MeVis/Foundation/Sources/MLUtilities/mlAbstractPersistenceStream.h

Go to the documentation of this file.

// **InsertLicense** code
//-------------------------------------------------------------------------
//-------------------------------------------------------------------------

#ifndef __mlAbstractPersistenceStream_H
#define __mlAbstractPersistenceStream_H

#include "mlUtilsSystem.h"
#include "mlTypeDefs.h"

#include "mlSystemWarningsDisable.h"
#include <list>
#include <set>
#include "mlSystemWarningsRestore.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 = NULL, const char* xmlItemName = "Item", bool xmlSuppressScope = false);
  
  void endList();
  
  void startStruct(const char* name = NULL);
  
  void endStruct();

  virtual bool isBinary() const = 0;

protected:
  AbstractPersistenceStream();
  ~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 = NULL);
  
private:
  std::list<bool> _isListStack;
};

// -----------------------------------------------------------------------------

class ML_UTILS_EXPORT AbstractPersistenceOutputStream : public AbstractPersistenceStream
{
public:
  ~AbstractPersistenceOutputStream() {}

  void startStructWithVersion(int version, const char* name = NULL);



  virtual void write(bool value, const char* name = NULL);

  void write(MLint32  value, const char* name = NULL);
  void write(MLuint32 value, const char* name = NULL);
  void write(MLint64  value, const char* name = NULL);
  void write(MLuint64 value, const char* name = NULL);
  void write(MLfloat  value, const char* name = NULL);
  void write(MLdouble value, const char* name = NULL);
  void write(const std::string& value, const char* name = NULL);

  void write(const char* value, const char* name = NULL) { write(std::string(value), name); }
  
  template<typename T>
  void write(const std::vector<T>& values, const char* name = NULL)
  {
    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 = NULL)
  {
    nameCheck(name);
    writeValues(name, &value[0], n, true);
  }
  
  template<typename T, size_t n>
  void write(const TVectorNDBase<T, n>& value, const char* name = NULL)
  {
    nameCheck(name);
    writeValues(name, &value.array, n, true);
  }
  
  template<typename T, size_t n>
  void write(const FloatingPointMatrix<T, n>& value, const char* name = NULL)
  {
    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 = NULL);

  virtual void writeData(const void* data, size_t len, const char* name = NULL) = 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;

  virtual void nameCheck(const char* name);
};

// -----------------------------------------------------------------------------

class ML_UTILS_EXPORT AbstractPersistenceInputStream : public AbstractPersistenceStream
{
public:
  ~AbstractPersistenceInputStream() {}

  int startStructWithVersion(const char* name = NULL);



  virtual void read(bool& value, const char* name = NULL);

  void read(MLint32&  value, const char* name = NULL);
  void read(MLuint32& value, const char* name = NULL);
  void read(MLint64&  value, const char* name = NULL);
  void read(MLuint64& value, const char* name = NULL);
  void read(MLfloat&  value, const char* name = NULL);
  void read(MLdouble& value, const char* name = NULL);
  void read(std::string& value, const char* name = NULL);

  template<typename T>
  void read(std::vector<T>& values, const char* name = NULL)
  {
    nameCheck(name);
    readValues(name, 0, values);
  }
  
  template<typename T, size_t n, class DataContainer>
  void read(FloatingPointVector<T, n, DataContainer>& value, const char* name = NULL)
  {
    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 = NULL)
  {
    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 = NULL)
  {
    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 = NULL)
  {
    if (_isAvailable(name)) {
      read(value, name);
    } else {
      value = defaultValue;
    }
  }

  virtual Base* readObject(const char* name = NULL);

  virtual void readData(std::string& value, const char* name = NULL) = 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