mlCopyBase.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
**
**************************************************************************************/
 
#ifndef ML_COPY_BASE_H
#define ML_COPY_BASE_H
 
 
 
// ML includes
#include "mlModuleIncludes.h"
#include "mlEngine.h"
 
 
#include "mlBaseInit.h"
#include "mlListBase.h"
 
ML_START_NAMESPACE
 
 
// ------------------------------------------------------------------
// ------------------------------------------------------------------
template <class BASE_DERIVED_CLASS>
class MLBASEEXPORT CopyBase : public Engine
{
 
public:
 
    CopyBase();
 
    ~CopyBase() override;
 
    void copyObject();
 
    void deleteObject();
 
    typedef enum {
        AutoUpdateModeDoNothing = 0,
            AutoUpdateModeAutoClear,
            AutoUpdateModeAutoUpdate,
            AutoUpdateModeCount
    } AutoUpdateMode;
 
    static const char* autoUpdateModeNames[];
 
protected:
 
 
 
    BaseField*    _fldInputBase;
 
    BaseField*    _fldOutputBase;
 
    StringField*  _fldObjectType;
 
    StringField*  _fldStatusString;
 
    BoolField*    _fldUpToDate;
 
    EnumField*    _fldAutoUpdateMode;
 
    NotifyField*  _fldUpdate;
 
    NotifyField*  _fldClear;
 
 
    void handleNotification(Field* field) override;
 
    void setNewOutputObject(BASE_DERIVED_CLASS* newOutObject);
 
    const RuntimeType* checkObjectType(const Base* inputObject) const;
 
    Base* _outputObject;
 
private:
 
    //------------------------------------------------------------------------------------
    //------------------------------------------------------------------------------------
    CopyBase(const CopyBase &) : Engine(0,0)
    {
        ML_PRINT_FATAL_ERROR("CopyBase::CopyBase(const CopyBase &)",
            ML_PROGRAMMING_ERROR,
            "Usage of copy constructor of CopyBase is not supported.");
    }
 
    //------------------------------------------------------------------------------------
    //------------------------------------------------------------------------------------
    CopyBase& operator=(const CopyBase &)
    {
        ML_PRINT_FATAL_ERROR("CopyBase& CopyBase::operator=(const CopyBase &)",
            ML_PROGRAMMING_ERROR,
            "Usage of assignment operator of CopyBase is not supported.");
        return *this;
    }
 
    int _lockNotification;
 
    //ML_MODULE_CLASS_HEADER(CopyBase);
 
};
 
 
 
 
//------------------------------------------------------------------------------------------
 
class MLBASEEXPORT CopyList : public CopyBase<ListBase>
{
 
    CopyList() : CopyBase<ListBase>(){}
 
    // TODO: Add support for event copying (instead of always copying the entire list)
  private:
 
    ML_MODULE_CLASS_HEADER(CopyList);
};
 
 
 
 
 
//------------------------------------------------------------------------------------------
// implementation follows here in header because of problems with template class implementations in cpp files
// in VC 6.0
 
//------------------------------------------------------------------------------------------
// CLASS CopyBase<>
//------------------------------------------------------------------------------------------
 
//------------------------------------------------------------------------------------------
template <class BASE_DERIVED_CLASS>
const char* CopyBase<BASE_DERIVED_CLASS>::autoUpdateModeNames[] = {
    "Off",
    "AutoClear",
    "AutoUpdate"
};
 
 
//------------------------------------------------------------------------------------------
template <class BASE_DERIVED_CLASS>
CopyBase<BASE_DERIVED_CLASS>::CopyBase()
: Engine(),
_outputObject(nullptr),
_lockNotification(1)
{
    FieldContainer* fields = getFieldContainer();
 
    // add fields and assign default values:
 
    _fldInputBase         = fields->addBase("inObject");//)->setBaseValue(NULL);
    (_fldOutputBase       = fields->addBase("outObject"))->setBaseValue(nullptr);
    (_fldAutoUpdateMode   = fields->addEnum("updateMode", autoUpdateModeNames, AutoUpdateModeCount))->setEnumValue(AutoUpdateModeAutoUpdate);
    (_fldStatusString     = fields->addString("status"))->setStringValue("ok.");
 
    (_fldUpToDate         = fields->addBool("upToDate"))->setBoolValue(true);
    (_fldObjectType       = fields->addString("objectType"))->setStringValue("(NULL)");
    _fldUpdate = fields->addNotify("update");
    _fldClear  = fields->addNotify("clear");
    _lockNotification = 0;
}
 
 
//------------------------------------------------------------------------------------------
template <class BASE_DERIVED_CLASS>
CopyBase<BASE_DERIVED_CLASS>::~CopyBase()
{
    deleteObject();
}
 
//------------------------------------------------------------------------------------------
template <class BASE_DERIVED_CLASS>
const RuntimeType* CopyBase<BASE_DERIVED_CLASS>::checkObjectType(const Base* inputObject) const {
 
    // check if object is present
    if (!inputObject) {
        _fldObjectType->setStringValue("(NULL)");
        _fldStatusString->setStringValue("No input object detected.");
        return nullptr;
    }
 
    // check type
    const RuntimeType* inType = inputObject->getTypeId();
    if (!inType || !inType->canCreateInstance() || !inType->isDerivedFrom(BASE_DERIVED_CLASS::getClassTypeId())) {
        _fldObjectType->setStringValue("(INVALID TYPE)");
        _fldStatusString->setStringValue("Error: Invalid input object type.");
        return nullptr;
    }
 
    _fldObjectType->setStringValue(inType->getName());
    _fldStatusString->setStringValue("Input Object Valid.");
 
    return inType;
}
 
//------------------------------------------------------------------------------------------
template <class BASE_DERIVED_CLASS>
void CopyBase<BASE_DERIVED_CLASS>::copyObject()
{
    // first delete any existing object:
    deleteObject();
 
    Base* inputObject = _fldInputBase->getBaseValue();
    BASE_DERIVED_CLASS* outputObject = nullptr;
 
    // check if object is present and has correct type:
    if (!checkObjectType(inputObject)) {
        setNewOutputObject(nullptr);
        _fldUpToDate->setBoolValue(inputObject == nullptr);
        return;
    }
 
    // copy object
    outputObject = static_cast<BASE_DERIVED_CLASS*>(inputObject)->clone();
 
    // update output
    setNewOutputObject(outputObject);
    _fldUpToDate->setBoolValue(true);
    _fldStatusString->setStringValue("ok.");
}
 
 
 
//------------------------------------------------------------------------------------------
template <class BASE_DERIVED_CLASS>
void CopyBase<BASE_DERIVED_CLASS>::setNewOutputObject(BASE_DERIVED_CLASS* newOutObject)
{
    _outputObject = newOutObject;
    _fldOutputBase->setBaseValue(_outputObject);
}
 
 
 
//------------------------------------------------------------------------------------------
template <class BASE_DERIVED_CLASS>
void CopyBase<BASE_DERIVED_CLASS>::deleteObject()
{
    if (_outputObject) {
        _fldOutputBase->setBaseValue(nullptr);
 
        delete _outputObject;
 
        _outputObject = nullptr;
    }
}
 
 
//------------------------------------------------------------------------------------------
template <class BASE_DERIVED_CLASS>
void CopyBase<BASE_DERIVED_CLASS>::handleNotification(Field* field)
{
    if (!_lockNotification) {
        ++_lockNotification;
 
        // output touched, output object possibly modified
        if (field == _fldOutputBase) {
            _fldUpToDate->setBoolValue(false);
            _fldStatusString->setStringValue("Output externally touched, possibly modified.");
        }
 
        // input touched
        if (field == _fldInputBase) {
            switch (_fldAutoUpdateMode->getEnumValue()) {
            case AutoUpdateModeDoNothing:
                checkObjectType(_fldInputBase->getBaseValue());
                _fldUpToDate->setBoolValue(false);
                break;
            case AutoUpdateModeAutoClear:
                checkObjectType(_fldInputBase->getBaseValue());
                // initiate clear
                field = _fldClear;
                break;
            case AutoUpdateModeAutoUpdate:
                // initiate update
                field = _fldUpdate;
                break;
            default:
              ML_PRINT_FATAL_ERROR("void CopyBase<BASE_DERIVED_CLASS>::handleNotification(Field* field)", ML_BAD_PARAMETER, "Clearing output!");
              field = _fldClear;
              break;
            }
        }
 
 
        // clear button pressed
        if (field == _fldClear) {
            deleteObject();
            _fldStatusString->setStringValue("Output object deleted.");
            _fldUpToDate->setBoolValue(_fldInputBase->getBaseValue() == nullptr);
 
        }
 
        // update button pressed
        if (field == _fldUpdate) {
            copyObject();
        }
 
        --_lockNotification;
    }
}
 
 
ML_END_NAMESPACE
 
#endif // __mlCopyBase_H