mlITKMLBaseWrapper.h

Go to the documentation of this file.

/*************************************************************************************
**
** Copyright 2007, MeVis Medical Solutions AG
**
** The user may use this file in accordance with the license agreement provided with
** the Software or, alternatively, in accordance with the terms contained in a
** written agreement between the user and MeVis Medical Solutions AG.
**
** For further information use the contact form at https://www.mevislab.de/contact
**
**************************************************************************************/
 
#pragma once
 
#include "mlInitSystemITKSupport.h"
 
#include "mlModuleIncludes.h"
 
ML_START_NAMESPACE
 
//----------------------------------------------------------------------------------
//----------------------------------------------------------------------------------
class MLITK_SUPPORT_EXPORT ITKWrapperBase : public Base
{
public:
  ITKWrapperBase(){};
 
protected:
  ML_ABSTRACT_CLASS_HEADER(ITKWrapperBase);
};
 
 
//----------------------------------------------------------------------------------
//----------------------------------------------------------------------------------
class WrapperSuperStructPtrs {
public:
  WrapperSuperStructPtrs(const std::string * const nameStringsArg, const WrapperSuperStructPtrs * const pSSArgs) :
     nameStrings(nameStringsArg), parentSuperStruct(pSSArgs) {}
 
  const std::string * const nameStrings;
 
  const WrapperSuperStructPtrs * const parentSuperStruct;
};
 
 
//----------------------------------------------------------------------------------
//----------------------------------------------------------------------------------
template<class OBJ_TYPE, typename OBJ_TYPE_POINTER, typename WRAPPER_CLASS_NAME> class ITKMLBaseWrapper
{
public:
 
  //----------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------
  ITKMLBaseWrapper(const WrapperSuperStructPtrs &parentSuperStruct, ITKWrapperBase &realWrapper) :
    _realWrapper(realWrapper), _wrapperSuperStructPtrs(&parentSuperStruct)
  {
    _outputBaseField = nullptr;
    _inputBaseField  = nullptr;
    _module          = nullptr;
    _outputObj       = nullptr;
    _inputObj        = nullptr;
    _numAddOutputBaseFieldCalls=0;
    _numAddInputBaseFieldCalls=0;
  }
 
  //----------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------
  virtual ~ITKMLBaseWrapper()
  {
    // Do nothing. The added base field will be destroyed by the Module
    // automatically and objects are destroyed automatically or by the application.
    // However this should not live longer than its referenced Module.
  }
 
  //----------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------
  void addOutputBaseField(Module &module, const char *outputFieldName)
  {
    if (!outputFieldName){
      ML_PRINT_ERROR("ITKMLBaseWrapper::addOutputBaseField", ML_BAD_POINTER_OR_0, "Passed field name pointer is nullptr. Ignoring call.");
      return;
    }
    if (_numAddOutputBaseFieldCalls!=0){
      ML_PRINT_ERROR("ITKMLBaseWrapper::addOutputBaseField", ML_BAD_STATE, "Ignoring multiple field add.");
      return;
    }
 
    _module = &module;
    _outputBaseField = module.addBase(outputFieldName);
    _outputBaseField->addAllowedType<ITKWrapperBase>();
    _outputBaseField->setBaseValue(&_realWrapper);
    ++_numAddOutputBaseFieldCalls;
  }
 
  //----------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------
  void addInputBaseField(Module &module, const char *inputFieldName)
  {
    if (!inputFieldName){
      ML_PRINT_ERROR("ITKMLBaseWrapper::addInputBaseField", ML_BAD_POINTER_OR_0, "Passed field name pointer is nullptr. Ignoring call.");
      return;
    }
    if (_numAddInputBaseFieldCalls!=0){
      ML_PRINT_ERROR("ITKMLBaseWrapper::addOutputBaseField", ML_BAD_STATE, "Ignoring multiple field add.");
      return;
    }
 
    _module = &module;
    _inputBaseField = module.addBase(inputFieldName);
    _inputBaseField->addAllowedType<ITKWrapperBase>();
    _inputBaseField->setBaseValue(nullptr);
    ++_numAddInputBaseFieldCalls;
  }
 
  //----------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------
  void setNewOutputBaseFieldObject(OBJ_TYPE_POINTER newObject)
  {
    _outputObj = newObject;
    if (_outputBaseField){ _outputBaseField->touch(); }
  }
 
  //----------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------
  BaseField *getOutputBaseField()
  {
    return _outputBaseField;
  }
 
  //----------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------
  BaseField *getInputBaseField()
  {
    return _inputBaseField;
  }
 
  //----------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------
  OBJ_TYPE_POINTER getWrappedOutputObject()
  {
    return _outputObj;
  }
 
  //----------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------
  bool hasSuperClass(const std::string &className) const
  {
    // Follow NameStrings and InheritrancePointer of class and super classes.
    // Terminated by return when class name matches or if className==parentClassName
    // in NameStrings. Termination criterion must be set correctly in Base classes
    // by specifying class name as super class name! Otherwise loop will not terminate.
    const WrapperSuperStructPtrs * follow = _wrapperSuperStructPtrs;
    do {
      if (follow->nameStrings[0] == className){ return true; }
      if (follow->nameStrings[0] == follow->nameStrings[1]){ return false; }
      follow = follow->parentSuperStruct;
    } while (1);
    return false;
  }
 
  /*---------------------------------------------------------------------------------- */
  /*---------------------------------------------------------------------------------- */
  OBJ_TYPE_POINTER getWrappedInputObject(const RuntimeType * /*rt*/ = nullptr)
  {
 
    if (_inputBaseField){
      /* Get the pointer to the connected object and check its type.*/
      /* If the type is valid then return a the pointer to the wrapped input object.*/
      // Get base object from connected input.
      Base *inPtr = _inputBaseField->getBaseValue();
 
      // Is it derived from ITKWrapperBase? If not then we cannot use it.
      ITKWrapperBase *wrapperBaseInPtr =
         ML_BASE_IS_A(inPtr, ITKWrapperBase) ?
         static_cast<ITKWrapperBase*>(inPtr) :
         nullptr;
      if (!wrapperBaseInPtr)
      { 
        return nullptr; 
      }
 
      // Create wrapper of correct type by typecasting.
      WRAPPER_CLASS_NAME *wrapper = wrapperBaseInPtr ? static_cast<WRAPPER_CLASS_NAME *>(wrapperBaseInPtr) : nullptr;
 
      // If wrapped object is derived from superclass then return casted pointer, otherwise return nullptr.
      return (wrapper && wrapper->hasSuperClass(wrapper->getName())) ? wrapper->getWrappedOutputObject() : nullptr;
    }
 
    /* No valid object connected to base field. */
    return nullptr;
  }
 
protected:
 
  Base &_realWrapper;
 
  const WrapperSuperStructPtrs *_wrapperSuperStructPtrs;
 
  BaseField                  *_outputBaseField;
 
  BaseField                  *_inputBaseField;
 
  Module                     *_module;
 
  OBJ_TYPE_POINTER            _outputObj;
 
  OBJ_TYPE_POINTER            _inputObj;
 
  MLint                       _numAddOutputBaseFieldCalls;
 
  MLint                       _numAddInputBaseFieldCalls;
};
 
 
//----------------------------------------------------------------------------------
//----------------------------------------------------------------------------------
#define ML_CREATE_BASE_WRAPPER_FOR_OBJECT_H(CLASS_NAME, CLASS_NAME_POINTER, WRAPPER_CLASS_NAME, PARENT_CLASS_NAME, ML_EXPORT_MACRO) \
 \
 \
/* Unified class which can be cast between all wrapped types. It accesses the internally specialized version */ \
/* of the wrapped class objects and checks for correct inheritance information.                              */ \
class ML_EXPORT_MACRO WRAPPER_CLASS_NAME : public ITKWrapperBase \
{ \
public: \
  /* Implement a constructor and call of superclass constructor. */ \
  WRAPPER_CLASS_NAME(); \
  \
  /* Destructor. */ \
  ~WRAPPER_CLASS_NAME(); \
  \
  /* Implemented in .cpp. This interface must not contain class specific code since */ \
  /* between all class wrapper this class wrapper it must be legal to cast it.      */ \
  /* For documentation of the following methods see ITKMLBaseWrapper.               */ \
  void               addOutputBaseField(Module &module, const char *outputFieldName); \
  void               addInputBaseField(Module &module, const char *inputFieldName); \
  void               setNewOutputBaseFieldObject(CLASS_NAME_POINTER newObject); \
  BaseField         *getOutputBaseField(); \
  BaseField         *getInputBaseField(); \
  CLASS_NAME_POINTER getWrappedOutputObject(); \
  CLASS_NAME_POINTER getWrappedInputObject(const RuntimeType * /*rt*/ = nullptr); \
  bool               hasSuperClass(const std::string &className) const; \
  const std::string &getName(); \
  \
  /* Pointer to the string names wrapped class and parent class. */\
  static const std::string         NameStrings[2]; \
  \
  \
  /* Reference the NameStrings for this class and for the parent class. */\
  static const WrapperSuperStructPtrs _wrapperSuperStructPtrs; \
  \
private: \
  \
  /* Incomplete pointer to internal object which contains type specific information. */ \
  void *_obj;\
  \
  /* The header part of the runtime type system interface. */  \
  ML_CLASS_HEADER(WRAPPER_CLASS_NAME); \
}; \
 
 
 
 
//----------------------------------------------------------------------------------
//----------------------------------------------------------------------------------
#define ML_CREATE_BASE_WRAPPER_FOR_OBJECT_CPP(CLASS_NAME, CLASS_NAME_POINTER, WRAPPER_CLASS_NAME, PARENT_CLASS_NAME, ML_EXPORT_MACRO) \
  \
  /* Pointer to the string names wrapped class and parent class. */\
  const std::string         WRAPPER_CLASS_NAME::NameStrings[2]         = { #CLASS_NAME, #PARENT_CLASS_NAME }; \
  \
  /* Reference the NameStrings for this class and for the parent class. */\
  const WrapperSuperStructPtrs WRAPPER_CLASS_NAME::_wrapperSuperStructPtrs(WRAPPER_CLASS_NAME::NameStrings, &PARENT_CLASS_NAME##Wrapper::_wrapperSuperStructPtrs); \
  \
  /* Implement a constructor and call of superclass constructor. */ \
  WRAPPER_CLASS_NAME::WRAPPER_CLASS_NAME(){ _obj = static_cast<void*>(new ITKMLBaseWrapper<CLASS_NAME, CLASS_NAME_POINTER, WRAPPER_CLASS_NAME>(WRAPPER_CLASS_NAME::_wrapperSuperStructPtrs, *this)); } \
  \
  /* Destructor. */ \
  WRAPPER_CLASS_NAME::~WRAPPER_CLASS_NAME(){ if (_obj){ delete (static_cast<ITKMLBaseWrapper<CLASS_NAME, CLASS_NAME_POINTER, WRAPPER_CLASS_NAME>*>(_obj)); _obj = nullptr; }; } \
  \
  /* For documentation of the following methods see ITKMLBaseWrapper.               */ \
  void                WRAPPER_CLASS_NAME::addOutputBaseField(Module &module, const char *outputFieldName){ (static_cast<ITKMLBaseWrapper<CLASS_NAME, CLASS_NAME_POINTER, WRAPPER_CLASS_NAME>*>(_obj))->addOutputBaseField(module, outputFieldName); } \
  void                WRAPPER_CLASS_NAME::addInputBaseField(Module &module, const char *inputFieldName)  { (static_cast<ITKMLBaseWrapper<CLASS_NAME, CLASS_NAME_POINTER, WRAPPER_CLASS_NAME>*>(_obj))->addInputBaseField(module, inputFieldName)  ; } \
  void                WRAPPER_CLASS_NAME::setNewOutputBaseFieldObject(CLASS_NAME_POINTER newObject)      { (static_cast<ITKMLBaseWrapper<CLASS_NAME, CLASS_NAME_POINTER, WRAPPER_CLASS_NAME>*>(_obj))->setNewOutputBaseFieldObject(newObject)     ; } \
  BaseField          *WRAPPER_CLASS_NAME::getOutputBaseField()                                           { return (static_cast<ITKMLBaseWrapper<CLASS_NAME, CLASS_NAME_POINTER, WRAPPER_CLASS_NAME>*>(_obj))->getOutputBaseField()                ; } \
  BaseField          *WRAPPER_CLASS_NAME::getInputBaseField()                                            { return (static_cast<ITKMLBaseWrapper<CLASS_NAME, CLASS_NAME_POINTER, WRAPPER_CLASS_NAME>*>(_obj))->getInputBaseField()                 ; } \
  CLASS_NAME_POINTER  WRAPPER_CLASS_NAME::getWrappedOutputObject()                                       { return (static_cast<ITKMLBaseWrapper<CLASS_NAME, CLASS_NAME_POINTER, WRAPPER_CLASS_NAME>*>(_obj))->getWrappedOutputObject()            ; } \
  CLASS_NAME_POINTER  WRAPPER_CLASS_NAME::getWrappedInputObject(const RuntimeType *rt)                   { return (static_cast<ITKMLBaseWrapper<CLASS_NAME, CLASS_NAME_POINTER, WRAPPER_CLASS_NAME>*>(_obj))->getWrappedInputObject(rt)           ; } \
  bool                WRAPPER_CLASS_NAME::hasSuperClass(const std::string &className) const              { return (static_cast<ITKMLBaseWrapper<CLASS_NAME, CLASS_NAME_POINTER, WRAPPER_CLASS_NAME>*>(_obj))->hasSuperClass(className)            ; } \
  \
  const std::string & WRAPPER_CLASS_NAME::getName()                                                      { return NameStrings[0]; }\
  \
  /* The .cpp part of the runtime type system interface. */ \
  ML_CLASS_SOURCE(WRAPPER_CLASS_NAME, ITKWrapperBase);   \
  \
 
ML_END_NAMESPACE