itkObjectFactoryBase.h

Go to the documentation of this file.

/*=========================================================================
 *
 *  Copyright NumFOCUS
 *
 *  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
 *
 *         https://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 "itkCommonEnums.h"
#include <list>
#include <memory> // For unique_ptr.
#include <vector>
 
namespace itk
{
class ITKCommon_EXPORT ObjectFactoryBase : public Object
{
public:
  ITK_DISALLOW_COPY_AND_MOVE(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 *);
 
  using InsertionPositionEnum = ObjectFactoryEnums::InsertionPosition;
#if !defined(ITK_LEGACY_REMOVE)
  // We need to expose the enum values at the class level
  // for backwards compatibility
  static constexpr InsertionPositionEnum INSERT_AT_FRONT = InsertionPositionEnum::INSERT_AT_FRONT;
  static constexpr InsertionPositionEnum INSERT_AT_BACK = InsertionPositionEnum::INSERT_AT_BACK;
  static constexpr InsertionPositionEnum INSERT_AT_POSITION = InsertionPositionEnum::INSERT_AT_POSITION;
#endif
 
  static bool
  RegisterFactory(ObjectFactoryBase *,
                  InsertionPositionEnum where = InsertionPositionEnum::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();
 
  template <typename TFactory>
  static void
  RegisterInternalFactoryOnce()
  {
    struct FactoryRegistration
    {};
 
    // Factory registration, made thread-safe by "magic statics" (as introduced with C++11).
    static const FactoryRegistration staticFactoryRegistration = [] {
      RegisterFactoryInternal(TFactory::New());
      return FactoryRegistration{};
    }();
 
    (void)staticFactoryRegistration;
  }
 
  static void
  Initialize();
 
protected:
  void
  PrintSelf(std::ostream & os, Indent indent) const override;
 
  void
  RegisterOverride(const char *               classOverride,
                   const char *               subclass,
                   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:
  // Forward reference because of private implementation
  class OverrideMap;
  class ObjectFactoryBasePrivate;
 
  static void
  SynchronizeObjectFactoryBase(void * objectFactoryBasePrivate);
  itkGetGlobalDeclarationMacro(ObjectFactoryBasePrivate, PimplGlobals);
  const std::unique_ptr<OverrideMap> m_OverrideMap;
 
  static void
  InitializeFactoryList();
 
  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