mlXMLTreeNode.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_XMLTREE_NODE_H
#define ML_XMLTREE_NODE_H
 
 
 
#include "mlBase.h"
#include "mlTreeNode.h"
#include "../mlParserSystem.h"
#include "mlXMLParserSystem.h"
 
#include <mlTypeDefs.h>
 
namespace XERCES_CPP_NAMESPACE {
 
  class DOMElement;
  class DOMNode;
  class XercesDOMParser;
}
 
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 = static_cast<int>(TNE_XML_LAST_MESSAGE_IDX) - TNE_COUNT
  };
 
  class PARSER_EXPORT XMLTreeNodeException : public TreeNodeException {
 
    public:
 
      XMLTreeNodeException(int errorCode = 0, const char* msg = nullptr);
 
 
      const char* getMessage() const override;
 
    private:
 
      std::string _message;
 
      static const char* _stdErrorMsg[];
 
      ML_CLASS_HEADER(XMLTreeNodeException);
 
  };
 
 
  class PARSER_EXPORT XMLTreeNode : public TreeNode
  {
    public:
 
 
      XMLTreeNode(TreeNode::ConstructionMode mode = TreeNode::CM_writerRoot);
 
 
      ~XMLTreeNode() override;
 
 
      void writeToFile    (const char* fileName) override;
 
  public:
      void writeToString(std::string& str) override;
 
 
      void readFromFile   (const char* fileName) override;
 
      void readFromString(const std::string& str) override;
 
 
 
      //virtual void addChild (bool              val, const char* tagName);
      void addChild (unsigned long       val, const char* tagName) override;
      void addChild (long                val, const char* tagName) override;
      void addChild (MLuint64            val, const char* tagName) override;
      void addChild (MLint64             val, const char* tagName) override;
      void addChild (long double         val, const char* tagName) override;
      void addChild (const Vector2&      vec, const char* tagName) override;
      void addChild (const Vector3&      vec, const char* tagName) override;
      void addChild (const Vector4&      vec, const char* tagName) override;
      void addChild (const Vector6&      vec, const char* tagName) override;
      void addChild (const ImageVector&  vec, const char* tagName) override;
      void addChild (const Matrix3&      mat, const char* tagName) override;
      void addChild (const Matrix4&      mat, const char* tagName) override;
      void addChild (const SubImageBox&  box, const char* tagName) override;
      void addChild (const SubImageBoxd& box, const char* tagName) override;
 
  public:
 
      void addChild(const std::string& str, const char* tagName) override;
      void addChild (const void* const   ptr, size_t noBytes, const char* tagName) override;
 
 
 
      void addChild (const Base* const obj, const char* tagName, bool generic = true) override;
 
      TreeNode* addChild (                   const char* tagName) override;
 
 
 
 
      bool hasChild  (const char* tagName = nullptr) override;
 
      //virtual void readChild (bool& val, const char* tagName = NULL);
      void readChild (unsigned long&  val, const char* tagName = nullptr) override;
      void readChild (long&           val, const char* tagName = nullptr) override;
      void readChild (MLuint64&       val, const char* tagName = nullptr) override;
      void readChild (MLint64&        val, const char* tagName = nullptr) override;
      void readChild (long double&    val, const char* tagName = nullptr) override;
      void readChild (Vector2&        val, const char* tagName = nullptr) override;
      void readChild (Vector3&        val, const char* tagName = nullptr) override;
      void readChild (Vector4&        val, const char* tagName = nullptr) override;
      void readChild (Vector6&        val, const char* tagName = nullptr) override;
      void readChild (ImageVector&    val, const char* tagName = nullptr) override;
      void readChild (Matrix3&        val, const char* tagName = nullptr) override;
      void readChild (Matrix4&        val, const char* tagName = nullptr) override;
      void readChild (SubImageBox&    val, const char* tagName = nullptr) override;
      void readChild (SubImageBoxd&   val, const char* tagName = nullptr) override;
 
      void readChild(void*& ptr, unsigned long& noBytes, const char* tagName = nullptr) override;
 
 
public:
 
      void readChild(std::string& val, const char* tagName = nullptr) override;
 
      void readChild (Base*&          val, const char* tagName = nullptr) override;
 
      void readChild (Base&           val, const char* tagName = nullptr) override;
 
      void readChild (TreeNode*&      val, const char* tagName = nullptr) override;
 
public:
 
 
 
 
      void deleteMemory(void* ptr) override;
 
      void setVersion(const char* className, int version) override;
 
      int getVersion(const char* /*className*/) override;
 
 
      const char* getLastReadChildName() const override;
 
      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 = nullptr);
 
      XMLTreeNode*        _addTreeNodeChild(DOMElement* child);
 
      DOMElement*         _parentDOMNode;
 
      // count the number of active root instances, so we can correctly
      // terminate the XML framework after deleting the last one
      static int          _numActiveRootInstances;
 
      static bool         _xercesInitialized;
 
 
    private:
      // above code hides overloaded virtual function and causes a lot of compiler warnings.
      // This using silence the warning while keeping the old public interface. Still, it doesn't fix the real problem.
      using TreeNode::addChild;
      using TreeNode::readChild;
 
      void _initFromParser(XercesDOMParser& parser);
 
      DOMNode*            _lastNode;
 
      DOMNode*            _lastNodeRead;
 
      mutable StringX     _lastName;
 
      ML_CLASS_HEADER(XMLTreeNode);
 
  }; // class XMLTreeNode
 
ML_END_NAMESPACE
 
#endif