mlBase.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_BASE_H
#define ML_BASE_H
 
 
// Project-includes
#include "mlUtilsSystem.h"
#include "mlRuntimeSubClass.h"
#include "mlRuntime.h"
 
#include <ThirdPartyWarningsDisable.h>
#include <string>
#include <vector>
#if ML_DEPRECATED_SINCE(3,5,0)
  #include <memory>
#endif
#include <ThirdPartyWarningsRestore.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();
 
  struct StateDeleter
  {
    const Base* _this{};
#if ML_DEPRECATED_SINCE(3,5,0)
    void operator()(char* ) const {}
#else
    void operator()(char* p) const
    {
      _this->clearPersistentState(p);
    }
#endif
  };
 
 
 
  enum PersistenceInterface {
    PersistenceByString,
    PersistenceByTreeNode,
    PersistenceByStream
  };
 
  virtual bool implementsPersistence(PersistenceInterface) const { return false; }
 
  virtual std::string persistentState() const;
 
  virtual void setPersistentState(const std::string& state);
 
#if !ML_DEPRECATED_SINCE(3,5,0)
protected:
#endif
 
  [[nodiscard]]
  [[deprecated]] virtual char* getPersistentState() const { return nullptr; }
 
  [[deprecated]] virtual void setPersistentState(const char* /*state*/){ }
 
  [[deprecated]] virtual void clearPersistentState(char* /*state*/) const { }
#if !ML_DEPRECATED_SINCE(3,5,0)
public:
#endif
 
 
  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 nullptr; };
 
  bool isOfAllowedType(const std::vector<const RuntimeType*>& types) const;
 
  virtual bool isRefCountedBase() const { return false; }
 
  virtual std::string detailString() const { return std::string(); }
 
  ML_ABSTRACT_ROOT_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