mlXMLPersistenceStream.h

Go to the documentation of this file.

/*************************************************************************************
**
** Copyright 2012, 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_XMLPERSISTENCE_STREAM_H
#define ML_XMLPERSISTENCE_STREAM_H
 
 
 
#include "mlAbstractPersistenceStream.h"
#include "mlBase.h"
 
#include <xercesc/dom/DOMElement.hpp>
#include <xercesc/dom/DOMNode.hpp>
#include <xercesc/util/XercesVersion.hpp>
 
using namespace XERCES_CPP_NAMESPACE;
 
 
ML_START_NAMESPACE
 
//--------------------------------------------------------------------------------
 
class XMLPersistenceStream
{
public:
  struct ListStackEntry
  {
    ListStackEntry(const char* anItemName, bool aSuppressScope)
      : itemName(anItemName)
      , suppressScope(aSuppressScope)
    {}
 
    const char* itemName;
    bool suppressScope;
  };
 
protected:
  XMLPersistenceStream()
  {}
 
  std::list<ListStackEntry> _listStack;
};
 
 
//--------------------------------------------------------------------------------
 
class XMLPersistenceOutputStream : public AbstractPersistenceOutputStream, private XMLPersistenceStream
{
public:
  XMLPersistenceOutputStream();
 
  XMLPersistenceOutputStream(DOMElement* container);
 
  virtual ~XMLPersistenceOutputStream();
 
  virtual void writeToFile(const std::string& fileName);
 
  virtual void writeToString(std::string& str);
 
  bool isBinary() const override
  {
    return false;
  }
 
  void writeString(const char* name, const std::string& value) override;
 
  void writeData(const void* data, size_t len, const char* name) override;
 
protected:
  void startListImpl(const char* name, const char* xmlItemName, bool xmlSuppressScope) override;
  void endListImpl() override;
  void startStructImpl(const char* name) override;
  void endStructImpl() override;
 
  void setObjectID(int id) override;
  void setObjectType(const char* type) override;
  void setObjectVersion(int version) override;
 
  void writeValues(const char* name, const MLint32* values, size_t n, bool fixedList) override;
  void writeValues(const char* name, const MLuint32* values, size_t n, bool fixedList) override;
  void writeValues(const char* name, const MLint64* values, size_t n, bool fixedList) override;
  void writeValues(const char* name, const MLuint64* values, size_t n, bool fixedList) override;
  void writeValues(const char* name, const MLfloat* values, size_t n, bool fixedList) override;
  void writeValues(const char* name, const MLdouble* values, size_t n, bool fixedList) override;
 
private:
  template <typename T> void _writeValuesT(const char* name, const T* values, size_t n, bool fixedList);
 
  void _setAttribute(const char* attrName, const char* value);
  void _setAttribute(const char* attrName, int value);
 
  void _createScope(const char* tagName);
 
  void _closeScope();
 
  DOMElement* _rootNode;
  DOMElement* _currentNode;
};
 
//--------------------------------------------------------------------------------
 
class XMLPersistenceInputStream : public AbstractPersistenceInputStream, private XMLPersistenceStream
{
public:
  XMLPersistenceInputStream();
 
  XMLPersistenceInputStream(DOMElement* container);
 
  virtual ~XMLPersistenceInputStream();
 
  virtual void readFromFile(const std::string& fileName);
 
  virtual void readFromString(const std::string& str);
 
  static void normalizeWindowsFileName(std::string& str);
 
  bool isBinary() const override
  {
    return false;
  }
 
  void readString(const char* name, std::string& value) override;
 
  void readData(std::string& value, const char* name) override;
 
protected:
  void startListImpl(const char* name, const char* xmlItemName, bool xmlSuppressScope) override;
  void endListImpl() override;
  void startStructImpl(const char* name) override;
  void endStructImpl() override;
 
  bool hasNextInStructImpl(std::string& name) override;
  bool hasNextListItemImpl() override;
 
  bool getObjectID(int& id) override;
  bool getObjectType(std::string& type) override;
  bool getObjectVersion(int& version) override;
 
  void readValues(const char* name, size_t expected, std::vector<MLint32>& values) override;
  void readValues(const char* name, size_t expected, std::vector<MLuint32>& values) override;
  void readValues(const char* name, size_t expected, std::vector<MLint64>& values) override;
  void readValues(const char* name, size_t expected, std::vector<MLuint64>& values) override;
  void readValues(const char* name, size_t expected, std::vector<MLfloat>& values) override;
  void readValues(const char* name, size_t expected, std::vector<MLdouble>& values) override;
 
  void formatError(const std::string& msg) override;
 
private:
  template <typename T> void _readValuesT(const char* name, size_t expected, std::vector<T>& values);
 
  bool _getAttribute(const char* attrName, std::string& value);
  bool _getAttribute(const char* attrName, int& value);
 
  bool _checkElement(const char* name, bool throwError = true);
 
  void _toNextElement(bool reset = false);
 
  void _enterScope(const char* tagName);
 
  void _leaveScope();
 
  DOMElement* _rootNode;
  DOMElement* _currentNode;
  DOMElement* _nextNode;
};
 
//--------------------------------------------------------------------------------
 
ML_END_NAMESPACE
 
#endif //__mlXMLPersistenceStream_H