MeVis/Foundation/Sources/MLUtilities/mlBase.h

Go to the documentation of this file.

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

//-------------------------------------------------------------------------
#ifndef __mlBase_H
#define __mlBase_H

// Project-includes
#ifndef __mlUtilsSystem_H
#include "mlUtilsSystem.h"
#endif
#ifndef __mlRuntimeSubClass_H
#include "mlRuntimeSubClass.h"
#endif

#include "mlSystemWarningsDisable.h"
#include <vector>
#include "mlSystemWarningsRestore.h"

#define ML_SET_ADDSTATE_VERSION(v) static int getAddStateVersion(void) { return v; };

#define ML_PERSISTENCE_VERSION(v) ML_SET_ADDSTATE_VERSION(v)

ML_UTILS_START_NAMESPACE

class TreeNode;
class AbstractPersistenceOutputStream;
class AbstractPersistenceInputStream;

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

//----------------------------------------------------------------------
class ML_UTILS_EXPORT Base 
{
  
public:

  Base();

  virtual ~Base();



  enum PersistenceInterface {
    PersistenceByString,
    PersistenceByTreeNode,
    PersistenceByStream
  };

  virtual bool implementsPersistence(PersistenceInterface) const { return false; }

  virtual char* getPersistentState() const  ML_RETURN_VALUE_SHOULD_BE_USED { return 0; }

  virtual void setPersistentState(const char* /*state*/){ ; }

  virtual void clearPersistentState(char* /*state*/) const { ; }

  virtual void addStateToTree(TreeNode* /*parent*/) const { ; }

  virtual void readStateFromTree(TreeNode* /*parent*/) { ; }

  virtual void writeTo(AbstractPersistenceOutputStream* /*stream*/) const {}

  virtual void readFrom(AbstractPersistenceInputStream* /*stream*/, int /*version*/) {}

  ML_PERSISTENCE_VERSION(0);


  virtual Base* deepCopy() const { return NULL; };

  bool isOfAllowedType(const std::vector<const RuntimeType*>& types) const;

  virtual bool isRefCountedBase() const { return false; } 

  ML_ABSTRACT_CLASS_HEADER(Base)

};

ML_UTILS_END_NAMESPACE

#undef ML_BASE_VERSION


template<typename ToTypePtr>
inline ToTypePtr mlbase_cast(ML_UTILS_NAMESPACE::Base* from) {
  if (from) {
    if (from->getTypeId()->isDerivedFrom((static_cast<ToTypePtr>(0))->getClassTypeId())) {
      return static_cast<ToTypePtr>(from);
    } else {
      return NULL;
    }
  } else {
    return NULL;
  }
}

template<typename ToTypePtr>
inline ToTypePtr mlbase_cast(const ML_UTILS_NAMESPACE::Base* from) {
  if (from) {
    if (from->getTypeId()->isDerivedFrom((static_cast<ToTypePtr>(0))->getClassTypeId())) {
      return static_cast<ToTypePtr>(from);
    } else {
      return NULL;
    }
  } else {
    return NULL;
  }
}

#endif // __mlBase_H