MeVisLab/Standard/Sources/ML/MLParser/mlXMLParser/mlXMLTreeNode.h

Go to the documentation of this file.

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

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

#include "mlBase.h"
#include "mlBasics.h"
#include "mlTreeNode.h"
#include "../mlParserSystem.h"
#include "mlXMLParserSystem.h"
//#include <xercesc/util/XercesDefs.hpp>

#ifndef __mlXMLTreeNode_H
#define __mlXMLTreeNode_H

namespace XERCES_CPP_NAMESPACE {

  class DOMElement;
  class DOMNode;

}

using namespace XERCES_CPP_NAMESPACE;


ML_START_NAMESPACE

  enum {
      TNE_XML_SystemInit = TNE_COUNT
    , TNE_XML_ParserError
    , TNE_XML_ReadingRawDataSize
    , TNE_XML_Unknown
    , TNE_XML_Other

    , TNE_XML_LAST_MESSAGE_IDX   
    , TNE_XML_COUNT = TNE_XML_LAST_MESSAGE_IDX - TNE_COUNT
  };

  class PARSER_EXPORT XMLTreeNodeException : public TreeNodeException {

    public:

      XMLTreeNodeException(int errorCode = 0, const char* msg = NULL) : TreeNodeException(errorCode, msg) {;}

      virtual const char* getMessage() const;

    private:

      static const char* _stdErrorMsg[];

      ML_CLASS_HEADER(XMLTreeNodeException);

  };


  class PARSER_EXPORT XMLTreeNode : public TreeNode {

    public:


      XMLTreeNode(TreeNode::ConstructionMode mode = TreeNode::CM_writerRoot);


      virtual ~XMLTreeNode();



      virtual void writeToFile    (const char* fileName);

      virtual void writeToString  (char*&      str);



      virtual void readFromFile   (const char* fileName);

      virtual void readFromString (const char* str);



      //virtual void addChild (bool              val, const char* tagName);
      virtual void addChild (unsigned long     val, const char* tagName);
      virtual void addChild (long              val, const char* tagName);
      virtual void addChild (MLuint64          val, const char* tagName);
      virtual void addChild (MLint64           val, const char* tagName);
      virtual void addChild (long double       val, const char* tagName);
      virtual void addChild (const vec2&       vec, const char* tagName);
      virtual void addChild (const vec3&       vec, const char* tagName);
      virtual void addChild (const vec4&       vec, const char* tagName);
      virtual void addChild (const vec6&       vec, const char* tagName);
      virtual void addChild (const Vector&     vec, const char* tagName);
      virtual void addChild (const mat3&       mat, const char* tagName);
      virtual void addChild (const mat4&       mat, const char* tagName);
      virtual void addChild (const SubImgBox&  box, const char* tagName);
      virtual void addChild (const SubImgBoxf& box, const char* tagName);
      virtual void addChild (const char* const text,const char* tagName);
      virtual void addChild (const void* const ptr, size_t noBytes, const char* tagName);



      virtual void addChild (const Base* const obj, const char* tagName, bool generic = true);

      virtual TreeNode* addChild (                   const char* tagName);




      virtual bool hasChild  (const char* tagName = NULL);

      //virtual void readChild (bool& val, const char* tagName = NULL);
      virtual void readChild (unsigned long&  val, const char* tagName = NULL);
      virtual void readChild (long&           val, const char* tagName = NULL);
      virtual void readChild (MLuint64&       val, const char* tagName = NULL);
      virtual void readChild (MLint64&        val, const char* tagName = NULL);
      virtual void readChild (long double&    val, const char* tagName = NULL);
      virtual void readChild (vec2&           val, const char* tagName = NULL);
      virtual void readChild (vec3&           val, const char* tagName = NULL);
      virtual void readChild (vec4&           val, const char* tagName = NULL);
      virtual void readChild (vec6&           val, const char* tagName = NULL);
      virtual void readChild (Vector&         val, const char* tagName = NULL);
      virtual void readChild (mat3&           val, const char* tagName = NULL);
      virtual void readChild (mat4&           val, const char* tagName = NULL);
      virtual void readChild (SubImgBox&      val, const char* tagName = NULL);
      virtual void readChild (SubImgBoxf&     val, const char* tagName = NULL);
      virtual void readChild (void*&          ptr, unsigned long& noBytes, const char* tagName = NULL);

      virtual void readChild (char*&          val, const char* tagName = NULL);

      virtual void readChild (Base*&          val, const char* tagName = NULL);

      virtual void readChild (Base&           val, const char* tagName = NULL);

      virtual void readChild (TreeNode*&      val, const char* tagName = NULL);

      virtual void deleteString (char* str) const;




      virtual void setVersion(const char* className, int version);

      virtual int getVersion(const char* /*className*/);


      virtual const char* getLastReadChildName() const;

      static char* normalizeFileName(const char* fileName);



      static void initXMLSystem();
      static void terminateXMLSystem();


    protected:

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


      XMLTreeNode(DOMElement* parent);

      static char*        _getTextNodeString(DOMElement* parentNode);

      DOMElement*         _findElemByTagName(const char* tagName, DOMNode* prevNode = NULL);

      XMLTreeNode*        _addTreeNodeChild(DOMElement* child);

      DOMElement*         _parentDOMNode;

      static bool         _xercesInitialized;


    private:
      DOMNode*            _lastNode;

      DOMNode*            _lastNodeRead;

      mutable StringX     _lastName;

      ML_CLASS_HEADER(XMLTreeNode);

  }; // class XMLTreeNode

ML_END_NAMESPACE

#define ML_PERSISTENCE_SUPPORT_VIA_XML \
virtual char* getPersistentState() const { \
  char* cstr = NULL; \
  try { \
    XMLTreeNode* ioRootNode = new XMLTreeNode(TreeNode::CM_writerRoot); \
    addStateToTree(ioRootNode); \
    ioRootNode->writeToString(cstr); \
    delete ioRootNode; \
  } catch (const TreeNodeException& e) { \
    ML_PRINT_ERROR("ML_PERSISTENCE_SUPPORT_VIA_XML - getPersistentState()", \
      std::string("Exception ") + e.getMessage() + " occurred.", "Returning empty string."); \
    return ""; \
  } \
  return cstr; \
} \
\
virtual void setPersistentState(const char* state) { \
  if (!state || std::string(state).empty()) return; \
  try { \
    XMLTreeNode* ioRootNode = new XMLTreeNode(TreeNode::CM_readerRoot); \
    this->readStateFromTree(ioRootNode); \
    ioRootNode->readFromString(state); \
    delete ioRootNode; \
  } catch (const TreeNodeException& e) { \
    ML_PRINT_ERROR("ML_PERSISTENCE_SUPPORT_VIA_XML - setPersistentState()", \
      std::string("Exception ") + e.getMessage() + " occurred.", \
      "Continuing. Warning: Object state may be undefined!"); \
  } \
} \
\
\
virtual void clearPersistentState(char* state) const { \
  if (!state || std::string(state).empty()) return; \
  try { \
    XMLTreeNode* ioRootNode = new XMLTreeNode(TreeNode::CM_readerRoot); \
    ioRootNode->deleteString(state); \
    delete ioRootNode; \
  } catch (const TreeNodeException& e) { \
    ML_PRINT_ERROR("ML_PERSISTENCE_SUPPORT_VIA_XML - clearPersistentState()", \
      std::string("Exception ") + e.getMessage() + " occurred.", \
      "Continuing. Warning: Object state may be undefined!"); \
  } \
}


#endif //__mlXMLTreeNode_H