itkObjectFactoryBase.h

Go to the documentation of this file.

/*=========================================================================
 *
 *  Copyright Insight Software Consortium
 *
 *  Licensed under the Apache License, Version 2.0 (the "License");
 *  you may not use this file except in compliance with the License.
 *  You may obtain a copy of the License at
 *
 *         http://www.apache.org/licenses/LICENSE-2.0.txt
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 *
 *=========================================================================*/
/*=========================================================================
 *
 *  Portions of this file are subject to the VTK Toolkit Version 3 copyright.
 *
 *  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
 *
 *  For complete copyright, license and disclaimer of warranty information
 *  please refer to the NOTICE file at the top of the ITK source tree.
 *
 *=========================================================================*/
#ifndef itkObjectFactoryBase_h
#define itkObjectFactoryBase_h

#include "itkCreateObjectFunction.h"
#include <list>
#include <vector>

namespace itk
{
class OverRideMap;

class ITKCommon_EXPORT ObjectFactoryBase:public Object
{
public:
  typedef ObjectFactoryBase          Self;
  typedef Object                     Superclass;
  typedef SmartPointer< Self >       Pointer;
  typedef SmartPointer< const Self > ConstPointer;

  itkTypeMacro(ObjectFactoryBase, Object);

  static LightObject::Pointer CreateInstance(const char *itkclassname);

  static std::list< LightObject::Pointer >
  CreateAllInstance(const char *itkclassname);

  static void ReHash();

  static void RegisterFactoryInternal(ObjectFactoryBase *);

  typedef enum
    {
    INSERT_AT_FRONT,
    INSERT_AT_BACK,
    INSERT_AT_POSITION
    }  InsertionPositionType;

  static bool RegisterFactory(ObjectFactoryBase *,
    InsertionPositionType where=INSERT_AT_BACK, size_t position = 0);

  static void UnRegisterFactory(ObjectFactoryBase *);

  static void UnRegisterAllFactories();

  static std::list< ObjectFactoryBase * > GetRegisteredFactories();

  virtual const char * GetITKSourceVersion(void) const = 0;

  static void SetStrictVersionChecking( bool );
  static void StrictVersionCheckingOn();
  static void StrictVersionCheckingOff();
  static bool GetStrictVersionChecking();

  virtual const char * GetDescription(void) const = 0;

  virtual std::list< std::string > GetClassOverrideNames();

  virtual std::list< std::string > GetClassOverrideWithNames();

  virtual std::list< std::string > GetClassOverrideDescriptions();

  virtual std::list< bool > GetEnableFlags();

  virtual void SetEnableFlag(bool flag,
                             const char *className,
                             const char *subclassName);

  virtual bool GetEnableFlag(const char *className,
                             const char *subclassName);

  virtual void Disable(const char *className);

  const char * GetLibraryPath();

  struct OverrideInformation {
    std::string m_Description;
    std::string m_OverrideWithName;
    bool m_EnabledFlag;
    CreateObjectFunctionBase::Pointer m_CreateObject;
  };

protected:
  virtual void PrintSelf(std::ostream & os, Indent indent) const ITK_OVERRIDE;

  void RegisterOverride(const char *classOverride,
                        const char *overrideClassName,
                        const char *description,
                        bool enableFlag,
                        CreateObjectFunctionBase *createFunction);

  virtual LightObject::Pointer CreateObject(const char *itkclassname);

  virtual std::list< LightObject::Pointer >
  CreateAllObject(const char *itkclassname);

  ObjectFactoryBase();
  virtual ~ObjectFactoryBase();

private:
  OverRideMap *m_OverrideMap;

  ObjectFactoryBase(const Self &); //purposely not implemented
  void operator=(const Self &);    //purposely not implemented

  static void InitializeFactoryList();

  static void Initialize();

  static void RegisterInternal();

  static void LoadDynamicFactories();

  static void LoadLibrariesInPath(const char *);

  static void DeleteNonInternalFactory(  ObjectFactoryBase * );

  void *        m_LibraryHandle;
  unsigned long m_LibraryDate;
  std::string   m_LibraryPath;

  static  bool  m_StrictVersionChecking;
};
} // end namespace itk

#endif