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 "itkSingletonMacro.h"
#include <list>
#include <vector>

namespace itk
{
// Forward reference because of private implementation
class OverRideMap;
struct ObjectFactoryBasePrivate;

class ITKCommon_EXPORT ObjectFactoryBase:public Object
{
public:
  ITK_DISALLOW_COPY_AND_ASSIGN(ObjectFactoryBase);

  using Self = ObjectFactoryBase;
  using Superclass = Object;
  using Pointer = SmartPointer< Self >;
  using ConstPointer = SmartPointer< const Self >;

  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() const = 0;

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

  virtual const char * GetDescription() 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:
  void PrintSelf(std::ostream & os, Indent indent) const 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();
  ~ObjectFactoryBase() override;

private:

  static void SynchronizeObjectFactoryBase(void * objectFactoryBasePrivate);
  itkGetGlobalDeclarationMacro(ObjectFactoryBasePrivate, PimplGlobals);

  OverRideMap *m_OverrideMap;

  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 ObjectFactoryBasePrivate * m_PimplGlobals;
};


} // end namespace itk

#endif