FMEwork/VTK/Sources/VTK/MLVTK/VTKSupport/mlVTKMLBaseWrapper.h

Go to the documentation of this file.

// **InsertLicense** code
//----------------------------------------------------------------------------------

//----------------------------------------------------------------------------------
#ifndef __mlVTKMLBaseWrapper_H
#define __mlVTKMLBaseWrapper_H

#include "mlInitSystemVTKSupport.h"

#ifndef __mlModuleIncludes_H
#include "mlModuleIncludes.h"
#endif


ML_START_NAMESPACE

//----------------------------------------------------------------------------------
//----------------------------------------------------------------------------------
class MLVTK_SUPPORT_EXPORT VTKWrapperBase : public Base
{
public:
  VTKWrapperBase(){};

protected:
  ML_ABSTRACT_CLASS_HEADER(VTKWrapperBase);
};


//----------------------------------------------------------------------------------
//----------------------------------------------------------------------------------
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 VTKMLBaseWrapper
{
public:

  //----------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------
  VTKMLBaseWrapper(const WrapperSuperStructPtrs &parentSuperStruct, VTKWrapperBase &realWrapper) :
    _realWrapper(realWrapper), _wrapperSuperStructPtrs(&parentSuperStruct)
  {
    _outputBaseField = NULL;
    _inputBaseField  = NULL;
    _module          = NULL;
    _outputObj       = NULL;
    _inputObj        = NULL;
    _numAddOutputBaseFieldCalls=0;
    _numAddInputBaseFieldCalls=0;
  }

  //----------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------
  virtual ~VTKMLBaseWrapper()
  {
    // 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("VTKMLBaseWrapper::addOutputBaseField", ML_BAD_POINTER_OR_0, "Passed field name pointer is NULL. Ignoring call.");
      return;
    }
    if (_numAddOutputBaseFieldCalls!=0){
      ML_PRINT_ERROR("VTKMLBaseWrapper::addOutputBaseField", ML_BAD_STATE, "Ignoring multiple field add.");
      return;
    }

    _module = &module;
    _outputBaseField = module.addBase(outputFieldName);
    _outputBaseField->setBaseValue(&_realWrapper);
    ++_numAddOutputBaseFieldCalls;
  }

  //----------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------
  void addInputBaseField(Module &module, const char *inputFieldName)
  {
    if (!inputFieldName){
      ML_PRINT_ERROR("VTKMLBaseWrapper::addInputBaseField", ML_BAD_POINTER_OR_0, "Passed field name pointer is NULL. Ignoring call.");
      return;
    }
    if (_numAddInputBaseFieldCalls!=0){
      ML_PRINT_ERROR("VTKMLBaseWrapper::addOutputBaseField", ML_BAD_STATE, "Ignoring multiple field add.");
      return;
    }

    _module = &module;
    _inputBaseField = module.addBase(inputFieldName);
    _inputBaseField->setBaseValue(NULL);
    ++_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*/ = NULL)
  {

    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 VTKWrapperBase? If not then we cannot use it.
      VTKWrapperBase *wrapperBaseInPtr =
         ML_BASE_IS_A(inPtr, VTKWrapperBase) ?
         static_cast<VTKWrapperBase*>(inPtr) :
         NULL;
      if (!wrapperBaseInPtr){ return NULL; }

      // Create wrapper of correct type by typecasting.
      WRAPPER_CLASS_NAME *wrapper = wrapperBaseInPtr ? static_cast<WRAPPER_CLASS_NAME *>(wrapperBaseInPtr) : NULL;

      // If wrapped object is derived from superclass then return casted pointer, otherwise return NULL.
      return (wrapper && wrapper->hasSuperClass(wrapper->getName())) ? wrapper->getWrappedOutputObject() : NULL;
    }

    /* No valid object connected to base field. */
    return NULL;
  }

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 VTKWrapperBase \
{ \
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 VTKMLBaseWrapper.               */ \
  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*/ = NULL); \
  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 VTKMLBaseWrapper<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<VTKMLBaseWrapper<CLASS_NAME, CLASS_NAME_POINTER, WRAPPER_CLASS_NAME>*>(_obj)); _obj = NULL; }; } \
  \
  /* For documentation of the following methods see VTKMLBaseWrapper.               */ \
  void                WRAPPER_CLASS_NAME::addOutputBaseField(Module &module, const char *outputFieldName){ (static_cast<VTKMLBaseWrapper<CLASS_NAME, CLASS_NAME_POINTER, WRAPPER_CLASS_NAME>*>(_obj))->addOutputBaseField(module, outputFieldName); } \
  void                WRAPPER_CLASS_NAME::addInputBaseField(Module &module, const char *inputFieldName)  { (static_cast<VTKMLBaseWrapper<CLASS_NAME, CLASS_NAME_POINTER, WRAPPER_CLASS_NAME>*>(_obj))->addInputBaseField(module, inputFieldName)  ; } \
  void                WRAPPER_CLASS_NAME::setNewOutputBaseFieldObject(CLASS_NAME_POINTER newObject)      { (static_cast<VTKMLBaseWrapper<CLASS_NAME, CLASS_NAME_POINTER, WRAPPER_CLASS_NAME>*>(_obj))->setNewOutputBaseFieldObject(newObject)     ; } \
  BaseField          *WRAPPER_CLASS_NAME::getOutputBaseField()                                           { return (static_cast<VTKMLBaseWrapper<CLASS_NAME, CLASS_NAME_POINTER, WRAPPER_CLASS_NAME>*>(_obj))->getOutputBaseField()                ; } \
  BaseField          *WRAPPER_CLASS_NAME::getInputBaseField()                                            { return (static_cast<VTKMLBaseWrapper<CLASS_NAME, CLASS_NAME_POINTER, WRAPPER_CLASS_NAME>*>(_obj))->getInputBaseField()                 ; } \
  CLASS_NAME_POINTER  WRAPPER_CLASS_NAME::getWrappedOutputObject()                                       { return (static_cast<VTKMLBaseWrapper<CLASS_NAME, CLASS_NAME_POINTER, WRAPPER_CLASS_NAME>*>(_obj))->getWrappedOutputObject()            ; } \
  CLASS_NAME_POINTER  WRAPPER_CLASS_NAME::getWrappedInputObject(const RuntimeType *rt)                   { return (static_cast<VTKMLBaseWrapper<CLASS_NAME, CLASS_NAME_POINTER, WRAPPER_CLASS_NAME>*>(_obj))->getWrappedInputObject(rt)           ; } \
  bool                WRAPPER_CLASS_NAME::hasSuperClass(const std::string &className) const              { return (static_cast<VTKMLBaseWrapper<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, VTKWrapperBase);   \
  \



ML_END_NAMESPACE

#endif