itkVisitorDispatcher.h

Go to the documentation of this file.

/*=========================================================================

  Program:   Insight Segmentation & Registration Toolkit
  Module:    $RCSfile: itkVisitorDispatcher.h,v $
  Language:  C++
  Date:      $Date: 2005-11-17 19:27:40 $
  Version:   $Revision: 1.23 $

  Copyright (c) Insight Software Consortium. All rights reserved.
  See ITKCopyright.txt or http://www.itk.org/HTML/Copyright.htm for details.

     This software is distributed WITHOUT ANY WARRANTY; without even 
     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR 
     PURPOSE.  See the above copyright notices for more information.

=========================================================================*/
#ifndef __VisitorDispatcher_h
#define __VisitorDispatcher_h

#include "itkFEMMacro.h"
#include "itkFEMException.h"
#include "itkFastMutexLock.h"
#include <typeinfo>
#include <map>

namespace itk {
namespace fem {

template< class TVisitedClass,
          class TVisitorBase>
class VisitorDispatcherTemplateHelper
{
public:
  typedef void (*FunctionPointerType )(typename TVisitedClass::ConstPointer, typename TVisitorBase::Pointer);
};
  



template< class TVisitedClass,
          class TVisitorBase,
          class TVisitFunctionPointerType= ITK_TYPENAME VisitorDispatcherTemplateHelper<TVisitedClass, TVisitorBase>::FunctionPointerType >
class VisitorDispatcher
{
public:

  typedef TVisitedClass VisitedClass;

  typedef TVisitorBase VisitorBase;

  typedef typename VisitedClass::Pointer VisitedClassPointer;
  typedef typename VisitedClass::ConstPointer VisitedClassConstPointer;
  typedef typename VisitorBase::Pointer VisitorBasePointer;



  typedef TVisitFunctionPointerType VisitFunctionPointerType;

  typedef int ClassIDType;

  typedef std::map<ClassIDType, VisitFunctionPointerType> VisitorsArrayType;
  typedef typename VisitorsArrayType::value_type VisitorsArray_value_type;

  template<class TVisitorClass>
  inline static bool RegisterVisitor(TVisitorClass*, VisitFunctionPointerType visitor_function)
  {
    typedef TVisitorClass VisitorClass;
    bool status;
    Instance().m_MutexLock.Lock();
    status=Instance().visitors.insert(VisitorsArray_value_type(VisitorClass::CLID(),visitor_function)).second;
    Instance().m_MutexLock.Unlock();
    if ( status )
    {
      // Visitor class was successfully registered
//      std::cout<<"Visitor "<<typeid(VisitorClass).name()<<" ("<<typeid(VisitedClass).name()<<") registered.\n";
//      std::cout<<"Visitor registered:\n  Visitee:"<<typeid(TVisitedClass).name()<<"\n  Visitor:"<<typeid(TVisitorClass).name()<<"\n  Func   :"<<typeid(VisitFunctionPointerType).name()<<"\n\n";
    }
    else
    {
      // The visitor function was already registered.
      // FIXME: implement the proper error handler if required
      std::cout<<"Warning: Visitor "<<typeid(VisitorClass).name()<<" that operates on objects of "<<typeid(VisitedClass).name()<<" was already registered! Ignoring the re-registration.\n";
    }
    return status;
  }

  static VisitFunctionPointerType Visit(VisitorBasePointer l);

private:

  static VisitorDispatcher& Instance();

  static void CleanUP(void) { delete obj; }

  static VisitorDispatcher* obj;

  VisitorsArrayType visitors;

  mutable SimpleFastMutexLock m_MutexLock;

};




template<class TVisitedClass, class TVisitorBase, class TVisitFunctionPointerType>
VisitorDispatcher<TVisitedClass, TVisitorBase, TVisitFunctionPointerType>*
VisitorDispatcher<TVisitedClass, TVisitorBase, TVisitFunctionPointerType>
::obj = 0;



extern "C"
{
  typedef void(*c_void_cast)();
}

template<class TVisitedClass, class TVisitorBase, class TVisitFunctionPointerType>
VisitorDispatcher<TVisitedClass, TVisitorBase, TVisitFunctionPointerType>&
VisitorDispatcher<TVisitedClass, TVisitorBase, TVisitFunctionPointerType>
::Instance()
{
  // Implementation of the singleton design pattern
  if (!obj) 
  { 
    // Create a new VisitorDispatcher object if we don't have it already.
    obj=new VisitorDispatcher;

    // Make sure that the object that we just created is also destroyed
    // when program finishes.
    atexit(reinterpret_cast<c_void_cast>(&CleanUP));
  }

  // Return the actual VisitorDispatcher object
  return *obj;
}




template<class TVisitedClass, class TVisitorBase, class TVisitFunctionPointerType>
typename VisitorDispatcher<TVisitedClass, TVisitorBase, TVisitFunctionPointerType>::VisitFunctionPointerType
VisitorDispatcher<TVisitedClass, TVisitorBase, TVisitFunctionPointerType>
::Visit(VisitorBasePointer l)
{
  typename VisitorsArrayType::const_iterator i = Instance().visitors.find(l->ClassID());
  if( i==Instance().visitors.end() )
  {
    // Visitor function not found... FIXME: write the proper error handler.
    std::cout<<"Error: Visitor "<<typeid(*l).name()<<" that operates on objects of "<<typeid(VisitedClass).name()<<" not found!\n";
    throw FEMException(__FILE__, __LINE__, "FEM error");
  }
  return i->second;
}




}} // end namespace itk::fem

#endif // __VisitorDispatcher_h

---