itkFEMObjectFactory.h

Go to the documentation of this file.

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

  Program:   Insight Segmentation & Registration Toolkit
  Module:    $RCSfile: itkFEMObjectFactory.h,v $
  Language:  C++
  Date:      $Date: 2009-01-30 21:10:19 $
  Version:   $Revision: 1.20 $

  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 __itkFEMObjectFactory_h
#define __itkFEMObjectFactory_h

#include "itkFastMutexLock.h"
#include <string>
#include <vector>
#include <cstdlib>

namespace itk {
namespace fem {

template<class T>
class FEMObjectFactory
{

  typedef typename T::Pointer (*COF)();

  typedef std::string StrClassName;

  typedef std::vector<std::pair<COF,StrClassName> > COF_Array;
  typedef typename COF_Array::value_type COF_Array_value_type;

public:

  static typename T::Pointer Create(int id)
    {
    return (Instance().cofs_[id].first)();
    }

  static int Register(COF f, const char *str)
    {
    int clid=-1;
    Instance().m_MutexLock.Lock();
    Instance().cofs_.push_back( COF_Array_value_type(f,str) );
    clid = static_cast<int>( Instance().cofs_.size()-1 );
    Instance().m_MutexLock.Unlock();
    return clid;
    }

  static StrClassName ID2ClassName(int id)
    {
    return Instance().cofs_[id].second;
    }

  static int ClassName2ID(StrClassName str)
    {
    int j=0;
    for(typename COF_Array::const_iterator i=Instance().cofs_.begin(); i != Instance().cofs_.end(); i++)
      {
      if (i->second==str) return j;
      j++;
      }
    return -1;
    }

private:

  COF_Array cofs_;

  mutable SimpleFastMutexLock m_MutexLock;

  FEMObjectFactory();

  FEMObjectFactory(const FEMObjectFactory&);

  ~FEMObjectFactory();

  inline static FEMObjectFactory& Instance();

  static void CleanUP();

  static FEMObjectFactory* obj;

private:
  class Dummy {};

  friend class Dummy;

};


template<class T>
FEMObjectFactory<T>* FEMObjectFactory<T>::obj = 0;

template<class T>
FEMObjectFactory<T>::FEMObjectFactory() {}

template<class T>
FEMObjectFactory<T>::FEMObjectFactory(const FEMObjectFactory<T>&) {}

template<class T>
FEMObjectFactory<T>::~FEMObjectFactory() {}

extern "C"
{
  typedef void(*c_void_cast)();
}
template<class T>
FEMObjectFactory<T>& FEMObjectFactory<T>::Instance() 
{
  if (!obj) 
    { 
    obj=new FEMObjectFactory;

    atexit(reinterpret_cast<c_void_cast>(&CleanUP));

    }

  return *obj;
}

template<class T>
void FEMObjectFactory<T>::CleanUP() { delete obj; }

}} // end namespace itk::fem

#endif // #ifndef __itkFEMFEMObjectFactory_h