mlTreeNode.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_TREE_NODE_H
#define ML_TREE_NODE_H
 
 
#include "mlImageVector.h"
#include "mlInitSystemML.h"
#include "mlRuntimeType.h"
#include "mlRuntimeSubClass.h"
#include "mlSubImageBox.h"
#include "mlVector2.h"
#include "mlVector3.h"
#include "mlVector4.h"
#include "mlVector6.h"
 
#include <string>
 
ML_START_NAMESPACE
 
class Base;
class SubImageBoxd;
 
//---------------------------------------------------------------------------------
//---------------------------------------------------------------------------------
enum {
  TNE_VoidImplementation,
  TNE_NotSupported,
  TNE_ChildNotFound,
  TNE_AddingBase,
  TNE_ReadingBase,
  TNE_ReadingUChar,
  TNE_ReadingChar,
  TNE_ReadingUShort,
  TNE_ReadingShort,
  TNE_ReadingUInt,
  TNE_ReadingInt,
  TNE_ReadingULong,
  TNE_ReadingLong,
  TNE_ReadingFloat,
  TNE_ReadingDouble,
  TNE_ReadingLDouble,
  TNE_ReadingString,
  TNE_ReadingVector2,
  TNE_ReadingVector3,
  TNE_ReadingVector4,
  TNE_ReadingVector6,
  TNE_ReadingImageVector,
  TNE_ReadingMatrix3,
  TNE_ReadingMatrix4,
  TNE_ReadingSubImageBox,
  TNE_ReadingSubImageBoxd,
  TNE_InvalidReadNext,
  TNE_InvalidParentNode,
  TNE_FileNotFound,
  TNE_ReadingFile,
  TNE_WritingFile,
  TNE_UnsupportedClassVersion,
  TNE_UserDefined,
  TNE_Unknown,
  TNE_ReadingMLint64,
  TNE_ReadingMLuint64,
 
  TNE_COUNT
};
 
 
//---------------------------------------------------------------------------------
//---------------------------------------------------------------------------------
class MLEXPORT TreeNodeException
{
 
public:
 
 
  TreeNodeException(int errorCode = 0, const char* msg = nullptr);
 
  virtual ~TreeNodeException() { }
 
  int                 getCode()    const { return _errorCode; }
 
 
  virtual const char* getMessage() const;
 
protected:
 
  int                   _errorCode;
 
private:
 
  std::string _message;
 
  static const char*    _stdErrorMsg[];
 
  ML_ROOT_CLASS_HEADER(TreeNodeException)
};
 
 
#define TREE_NODE_CHECK_THROW(x) { if (!(x)) throw TreeNodeException(TNE_UserDefined, #x); }
 
 
 
class MLEXPORT TreeNode {
 
 
public:
 
  // Define macros for default implementations:
 
#define VOID_IMPLEMENTATION(which)     { throw TreeNodeException(TNE_VoidImplementation, which); }
 
#define VOID_IMPLEMENTATION_RET(which, R) { if (MLAlwaysTrue){ throw TreeNodeException(TNE_VoidImplementation, which); } return R; }
 
#define ADD_LONG_CHILD            { addChild(static_cast<long>(val), name); }
 
#define ADD_ULONG_CHILD           { addChild(static_cast<unsigned long>(val), name); }
 
#define ADD_LDOUBLE_CHILD         { addChild(static_cast<long double>(val), name); }
 
#define READ_LONG_CHILD(DST_TYPE)   { long lval=0; readChild(lval, name); val = static_cast<DST_TYPE>(lval); }
 
#define READ_ULONG_CHILD(DST_TYPE)  { unsigned long lval=0; readChild(lval, name); val = static_cast<DST_TYPE>(lval); }
 
#define READ_LDOUBLE_CHILD(DST_TYPE){ long double ldval=0; readChild(ldval, name); val = static_cast<DST_TYPE>(ldval); }
 
#define READ_LONG_CHILD_FOR_BOOL  { long lval=0; readChild(lval, name); val = (lval!=0); }
 
 
  typedef enum {
 
    CM_writerRoot,
 
    CM_readerRoot,
 
    CM_COUNT
 
  } ConstructionMode;
 
 
  virtual ~TreeNode();
 
  //--------------------------------------------------------------
  //--------------------------------------------------------------
 
 
  virtual void writeToFile    (const char* /*fileName*/)    VOID_IMPLEMENTATION("writeToFile");
 
  virtual void readFromFile   (const char* /*fileName*/)    VOID_IMPLEMENTATION("readFromFile");
 
 
  virtual void writeToString(std::string&  /*str*/)         VOID_IMPLEMENTATION("writeToString");
 
 
  virtual void readFromString(const std::string& /*str*/)         VOID_IMPLEMENTATION("readFromString");
 
public:
 
 
  //------------------------------------------------------------------------------------------
  //------------------------------------------------------------------------------------------
 
 
  virtual void addChild (bool                 val  , const char*   name  ) ADD_ULONG_CHILD;
 
  virtual void addChild (unsigned char        val  , const char*   name  ) ADD_ULONG_CHILD;
 
  virtual void addChild (char                 val  , const char*   name  ) ADD_LONG_CHILD;
 
  virtual void addChild (unsigned short       val  , const char*   name  ) ADD_ULONG_CHILD;
 
  virtual void addChild (short                val  , const char*   name  ) ADD_LONG_CHILD;
 
  virtual void addChild (unsigned int         val  , const char*   name  ) ADD_ULONG_CHILD;
 
  virtual void addChild (int                  val  , const char*   name  ) ADD_LONG_CHILD;
 
  virtual void addChild (unsigned long      /*val*/, const char* /*name*/) VOID_IMPLEMENTATION("addChild(unsigned long)");
 
  virtual void addChild (long               /*val*/, const char* /*name*/) VOID_IMPLEMENTATION("addChild(long)");
 
  virtual void addChild (MLuint64           /*val*/, const char* /*name*/) VOID_IMPLEMENTATION("addChild(MLuint64)");
 
  virtual void addChild (MLint64            /*val*/, const char* /*name*/) VOID_IMPLEMENTATION("addChild(MLint64)");
 
  virtual void addChild (float                val  , const char*   name  ) ADD_LDOUBLE_CHILD;
 
  virtual void addChild (double               val  , const char*   name  ) ADD_LDOUBLE_CHILD;
 
  virtual void addChild (long double        /*val*/, const char* /*name*/) VOID_IMPLEMENTATION("addChild(long double)");
 
  virtual void addChild(const std::string&  /*str*/, const char* /*name*/) VOID_IMPLEMENTATION("addChild(const std::string&)");
 
  virtual void addChild (const Vector2&        /*vec*/, const char* /*name*/) VOID_IMPLEMENTATION("addChild(Vector2)");
 
  virtual void addChild (const Vector3&        /*vec*/, const char* /*name*/) VOID_IMPLEMENTATION("addChild(Vector3)");
 
  virtual void addChild (const Vector4&        /*vec*/, const char* /*name*/) VOID_IMPLEMENTATION("addChild(Vector4)");
 
  virtual void addChild (const Vector6&        /*vec*/, const char* /*name*/) VOID_IMPLEMENTATION("addChild(Vector6)");
 
  virtual void addChild (const ImageVector&      /*vec*/, const char* /*name*/) VOID_IMPLEMENTATION("addChild(ImageVector)");
 
  virtual void addChild (const Matrix3&        /*mat*/, const char* /*name*/) VOID_IMPLEMENTATION("addChild(Matrix3)");
 
  virtual void addChild (const Matrix4&        /*mat*/, const char* /*name*/) VOID_IMPLEMENTATION("addChild(Matrix4)");
 
  virtual void addChild (const SubImageBox&   /*box*/, const char* /*name*/) VOID_IMPLEMENTATION("addChild(SubImageBox)");
 
  virtual void addChild (const SubImageBoxd&  /*box*/, const char* /*name*/) VOID_IMPLEMENTATION("addChild(SubImageBoxd)");
 
  virtual void addChild (const void* const  /*ptr*/, size_t /*noBytes*/, const char* /*name*/) VOID_IMPLEMENTATION("addChild(void*)");
 
 
  virtual void addChild (const Base* const  /*obj*/, const char* /*name*/, bool /*generic*/ = true) VOID_IMPLEMENTATION("addChild(Base*)");
 
 
  virtual TreeNode* addChild (const char* /*name*/) VOID_IMPLEMENTATION_RET("TreeNode* addChild()", nullptr);
 
 
 
 
 
  //--------------------------------------------------------------------------------------------
  //--------------------------------------------------------------------------------------------
 
 
  virtual bool hasChild  (const char* /*tagName*/ = nullptr) VOID_IMPLEMENTATION_RET("TreeNode* hasChild()", false);
 
 
 
  virtual void readChild (bool&           val, const char* name = nullptr) READ_LONG_CHILD_FOR_BOOL;
 
  virtual void readChild (char&           val, const char* name = nullptr) READ_LONG_CHILD(char);
 
  virtual void readChild (unsigned char&  val, const char* name = nullptr) READ_ULONG_CHILD(unsigned char);
 
  virtual void readChild (short&          val, const char* name = nullptr) READ_LONG_CHILD(short);
 
  virtual void readChild (unsigned short& val, const char* name = nullptr) READ_ULONG_CHILD(unsigned short);
 
  virtual void readChild (int&            val, const char* name = nullptr) READ_LONG_CHILD(int);
 
  virtual void readChild (unsigned int&   val, const char* name = nullptr) READ_ULONG_CHILD(unsigned int);
 
  virtual void readChild (long&           /*val*/, const char* /*name*/ = nullptr) VOID_IMPLEMENTATION("readChild(long&)");
 
  virtual void readChild (unsigned long&  /*val*/, const char* /*name*/ = nullptr) VOID_IMPLEMENTATION("readChild(unsigned long&)");
 
  virtual void readChild (MLint64&      /*val*/, const char* /*name*/ = nullptr) VOID_IMPLEMENTATION("readChild(MLint64&)");
 
  virtual void readChild (MLuint64&     /*val*/, const char* /*name*/ = nullptr) VOID_IMPLEMENTATION("readChild(MLuint64&)");
 
  virtual void readChild (float&          val, const char* name = nullptr) READ_LDOUBLE_CHILD(float);
 
  virtual void readChild (double&         val, const char* name = nullptr) READ_LDOUBLE_CHILD(double);
 
  virtual void readChild (long double&    /*val*/, const char* /*name*/ = nullptr) VOID_IMPLEMENTATION("readChild(long double&)");
 
  virtual void readChild (Vector2&           /*vec*/, const char* /*name*/ = nullptr) VOID_IMPLEMENTATION("readChild(Vector2&)");
 
  virtual void readChild (Vector3&           /*vec*/, const char* /*name*/ = nullptr) VOID_IMPLEMENTATION("readChild(Vector3&)");
 
  virtual void readChild (Vector4&           /*vec*/, const char* /*name*/ = nullptr) VOID_IMPLEMENTATION("readChild(Vector4&)");
 
  virtual void readChild (Vector6&           /*vec*/, const char* /*name*/ = nullptr) VOID_IMPLEMENTATION("readChild(Vector6&)");
 
  virtual void readChild (ImageVector&         /*vec*/, const char* /*name*/ = nullptr) VOID_IMPLEMENTATION("readChild(ImageVector&)");
 
  virtual void readChild (Matrix3&           /*mat*/, const char* /*name*/ = nullptr) VOID_IMPLEMENTATION("readChild(Matrix3&)");
 
  virtual void readChild (Matrix4&           /*mat*/, const char* /*name*/ = nullptr) VOID_IMPLEMENTATION("readChild(Matrix4&)");
 
  virtual void readChild (SubImageBox&      /*box*/, const char* /*name*/ = nullptr) VOID_IMPLEMENTATION("readChild(SubImageBox&)");
 
  virtual void readChild (SubImageBoxd&     /*box*/, const char* /*name*/ = nullptr) VOID_IMPLEMENTATION("readChild(SubImageBoxd&)");
 
  virtual void readChild (void*&          /*ptr*/, unsigned long& /*noBytes*/, const char* /*name*/ = nullptr) VOID_IMPLEMENTATION("readChild(char*&)");
 
  virtual void readChild (Base*&         /*objP*/, const char* /*name*/ = nullptr) VOID_IMPLEMENTATION("readChild(Base*&)");
 
  virtual void readChild (Base&          /*objP*/, const char* /*name*/ = nullptr) VOID_IMPLEMENTATION("readChild(Base&)");
 
  virtual void readChild (TreeNode*&     /*node*/, const char* /*name*/ = nullptr) VOID_IMPLEMENTATION("readChild(TreeNode*&)");
 
  virtual void readChild(std::string&   /*str*/, const char* /*name*/ = nullptr) VOID_IMPLEMENTATION("readChild(std::string&)");
 
  template <typename T> bool readOptionalChild(T& value, const char* name)
  {
    if (hasChild(name)) {
      readChild(value, name);
      return true;
    }
    return false;
  }
 
  template <typename T> T getOptionalChildValue(const char* name, const T& defaultValue)
  {
    T value;
    if (readOptionalChild(value, name)) {
      return value;
    }
    return defaultValue;
  }
 
 
 
  //-----------------------------------------------------------------------------
  //-----------------------------------------------------------------------------
 
 
  virtual TreeNode*  readContainerChild (const char* name = nullptr)
  {
    TreeNode* node = nullptr;
    readChild(node, name);
    return node;
  }
 
 
 
  virtual Base* readBaseChild (const char* name = nullptr)
  {
    Base* objP = nullptr;
    readChild(objP, name);
    return objP;
  }
 
 
  //------------------------------
  //------------------------------
 
 
  virtual void setVersion(const char* /*className*/, int /*version*/){ VOID_IMPLEMENTATION("setVersion()"); }
 
  virtual int getVersion(const char* /*className*/)  { VOID_IMPLEMENTATION_RET("getVersion()", 0); }
 
  virtual const char* getLastReadChildName() const  { VOID_IMPLEMENTATION_RET("getLastReadChildName()", nullptr); }
 
  bool isRootNode() const                                { return _isRoot; }
 
  virtual char* correctName(const char* /*name*/) const  { VOID_IMPLEMENTATION_RET("correctName()", nullptr);      }
 
  virtual bool isCorrectName(const char* /*name*/) const { VOID_IMPLEMENTATION_RET("isCorrectName()", false); }
 
 
  virtual void deleteMemory(void* /*ptr*/){};
 
protected:
 
 
  //----------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------
 
  TreeNode(ConstructionMode /*mode*/) :
  _isRoot(true)
  {
  }
 
  TreeNode()  :
  _isRoot(false)
  {
  }
 
 
  std::vector<TreeNode*> &_getChildTreeNodes();
 
  //---------------------------------------------
  //---------------------------------------------
 
 
  void _appendNewChild(TreeNode& newNode) { _childTreeNodes.push_back(&newNode); }
 
 
  //------------------------------------------------
  //------------------------------------------------
 
private:
 
 
  //------------------------
  //------------------------
 
 
  std::vector<TreeNode*> _childTreeNodes;
 
  bool _isRoot;
 
 
  ML_ABSTRACT_ROOT_CLASS_HEADER(TreeNode)
 
  
#undef VOID_IMPLEMENTATION
#undef ADD_ULONG_CHILD
#undef ADD_LONG_CHILD
#undef ADD_LDOUBLE_CHILD
#undef READ_ULONG_CHILD
#undef READ_LONG_CHILD
#undef READ_LDOUBLE_CHILD
#undef READ_LONG_CHILD_FOR_BOOL
 
}; // class TreeNode
 
 
//------------------------
//------------------------
 
 
#define ML_READCHILD_OPTIONAL(obj, tagName, defaultVal) \
if (parent->hasChild(tagName)) { \
  parent->readChild(obj, tagName); \
} else { \
  obj = defaultVal; \
}
 
 
#define ML_ADDSTATE_VERSION(ThisClass) parent->setVersion("#ThisClass#", ThisClass::getAddStateVersion());
 
#define ML_ADDSTATE_SUPER(SuperClass) { \
TreeNode* superClassNode = parent->addChild("_" #SuperClass); \
SuperClass::addStateToTree(superClassNode); \
}
 
#define ML_READSTATE_SUPER(SuperClass) { \
TreeNode* superClassNode = parent->readContainerChild("_" #SuperClass); \
SuperClass::readStateFromTree(superClassNode); \
}
 
 
#define ML_TREE_NODE_SUPPORT_VIA_PERSISTENT_STATE \
virtual void addStateToTree(TreeNode* parent) const \
{ \
auto state = persistentState(); \
if (state.empty()){ state = "Could not read object state."; } \
parent->addChild(state, "State"); \
} \
\
virtual void readStateFromTree(TreeNode* parent) \
{ \
std::string state; \
parent->readChild(state, "State"); \
setPersistentState(state); \
}
 
ML_END_NAMESPACE
 
#endif // __mlTreeNode_H