MeVis/Foundation/Sources/ML/include/mlTreeNode.h

Go to the documentation of this file.

// **InsertLicense** code
//-------------------------------------------------------------------------
//-------------------------------------------------------------------------
#ifndef __mlTreeNode_H
#define __mlTreeNode_H

#ifndef __mlInitSystemML_H
#include "mlInitSystemML.h"
#endif
#ifndef __mlBasics_H
#include "mlBasics.h"
#endif
#ifndef __mlRuntimeType_H
#include "mlRuntimeType.h"
#endif
#ifndef __mlRuntimeSubClass_H
#include "mlRuntimeSubClass.h"
#endif

#ifdef _MSC_VER
#pragma warning(push)
// warning C4244: 'Argument': Konvertierung von 'typ1' in 'typ2', möglicher Datenverlust
#pragma warning(disable: 4244)
#endif

ML_START_NAMESPACE

// Incomplete type to reduce header file dependencies.
class Base;
class SubImageBoxd;
#ifdef ML_DEPRECATED
ML_DEPRECATED typedef SubImageBoxd SubImgBoxf;
#endif

//---------------------------------------------------------------------------------
//---------------------------------------------------------------------------------
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

#if defined(ML_DEPRECATED)
  ,
  TNE_ReadingVec2 =        TNE_ReadingVector2,
  TNE_ReadingVec3 =        TNE_ReadingVector3,
  TNE_ReadingVec4 =        TNE_ReadingVector4,
  TNE_ReadingVec6 =        TNE_ReadingVector6,
  TNE_ReadingVector =      TNE_ReadingImageVector,
  TNE_ReadingMat3 =        TNE_ReadingMatrix3,
  TNE_ReadingMat4 =        TNE_ReadingMatrix4,
  TNE_ReadingSubImgBox =   TNE_ReadingSubImageBox,
  TNE_ReadingSubImgBoxf =  TNE_ReadingSubImageBoxd
#endif  
};


//---------------------------------------------------------------------------------
//---------------------------------------------------------------------------------
class MLEXPORT TreeNodeException
{

public:


  TreeNodeException(int errorCode = 0, const char* msg = 0) { _errorCode = errorCode; _errorMsg = msg; }

  virtual ~TreeNodeException() { }

  int                 getCode()    const { return _errorCode; }


  virtual const char* getMessage() const;

protected:

  int                   _errorCode;

  const char*           _errorMsg;

private:

  static const char*    _stdErrorMsg[];

  ML_CLASS_HEADER(TreeNodeException);
};



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  (char*&      /*str*/)         VOID_IMPLEMENTATION("writeToString");


  virtual void readFromString (const char* /*str*/)         VOID_IMPLEMENTATION("readFromString");


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


  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 char* const  /*str*/, const char* /*name*/) VOID_IMPLEMENTATION("addChild(const char* const)");

  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()", NULL);





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


  virtual bool hasChild  (const char* /*tagName*/ = 0) VOID_IMPLEMENTATION_RET("TreeNode* hasChild()", false);



  virtual void readChild (bool&           val, const char* name = 0) READ_LONG_CHILD_FOR_BOOL;

  virtual void readChild (char&           val, const char* name = 0) READ_LONG_CHILD(char);

  virtual void readChild (unsigned char&  val, const char* name = 0) READ_ULONG_CHILD(unsigned char);

  virtual void readChild (short&          val, const char* name = 0) READ_LONG_CHILD(short);

  virtual void readChild (unsigned short& val, const char* name = 0) READ_ULONG_CHILD(unsigned short);

  virtual void readChild (int&            val, const char* name = 0) READ_LONG_CHILD(int);

  virtual void readChild (unsigned int&   val, const char* name = 0) READ_ULONG_CHILD(unsigned int);

  virtual void readChild (long&           /*val*/, const char* /*name*/ = 0) VOID_IMPLEMENTATION("readChild(long&)");

  virtual void readChild (unsigned long&  /*val*/, const char* /*name*/ = 0) VOID_IMPLEMENTATION("readChild(unsigned long&)");

  virtual void readChild (MLint64&      /*val*/, const char* /*name*/ = 0) VOID_IMPLEMENTATION("readChild(MLint64&)");

  virtual void readChild (MLuint64&     /*val*/, const char* /*name*/ = 0) VOID_IMPLEMENTATION("readChild(MLuint64&)");

  virtual void readChild (float&          val, const char* name = 0) READ_LDOUBLE_CHILD(float);

  virtual void readChild (double&         val, const char* name = 0) READ_LDOUBLE_CHILD(double);

  virtual void readChild (long double&    /*val*/, const char* /*name*/ = 0) VOID_IMPLEMENTATION("readChild(long double&)");

  virtual void readChild (Vector2&           /*vec*/, const char* /*name*/ = 0) VOID_IMPLEMENTATION("readChild(Vector2&)");

  virtual void readChild (Vector3&           /*vec*/, const char* /*name*/ = 0) VOID_IMPLEMENTATION("readChild(Vector3&)");

  virtual void readChild (Vector4&           /*vec*/, const char* /*name*/ = 0) VOID_IMPLEMENTATION("readChild(Vector4&)");

  virtual void readChild (Vector6&           /*vec*/, const char* /*name*/ = 0) VOID_IMPLEMENTATION("readChild(Vector6&)");

  virtual void readChild (ImageVector&         /*vec*/, const char* /*name*/ = 0) VOID_IMPLEMENTATION("readChild(ImageVector&)");

  virtual void readChild (Matrix3&           /*mat*/, const char* /*name*/ = 0) VOID_IMPLEMENTATION("readChild(Matrix3&)");

  virtual void readChild (Matrix4&           /*mat*/, const char* /*name*/ = 0) VOID_IMPLEMENTATION("readChild(Matrix4&)");

  virtual void readChild (SubImageBox&      /*box*/, const char* /*name*/ = 0) VOID_IMPLEMENTATION("readChild(SubImageBox&)");

  virtual void readChild (SubImageBoxd&     /*box*/, const char* /*name*/ = 0) VOID_IMPLEMENTATION("readChild(SubImageBoxd&)");

  virtual void readChild (void*&          /*ptr*/, unsigned long& /*noBytes*/, const char* /*name*/ = 0) VOID_IMPLEMENTATION("readChild(char*&)");

  virtual void readChild (Base*&         /*objP*/, const char* /*name*/ = 0) VOID_IMPLEMENTATION("readChild(Base*&)");

  virtual void readChild (Base&          /*objP*/, const char* /*name*/ = 0) VOID_IMPLEMENTATION("readChild(Base&)");

  virtual void readChild (TreeNode*&     /*node*/, const char* /*name*/ = 0) VOID_IMPLEMENTATION("readChild(TreeNode*&)");

  virtual void readChild (char*&          /*str*/, const char* /*name*/ = 0) VOID_IMPLEMENTATION("readChild(char*&)");

  virtual void deleteString (char* /*str*/) const VOID_IMPLEMENTATION("deleteString(char*)");



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


  virtual TreeNode*  readContainerChild (const char* name = 0)
  {
    ML_TRACE_IN( "TreeNode::readContainerChild ( )" );

    TreeNode* node = NULL;
    ML_TRY
    {
      readChild(node, name);
    }
    ML_CATCH_BLOCK(const TreeNodeException&) { throw; }
    ML_CATCH_RETHROW;
    return node;
  }



  virtual Base* readBaseChild (const char* name = 0)
  {
    ML_TRACE_IN( "TreeNode::readBaseChild ( )" );

    Base* objP = NULL;
    ML_TRY
    {
      readChild(objP, name);
    }
    ML_CATCH_BLOCK(const TreeNodeException&) { throw; }
    ML_CATCH_RETHROW;
    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()", NULL); }

  bool isRootNode() const                                { return _isRoot; }

  virtual char* correctName(const char* /*name*/) const  { VOID_IMPLEMENTATION_RET("correctName()", NULL);      }

  virtual bool isCorrectName(const char* /*name*/) const { VOID_IMPLEMENTATION_RET("isCorrectName()", false); }


protected:


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

  TreeNode(ConstructionMode /*mode*/) :
  _isRoot(true)
  {
    ML_TRACE_IN( "TreeNode::TreeNode( )" );
  }

  TreeNode()  :
  _isRoot(false)
  {
    ML_TRACE_IN( "TreeNode::TreeNode( )" );
  }


  std::vector<TreeNode*> &_getChildTreeNodes();

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


  void _appendNewChild(TreeNode& newNode) { _childTreeNodes.push_back(&newNode); }


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

private:


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


  std::vector<TreeNode*> _childTreeNodes;

  bool _isRoot;


  ML_ABSTRACT_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 \
{ \
char* state = getPersistentState(); \
if (!state){ state = "Could not read object state."; } \
parent->addChild(state, "State"); \
clearPersistentState(state); \
} \
\
virtual void readStateFromTree(TreeNode* parent) \
{ \
char* state; \
parent->readChild(state, "State"); \
setPersistentState(state); \
parent->deleteString(state); \
}


ML_END_NAMESPACE

#ifdef _MSC_VER
#pragma warning(pop)
#endif

#endif // __mlTreeNode_H