MeVis/Foundation/Sources/DicomTree/MLDicomTree/DCMTree_Serialization.h

Go to the documentation of this file.

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

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

#ifndef CLASS_DCMTREE_SERIALIZATION
#define CLASS_DCMTREE_SERIALIZATION

#include "DCMTree_Defines.h"
#include "boost/cstdint.hpp"
#include "boost/limits.hpp"
#include <string>

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