DCMTree_Serialization.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 DCM_TREE_SERIALIZATION_H
#define DCM_TREE_SERIALIZATION_H
 
#ifdef _MSC_VER
  #pragma warning (push)
  #pragma warning (disable : 4350)
#endif
 
#include "DCMTree_Defines.h"
#include <boost/cstdint.hpp>
#include <boost/limits.hpp>
#include <string>
 
#ifdef _MSC_VER
  #pragma warning (pop)
#endif
 
namespace DCMTree_Serialization
{
    enum TypeCode
    {
        TC_BOOL,
        TC_SIGNED_INT,
        TC_UNSIGNED_INT,
        TC_SIGNED_SHORT,
        TC_UNSIGNED_SHORT,
        TC_SIGNED_LONG,
        TC_UNSIGNED_LONG,
        TC_FLOAT,
        TC_DOUBLE,
        TC_STRING,
        TC_PAIR,
        TC_VECTOR,
        TC_MAP,
        TC_SET,
        TC_MULTIMAP,
        TC_ENUM,
        TC_OTHER,
        TC_SIGNED_LONG_LONG,
        TC_UNSIGNED_LONG_LONG,
    };
 
    class DCMTREE_EXPORT Sink {
    public:
        virtual ~Sink(){};
 
        void writeX(const std::string &value);
 
        void writeTypeX(TypeCode tc)
        {
            boost::uint32_t c = static_cast<boost::uint32_t>(tc);
            writeX(&c, sizeof(boost::uint32_t));
        }
 
        virtual void writeX(const void *data, boost::uint32_t size) = 0;
    };
 
    class DCMTREE_EXPORT Source {
    public:
        virtual ~Source(){};
 
        void readX(std::string &value);
 
        void readTypeX(TypeCode expected);
 
        virtual void readX(void *data, boost::uint32_t size) = 0;
 
        virtual void rewind()=0;
    };
 
    class DCMTREE_EXPORT Serializable {
    public:
        virtual void serializeX(Sink &sink) const = 0;
 
        virtual ~Serializable(){}
    };
 
    class DCMTREE_EXPORT Deserializable {
    public:
        virtual void deserializeX(Source &source) = 0;
 
        virtual ~Deserializable(){}
    };
 
    template<typename T>
    class SerializerIntf {
    public:
        virtual ~SerializerIntf(){}
 
        virtual void serializeX(Sink &sink, const T &value) = 0;
    };
 
    template<typename T>
    class DeserializerIntf {
    public:
        virtual ~DeserializerIntf(){}
 
        virtual T deserializeX(Source &source) = 0;
    };
}
 
#endif