This class provides the functionality needed to apply the correct visitor function to object of some class. The specific visitor function is choosen, based on a given pointer to some object. More...

#include <itkVisitorDispatcher.h>

Collaboration diagram for itk::fem::VisitorDispatcher< TVisitedClass, TVisitorBase, TVisitFunctionPointerType >:

[legend]

List of all members.

Public Types
typedef int	ClassIDType
typedef TVisitedClass	VisitedClass
typedef VisitedClass::ConstPointer	VisitedClassConstPointer
typedef VisitedClass::Pointer	VisitedClassPointer
typedef TVisitFunctionPointerType	VisitFunctionPointerType
typedef TVisitorBase	VisitorBase
typedef VisitorBase::Pointer	VisitorBasePointer
typedef VisitorsArrayType::value_type	VisitorsArray_value_type
typedef std::map< ClassIDType, VisitFunctionPointerType >	VisitorsArrayType
Static Public Member Functions


template<class TVisitorClass >
static bool	RegisterVisitor (TVisitorClass *, VisitFunctionPointerType visitor_function)

static VisitFunctionPointerType	Visit (VisitorBasePointer l)

Detailed Description

template<class TVisitedClass, class TVisitorBase, class TVisitFunctionPointerType = typename VisitorDispatcherTemplateHelper<TVisitedClass, TVisitorBase>::FunctionPointerType>
class itk::fem::VisitorDispatcher< TVisitedClass, TVisitorBase, TVisitFunctionPointerType >

This class provides the functionality needed to apply the correct visitor function to object of some class. The specific visitor function is choosen, based on a given pointer to some object.

A visitor function is a function, that can perform various operations on objects of various classes. Usually we want this operation applied on any of the polymorphic derived classes. The specific operation is defined in visitor functions.

For example: calculating the area of Shape objects. In this case the function that calculates the area of a specific shape, is called the visitor function. A specific version of this function must be defined for each class, on which you want the perform the operation (Area(Circle*); Area(Square*); ...).

Now suppose that you want different operations performed on the shape objects. Which operation will be performed is specified by the class of the Visitor object. If the Visitor object is of class Area, then the area of objects will be calculated. If the visitor is object of class Circumference, then the circumference of the shapes will be calculated...

In order to be able to do that and provide the framework to easily add new Visitor as well as Visited classes, we create the VisitorDispatcher class. It is implemented as a singelton. It stores pointers to Visitor functions together with the information about which Visitor function must be called in order to perform an operation specified by Visitor class on objects of Visited class.

To make a specific base class and all its derived classes visitable, you must make the following changes to your code:

1. Declare the folowing virtual member function in the base class:

class BaseVisitable { ... virtual ReturnType AcceptVisitor( VisitorBase* ) = 0; ... };

2. Implement this function in ALL derived classes like this:

class MyVisitableClass : public BaseVisitable { ... virtual ReturnType AcceptVisitor( VisitorBase* l ) { return VisitorDispatcher<MyVisitableClass,VisitorBase,VisitFunctionPointerType>::Visit( <parameters> ); } ... };

Since this code is the same for all derived element classes, you should probably put it in the macro.

3. Register each visitor class with the VisitorDispatcher class before it is called. This is done by calling the member function RegisterVisitor of the VisitorDispatcher class and providing the pointer to the Visitor function that performs the required task. The visitor function must be declared according to the VisitFunctionPointerType template parameter.

ReturnType MyVisitor_Function( ... );

Once all this is done, you can perform various operations on objects of all derived classes by simply calling the Visit function on the pointer to base class and providing a pointer to the specific Visitor object:

object->AcceptVisitor(visitor);

The Visitor class is templated over several classes that make its use generic and simple.

TVisitedClass Class of objects that will be visited.

TVisitorBase Base class of Visitor objects. Objects of class TVisitedClass will be visited by object of any registered class that is derived from TVisitorBase.

TVisitFunctionPointerType Type of visit functions. Visitor dispatcher stores an array of pointers to these functions. Default function pointer type is provided.

Note:: Template parameter TVisitFunctionPointerType in general doesn't have to be a pointer to function. In fact, it can be any type Object of this type will be returned, when calling the VisitorDispatcher::Visit function.

Definition at line 131 of file itkVisitorDispatcher.h.