MeVisLab/Standard/Sources/ML/MLBase/mlCopyBase.h

Go to the documentation of this file.

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

//----------------------------------------------------------------------------------



#ifndef __mlCopyBase_H
#define __mlCopyBase_H


// ML includes
#ifndef __mlModuleIncludes_H
#include "mlModuleIncludes.h"
#endif
#ifndef __mlEngine_H
#include "mlEngine.h"
#endif

// Local includes
#ifndef __mlBaseInit_H
#include "mlBaseInit.h"
#endif
#ifndef __mlListBase_H
#include "mlListBase.h"
#endif

ML_START_NAMESPACE


// ------------------------------------------------------------------
// ------------------------------------------------------------------
template <class BASE_DERIVED_CLASS>
class MLBASEEXPORT CopyBase : public Engine
{
    
public:
    
    CopyBase();
    
    ~CopyBase();  
    
    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;
    
    
    virtual void handleNotification(Field* field);
    
    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(NULL),
_lockNotification(1)
{
    FieldContainer* fields = getFieldContainer();
    
    // add fields and assign default values:

    _fldInputBase         = fields->addBase("inObject");//)->setBaseValue(NULL);
    (_fldOutputBase       = fields->addBase("outObject"))->setBaseValue(NULL);
    (_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 NULL;
    } 
    
    // 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 NULL;
    }
    
    _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 = NULL;
    
    // check if object is present and has correct type:
    if (!checkObjectType(inputObject)) {
        setNewOutputObject(NULL);
        _fldUpToDate->setBoolValue(inputObject == NULL);      
        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(NULL);  
        
        ML_DELETE(_outputObject);
    }   
}


//------------------------------------------------------------------------------------------
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() == NULL);        
            
        }
        
        // update button pressed
        if (field == _fldUpdate) {
            copyObject();
        }
        
        --_lockNotification;
    }  
}


ML_END_NAMESPACE

#endif // __mlCopyBase_H