#ifndef __FPA__BASE__EVENTS__H__
#define __FPA__BASE__EVENTS__H__

#include <vector>
#include <itkProcessObject.h>

namespace fpa
{
  namespace Base
  {
    /**
     * Evolution event. An event is generated when a vertex changes its
     * state.
     */
    template< class N >
    class BaseEvent
      : public itk::AnyEvent
    {
    public:
      BaseEvent( )
        : itk::AnyEvent( )
        { }
      BaseEvent( const N& n )
        : itk::AnyEvent( ),
          Node( n )
        { }
      virtual ~BaseEvent( )
        { }

      const char* GetEventName( ) const
        { return( "fpa::Base::BaseEvent" ); }
      bool CheckEvent( const itk::EventObject* e ) const
        { return( dynamic_cast< const BaseEvent< N >* >( e ) != NULL ); }
      itk::EventObject* MakeObject( ) const
        { return( new BaseEvent< N >( ) ); }

    public:
      N Node;
    };

    /**
     */
    template< class N >
    class FrontEvent
      : public BaseEvent< N >
    {
    public:
      FrontEvent( )
        : BaseEvent< N >( )
        { }
      FrontEvent( const N& n )
        : BaseEvent< N >( n )
        { }
      virtual ~FrontEvent( )
        { }
      const char* GetEventName( ) const
        { return( "fpa::Base::FrontEvent" ); }
      bool CheckEvent( const itk::EventObject* e ) const
        { return( dynamic_cast< const FrontEvent< N >* >( e ) != NULL ); }
      itk::EventObject* MakeObject( ) const
        { return( new FrontEvent< N >( ) ); }
    };

    /**
     */
    template< class N >
    class MarkEvent
      : public BaseEvent< N >
    {
    public:
      MarkEvent( )
        : BaseEvent< N >( )
        { }
      MarkEvent( const N& n )
        : BaseEvent< N >( n )
        { }
      virtual ~MarkEvent( )
        { }
      const char* GetEventName( ) const
        { return( "fpa::Base::MarkEvent" ); }
      bool CheckEvent( const itk::EventObject* e ) const
        { return( dynamic_cast< const MarkEvent< N >* >( e ) != NULL ); }
      itk::EventObject* MakeObject( ) const
        { return( new MarkEvent< N >( ) ); }
    };

    /**
     */
    template< class N >
    class CollisionEvent
      : public BaseEvent< N >
    {
    public:
      CollisionEvent( )
        : BaseEvent< N >( )
        { }
      CollisionEvent( const N& n )
        : BaseEvent< N >( n )
        { }
      virtual ~CollisionEvent( )
        { }
      const char* GetEventName( ) const
        { return( "fpa::Base::CollisionEvent" ); }
      bool CheckEvent( const itk::EventObject* e ) const
        { return( dynamic_cast< const CollisionEvent< N >* >( e ) != NULL ); }
      itk::EventObject* MakeObject( ) const
        { return( new CollisionEvent< N >( ) ); }
    };

    /**
     */
    template< class N >
    class EndEvent
      : public BaseEvent< N >
    {
    public:
      EndEvent( )
        : BaseEvent< N >( )
        { }
      virtual ~EndEvent( )
        { }
      const char* GetEventName( ) const
        { return( "fpa::Base::EndEvent" ); }
      bool CheckEvent( const itk::EventObject* e ) const
        { return( dynamic_cast< const EndEvent< N >* >( e ) != NULL ); }
      itk::EventObject* MakeObject( ) const
        { return( new EndEvent< N >( ) ); }
    };

    /**
     */
    template< class N >
    class BacktrackingEvent
      : public BaseEvent< N >
    {
    public:
      BacktrackingEvent( )
        : BaseEvent< N >( )
        { }
      BacktrackingEvent( const N& n, const unsigned long& id )
        : BaseEvent< N >( n ),
        BackId( id )
        { }
      virtual ~BacktrackingEvent( )
        { }
      const char* GetEventName( ) const
        { return( "fpa::Base::BacktrackingEvent" ); }
      bool CheckEvent( const itk::EventObject* e ) const
        {
          return(
            dynamic_cast< const BacktrackingEvent< N >* >( e ) != NULL
            );
        }
      itk::EventObject* MakeObject( ) const
        { return( new BacktrackingEvent< N >( ) ); }

      unsigned long BackId;
    };

    /**
     */
    template< class N >
    class EndBacktrackingEvent
      : public BaseEvent< N >
    {
    public:
      EndBacktrackingEvent( )
        : BaseEvent< N >( )
        { }
      EndBacktrackingEvent( const unsigned long& id )
        : BaseEvent< N >( ),
        BackId( id )
        { }
      virtual ~EndBacktrackingEvent( )
        { }
      const char* GetEventName( ) const
        { return( "fpa::Base::EndBacktrackingEvent" ); }
      bool CheckEvent( const itk::EventObject* e ) const
        {
          return(
            dynamic_cast< const EndBacktrackingEvent< N >* >( e ) != NULL
            );
        }
      itk::EventObject* MakeObject( ) const
        { return( new EndBacktrackingEvent< N >( ) ); }

      unsigned long BackId;
    };

  } // ecapseman

} // ecapseman

#endif // __FPA__BASE__EVENTS__H__

// eof - $RCSfile$