mlAbstractPersistenceStream.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_ABSTRACT_PERSISTENCE_STREAM_H
#define ML_ABSTRACT_PERSISTENCE_STREAM_H
 
 
#include "mlUtilsSystem.h"
#include "mlTypeDefs.h"
 
#include <ThirdPartyWarningsDisable.h>
#include <list>
#include <vector>
#include <set>
#include <string>
#include <ThirdPartyWarningsRestore.h>
 
ML_UTILS_START_NAMESPACE
 
class Base;
 
// pre-define templates that are defined in MLLinearAlgebra
template <class T, size_t size, class DataContainer>
class FloatingPointVector;
 
// pre-define templates that are defined in MLLinearAlgebra
template<typename T, int n>
class TVectorNDBase;
 
// pre-define templates that are defined in MLLinearAlgebra
template <class VectorT, size_t size>
class FloatingPointMatrix;
 
 
class ML_UTILS_EXPORT AbstractPersistenceStream
{
public:
  void startList(const char* name = nullptr, const char* xmlItemName = "Item", bool xmlSuppressScope = false);
 
  void endList();
 
  void startStruct(const char* name = nullptr);
 
  void endStruct();
 
  virtual bool isBinary() const = 0;
 
protected:
  AbstractPersistenceStream();
  virtual ~AbstractPersistenceStream();
 
  virtual void nameCheck(const char* name);
 
  virtual void startListImpl(const char* name, const char* xmlItemName, bool xmlSuppressScope) = 0;
  virtual void endListImpl() = 0;
  virtual void startStructImpl(const char* name) = 0;
  virtual void endStructImpl() = 0;
 
  bool isInList() const { return !_isListStack.empty() && _isListStack.back(); }
 
  size_t nestingDepth() const { return _isListStack.size(); }
 
  virtual void internalError(const char* msg, const char* arg = nullptr);
 
private:
  std::list<bool> _isListStack;
};
 
// -----------------------------------------------------------------------------
 
class ML_UTILS_EXPORT AbstractPersistenceOutputStream : public AbstractPersistenceStream
{
public:
  ~AbstractPersistenceOutputStream() override = default;
 
  void startStructWithVersion(int version, const char* name = nullptr);
 
  virtual void write(bool value, const char* name = nullptr);
 
  void write(MLint32  value, const char* name = nullptr);
  void write(MLuint32 value, const char* name = nullptr);
  void write(MLint64  value, const char* name = nullptr);
  void write(MLuint64 value, const char* name = nullptr);
  void write(MLfloat  value, const char* name = nullptr);
  void write(MLdouble value, const char* name = nullptr);
  void write(const std::string& value, const char* name = nullptr);
 
  void write(const char* value, const char* name = nullptr) { write(std::string(value), name); }
 
  template<typename T>
  void write(const std::vector<T>& values, const char* name = nullptr)
  {
    nameCheck(name);
    writeValues(name, &values.front(), values.size(), false);
  }
 
  template<typename T, size_t n, class DataContainer>
  void write(const FloatingPointVector<T, n, DataContainer>& value, const char* name = nullptr)
  {
    nameCheck(name);
    writeValues(name, &value[0], n, true);
  }
 
  template<typename T, size_t n>
  void write(const TVectorNDBase<T, n>& value, const char* name = nullptr)
  {
    nameCheck(name);
    writeValues(name, &value.array, n, true);
  }
 
  template<typename T, size_t n>
  void write(const FloatingPointMatrix<T, n>& value, const char* name = nullptr)
  {
    nameCheck(name);
    typename T::ComponentType components[FloatingPointMatrix<T, n>::ComponentCount];
    value.getValuesToPtr(components);
    writeValues(name, components, FloatingPointMatrix<T, n>::ComponentCount, true);
  }
 
  virtual void writeObject(const Base* const obj, const char* name = nullptr);
 
  virtual void writeData(const void* data, size_t len, const char* name = nullptr) = 0;
 
  virtual bool isValidElementName(const char* name);
 
protected:
  AbstractPersistenceOutputStream() {}
 
  virtual void setObjectID(int id) = 0;
  virtual void setObjectType(const char* type) = 0;
  virtual void setObjectVersion(int version) = 0;
 
  virtual void writeValues(const char* name, const MLint32*  values, size_t n, bool fixedList) = 0;
  virtual void writeValues(const char* name, const MLuint32* values, size_t n, bool fixedList) = 0;
  virtual void writeValues(const char* name, const MLint64*  values, size_t n, bool fixedList) = 0;
  virtual void writeValues(const char* name, const MLuint64* values, size_t n, bool fixedList) = 0;
  virtual void writeValues(const char* name, const MLfloat*  values, size_t n, bool fixedList) = 0;
  virtual void writeValues(const char* name, const MLdouble* values, size_t n, bool fixedList) = 0;
 
  virtual void writeString(const char* name, const std::string& value) = 0;
 
  void nameCheck(const char* name) override;
};
 
// -----------------------------------------------------------------------------
 
class ML_UTILS_EXPORT AbstractPersistenceInputStream : public AbstractPersistenceStream
{
public:
  virtual ~AbstractPersistenceInputStream() {}
 
  int startStructWithVersion(const char* name = nullptr);
 
  virtual void read(bool& value, const char* name = nullptr);
 
  void read(MLint32&  value, const char* name = nullptr);
  void read(MLuint32& value, const char* name = nullptr);
  void read(MLint64&  value, const char* name = nullptr);
  void read(MLuint64& value, const char* name = nullptr);
  void read(MLfloat&  value, const char* name = nullptr);
  void read(MLdouble& value, const char* name = nullptr);
  void read(std::string& value, const char* name = nullptr);
 
  template<typename T>
  void read(std::vector<T>& values, const char* name = nullptr)
  {
    nameCheck(name);
    readValues(name, 0, values);
  }
 
  template<typename T, size_t n, class DataContainer>
  void read(FloatingPointVector<T, n, DataContainer>& value, const char* name = nullptr)
  {
    nameCheck(name);
    std::vector<T> buffer;
    readValues(name, n, buffer);
    for(size_t i=0;i<n;i++) {
      value[i] = buffer[i];
    }
  }
 
  template<typename T, size_t n>
  void read(TVectorNDBase<T, n>& value, const char* name = nullptr)
  {
    nameCheck(name);
    std::vector<T> buffer;
    readValues(name, n, buffer);
    for(size_t i=0;i<n;i++) {
      value[i] = buffer[i];
    }
  }
 
  template<typename T, size_t n>
  void read(FloatingPointMatrix<T, n>& value, const char* name = nullptr)
  {
    nameCheck(name);
    std::vector<typename T::ComponentType> buffer;
    readValues(name, n, buffer);
    value.setValuesFromPtr(buffer.data());
  }
 
  template<typename T>
  void readOptional(T& value, const T& defaultValue, const char* name = nullptr)
  {
    if (_isAvailable(name)) {
      read(value, name);
    } else {
      value = defaultValue;
    }
  }
 
  virtual Base* readObject(const char* name = nullptr);
 
  virtual void readData(std::string& value, const char* name = nullptr) = 0;
 
  bool hasNextInStruct(std::string& name);
 
  bool isNextInStruct(const char* name);
 
  bool hasNextListItem();
 
  void versionCheck(const char* className, int objectVersion, int storedVersion);
 
protected:
  AbstractPersistenceInputStream() {}
 
  virtual bool hasNextInStructImpl(std::string& name) = 0;
 
  virtual bool hasNextListItemImpl() = 0;
 
  virtual bool getObjectID(int& id) = 0;
  virtual bool getObjectType(std::string& type) = 0;
  virtual bool getObjectVersion(int& version) = 0;
 
  virtual void readValues(const char* name, size_t expected, std::vector<MLint32>&  values) = 0;
  virtual void readValues(const char* name, size_t expected, std::vector<MLuint32>& values) = 0;
  virtual void readValues(const char* name, size_t expected, std::vector<MLint64>&  values) = 0;
  virtual void readValues(const char* name, size_t expected, std::vector<MLuint64>& values) = 0;
  virtual void readValues(const char* name, size_t expected, std::vector<MLfloat>&  values) = 0;
  virtual void readValues(const char* name, size_t expected, std::vector<MLdouble>& values) = 0;
 
  virtual void readString(const char* name, std::string& value) = 0;
 
  virtual void formatError(const std::string& msg);
 
private:
  bool _isAvailable(const char* name);
 
  std::set<std::string> _futureVersionClasses;
};
 
// -----------------------------------------------------------------------------
 
class ML_UTILS_EXPORT PersistenceStreamException
{
public:
  enum ErrorType {
    IOError,
    FormatError,
    InternalError
  };
 
  virtual ~PersistenceStreamException() {}
 
  ErrorType getErrorType() const { return _type; }
 
  virtual std::string getMessage() const { return _msg; }
 
protected:
  PersistenceStreamException(ErrorType type, const std::string& msg) : _type(type), _msg(msg) {}
 
  ErrorType _type;
  std::string _msg;
};
 
class ML_UTILS_EXPORT PersistenceStreamIOException : public PersistenceStreamException
{
public:
  PersistenceStreamIOException(const std::string& msg)
    : PersistenceStreamException(IOError, msg) {}
};
 
class ML_UTILS_EXPORT PersistenceStreamFormatException : public PersistenceStreamException
{
public:
  PersistenceStreamFormatException(const std::string& msg)
    : PersistenceStreamException(FormatError, msg) {}
};
 
class ML_UTILS_EXPORT PersistenceStreamInternalError : public PersistenceStreamException
{
public:
  PersistenceStreamInternalError(const std::string& msg)
    : PersistenceStreamException(FormatError, msg) {}
};
 
ML_UTILS_END_NAMESPACE
// -----------------------------------------------------------------------------
 
#define ML_WRITETO_SUPER(SuperClass, stream) { \
  stream->startStructWithVersion(SuperClass::getAddStateVersion(), "_" #SuperClass); \
  SuperClass::writeTo(stream); \
  stream->endStruct(); \
}
 
#define ML_READFROM_SUPER(SuperClass, stream) { \
  int version = stream->startStructWithVersion("_" #SuperClass); \
  SuperClass::readFrom(stream, version); \
  stream->versionCheck(SuperClass::getTypeId()->getName(), SuperClass::getAddStateVersion(), version); \
  stream->endStruct(); \
}
 
// -----------------------------------------------------------------------------
 
#endif