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 "mlBase.h"
#include "mlAbstractPersistenceStream.h"
#include "mlXMLParserSystem.h"
 
namespace XERCES_CPP_NAMESPACE {
 
  class DOMElement;
  class DOMNode;
 
}
 
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