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 "../mlParserSystem.h"
#include "mlBase.h"
#include "mlTreeNode.h"
#include "mlXMLParserSystem.h"
 
#include <mlTypeDefs.h>
#include <xercesc/util/XercesVersion.hpp>
 
namespace XERCES_CPP_NAMESPACE
{
 
  class DOMElement;
  class DOMNode;
  class XercesDOMParser;
} // namespace XERCES_CPP_NAMESPACE
 
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 std::string 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