Major refactoring

[FrontAlgorithms.git] / lib / fpa / Base / Events.h

diff --git a/lib/fpa/Base/Events.h b/lib/fpa/Base/Events.h
index c92c4dbc3051593f8e27cd15759510b110f6c40a..09f0637da4731445aff3c2304363aa18963529f4 100644 (file)
--- a/lib/fpa/Base/Events.h
+++ b/lib/fpa/Base/Events.h
@@ -4,15 +4,46 @@
 #include <vector>
 #include <itkProcessObject.h>
 
+// -------------------------------------------------------------------------
+#define fpa_Base_NewEvent( name )                               \
+  class name                                                    \
+    : public BaseEvent                                          \
+  {                                                             \
+  public:                                                       \
+    name( ) : BaseEvent( ) { }                                  \
+    virtual ~name( ) { }                                        \
+    const char* GetEventName( ) const                           \
+    { return( "fpa::Base::##name" ); }                          \
+    bool CheckEvent( const itk::EventObject* e ) const          \
+    { return( dynamic_cast< const name* >( e ) != NULL ); }     \
+    itk::EventObject* MakeObject( ) const                       \
+    { return( new name( ) ); }                                  \
+  };
+
+// -------------------------------------------------------------------------
+#define fpa_Base_NewEventWithVertex( name, type )               \
+  class name                                                    \
+    : public BaseEventWithVertex< type >                        \
+  {                                                             \
+  public:                                                       \
+    name( ) : BaseEventWithVertex< type >( ) { }                \
+    name( const type& v, long fid )                             \
+        : BaseEventWithVertex< type >( v, fid ) { }             \
+    virtual ~name( ) { }                                        \
+    const char* GetEventName( ) const                           \
+    { return( "fpa::Base::##name" ); }                          \
+    bool CheckEvent( const itk::EventObject* e ) const          \
+    { return( dynamic_cast< const name* >( e ) != NULL ); }     \
+    itk::EventObject* MakeObject( ) const                       \
+    { return( new name( ) ); }                                  \
+  };
+
 namespace fpa
 {
   namespace Base
   {
     /**
-     * Evolution event. An event is generated when a vertex changes its
-     * state.
      */
-    template< class N >
     class BaseEvent
       : public itk::AnyEvent
     {
@@ -20,171 +51,47 @@ namespace fpa
       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 ); }
+        { return( dynamic_cast< const BaseEvent* >( e ) != NULL ); }
       itk::EventObject* MakeObject( ) const
-        { return( new EndEvent< N >( ) ); }
+        { return( new BaseEvent( ) ); }
     };
 
     /**
      */
-    template< class N >
-    class BacktrackingEvent
-      : public BaseEvent< N >
+    template< class V >
+    class BaseEventWithVertex
+      : public BaseEvent
     {
     public:
-      BacktrackingEvent( )
-        : BaseEvent< N >( )
+      BaseEventWithVertex( )
+        : BaseEvent( )
         { }
-      BacktrackingEvent( const N& n, const unsigned long& id )
-        : BaseEvent< N >( n ),
-        BackId( id )
+      BaseEventWithVertex( const V& v, long fid )
+        : BaseEvent( ),
+          Vertex( v ),
+          FrontId( fid )
         { }
-      virtual ~BacktrackingEvent( )
+      virtual ~BaseEventWithVertex( )
         { }
       const char* GetEventName( ) const
-        { return( "fpa::Base::BacktrackingEvent" ); }
+        { return( "fpa::Base::BaseEventWithVertex" ); }
       bool CheckEvent( const itk::EventObject* e ) const
         {
           return(
-            dynamic_cast< const BacktrackingEvent< N >* >( e ) != NULL
+            dynamic_cast< const BaseEventWithVertex< V >* >( e ) != NULL
             );
         }
       itk::EventObject* MakeObject( ) const
-        { return( new BacktrackingEvent< N >( ) ); }
-
-      unsigned long BackId;
-    };
+        { return( new BaseEventWithVertex< V >( ) ); }
 
-    /**
-     */
-    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;
+      V Vertex;
+      long FrontId;
     };
 
   } // ecapseman