DCMTree_SerializationHelper.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_HELPER_H
#define DCM_TREE_SERIALIZATION_HELPER_H
 
#include "DCMTree_Serialization.h"
#include "DCMTree_Exception.h"
 
#include <boost/shared_ptr.hpp>
 
#include <string>
#include <map>
#include <vector>
#include <set>
#include <limits>
 
#ifdef _MSC_VER
  #pragma warning (push)
  #pragma warning (disable : 4018)
#endif
 
namespace DCMTree_Serialization
{
    template<typename T>
    inline void serializePrimitiveX(Sink &sink, T value)
    {
        sink.writeX(&value, sizeof(value));
    }
 
    template<typename T>
    inline void deserializePrimitiveX(Source &source, T &value)
    {
        source.readX(&value, sizeof(value));
    }
 
    void serializeX(Sink &sink, int value);
 
    void deserializeX(Source &source, int &value);
 
    void serializeX(Sink &sink, unsigned int value);
 
    void deserializeX(Source &source, unsigned int &value);
 
    void serializeX(Sink &sink, short value);
 
    void deserializeX(Source &source, short &value);
 
    void serializeX(Sink &sink, unsigned short  value);
 
    void deserializeX(Source &source, unsigned short  &value);
 
    void serializeX(Sink &sink, long value);
 
    void deserializeX(Source &source, long &value);
 
    void serializeX(Sink &sink, unsigned long value);
 
    void deserializeX(Source &source, unsigned long &value);
 
    void serializeX(Sink &sink, long long value);
 
    void deserializeX(Source &source, long long &value);
 
    void serializeX(Sink &sink, unsigned long long value);
 
    void deserializeX(Source &source, unsigned long long &value);
 
    void serializeX(Sink &sink, float value);
 
    void deserializeX(Source &source, float &value);
 
    void serializeX(Sink &sink, const double &value);
 
    void deserializeX(Source &source, double &value);
 
    void serializeX(Sink &sink, bool value);
 
    void deserializeX(Source &source, bool &value);
 
    void serializeX(Sink &sink, const std::string &value);
 
    void deserializeX(Source &source, std::string &value);
 
    template<typename T>
    inline void serializeEnumX(Sink &sink, T value)
    {
        sink.writeTypeX(TC_ENUM);
        serializePrimitiveX(sink, static_cast<int>(value));
    }
 
    template<typename T>
    inline void deserializeEnumX(Source &source, T &value)
    {
        source.readTypeX(TC_ENUM);
        int i = 0;
        deserializePrimitiveX(source, i);
        value = static_cast<T>(i);
    }
 
    inline void serializeX(Sink &sink, const Serializable &value)
    {
        value.serializeX(sink);
    }
 
    inline void deserializeX(Source &source, Deserializable &value)
    {
        value.deserializeX(source);
    }
 
    template<typename T>
    inline void serializeX(Sink &sink, boost::shared_ptr<T> value)
    {
        serializeX(sink, *value);
    }
 
    template<typename T>
    inline void deserializeIntoNewX(Source &source, boost::shared_ptr<T>& value)
    {
        value = boost::shared_ptr<T>(new T());
        deserializeX(source, *value);
    }
 
    template<typename T>
    inline void deserializeIntoExistingX(Source &source, boost::shared_ptr<T> value)
    {
        deserializeX(source, *value);
    }
 
    template<typename T,typename U>
    inline void serializeX(Sink &sink, const std::pair<T,U> &value)
    {
        sink.writeTypeX(TC_PAIR);
        serializeX(sink, value.first);
        serializeX(sink, value.second);
    }
 
    template<typename T,typename U>
    inline void deserializeX(Source &source, std::pair<T,U> &value)
    {
        source.readTypeX(TC_PAIR);
        deserializeX(source, value.first);
        deserializeX(source, value.second);
    }
 
    template<typename T,typename U>
    inline void serializeX(Sink &sink, const std::map<T,U> &value)
    {
        sink.writeTypeX(TC_MAP);
        if ( std::numeric_limits<boost::uint32_t>::max() < value.size() )
        {
          throw DCMTree::Exception( "DCMTree_Serialization::serializeX()", "Value size too large for serialization" );
        }
        serializeX( sink, static_cast<boost::uint32_t>( value.size() ) );
 
        typename std::map<T,U>::const_iterator mapEnd = value.end();
        for(typename std::map<T,U>::const_iterator i = value.begin(); i != mapEnd; i++)
        {
            serializeX(sink, (*i).first);
            serializeX(sink, (*i).second);
        }
    }
 
    template<typename T,typename U>
    inline void deserializeX(Source &source, std::map<T,U> &value)
    {
        source.readTypeX(TC_MAP);
        //typename std::map<T,U>::size_type size;
        boost::uint32_t size;
        deserializeX(source, size);
        value.clear();
        for(typename std::map<T,U>::size_type i = 0; i < size; i++)
        {
            T t;
            deserializeX(source, t);
            deserializeX(source, value[t]);
        }
    }
 
    template<typename T,typename U>
    inline void serializeX(Sink &sink, const std::multimap<T,U> &value)
    {
        sink.writeTypeX(TC_MULTIMAP);
        if ( std::numeric_limits<boost::uint32_t>::max() < value.size() )
        {
          throw DCMTree::Exception( "DCMTree_Serialization::serializeX()", "Value size too large for serialization" );
        }
        serializeX( sink, static_cast<boost::uint32_t>( value.size() ) );
 
        typename std::multimap<T,U>::const_iterator mapEnd = value.end();
        for(typename std::multimap<T,U>::const_iterator i = value.begin(); i != mapEnd; i++)
        {
            serializeX(sink, (*i).first);
            serializeX(sink, (*i).second);
        }
    }
 
    template<typename T,typename U>
    inline void deserializeX(Source &source, std::multimap<T,U> &value)
    {
        source.readTypeX(TC_MULTIMAP);
        //typename std::multimap<T,U>::size_type size;
        boost::uint32_t size;
        deserializeX(source, size);
        value.clear();
        for(typename std::multimap<T,U>::size_type i = 0; i < size; i++)
        {
            T t;
            deserializeX(source, t);
            U u;
            deserializeX(source, u);
            value.insert(std::make_pair(t,u));
        }
    }
 
    template<typename T>
    inline void serializeX(Sink &sink, const std::set<T> &value)
    {
        sink.writeTypeX(TC_SET);
        if ( std::numeric_limits<boost::uint32_t>::max() < value.size() )
        {
          throw DCMTree::Exception( "DCMTree_Serialization::serializeX()", "Value size too large for serialization" );
        }
        serializeX( sink, static_cast<boost::uint32_t>( value.size() ) );
 
        typename std::set<T>::const_iterator setEnd = value.end();
        for(typename std::set<T>::const_iterator i = value.begin(); i != setEnd; i++)
        {
            serializeX(sink, (*i));
        }
    }
 
    template<typename T>
    inline void deserializeX(Source &source, std::set<T> &value)
    {
        source.readTypeX(TC_SET);
        //typename std::set<T>::size_type size;
        boost::uint32_t size;
        deserializeX(source, size);
        value.clear();
        for(typename std::set<T>::size_type i = 0; i < size; i++)
        {
            T t;
            deserializeX(source, t);
            value.insert(t);
        }
    }
 
    template<typename T>
    inline void serializeX(Sink &sink, const std::vector<T> &vl)
    {
        sink.writeTypeX(TC_VECTOR);
        // BugID: 31906
        // size_type of a vector is not standardized between 32 and 64 bit OSs. Force it to 32 bit max.
        //serializePrimitiveX(sink, vl.size());
        if ( std::numeric_limits<std::uint32_t>::max() < vl.size() )
        {
          throw DCMTree::Exception( "DCMTree_Serialization::serializeX()", "Value size too large for serialization" );
        }
        serializePrimitiveX( sink, static_cast<std::uint32_t>( vl.size() ) );
 
        for( auto i = 0u; i < vl.size(); ++i )
        {
            serializeX(sink, vl[i]);
        }
    }
 
    template<typename T>
    inline void deserializeX(Source &source, std::vector<T> &vl)
    {
        source.readTypeX(TC_VECTOR);
        // BugID: 31906
        // size_type of a vector is not standardized between 32 and 64 bit OSs
        //typename std::vector<T>::size_type count;
        boost::uint32_t       count;
 
        deserializePrimitiveX(source, count);
        vl.clear();
        vl.resize(count);
        // BugID: 31906
        //for(typename std::vector<T>::size_type i = 0; i < count; ++i)
        for( boost::uint32_t i = 0; i < count; ++i)
        {
            deserializeX(source, vl[i]);
        }
    }
 
    template<typename T>
    inline void serializeX(SerializerIntf<T> &serializer, Sink &sink, const T &value)
    {
        serializer.serializeX(sink, value);
    }
 
    template<typename T>
    inline void deserializeX(DeserializerIntf<T> &deserializer, Source &source, T &value)
    {
        value = deserializer.deserializeX(source);
    }
 
    template<typename T>
    inline bool serialize(Sink &sink, const T &value)
    {
        try {
            serializeX(value);
        }
        catch(.../*const SerializationException&*/) {
            return false;
        }
 
        return true;
    }
 
    template<typename T>
    inline bool deserialize(Source &source, T &value)
    {
        try {
            deserializeX(source,value);
        }
        catch(.../*const SerializationException&*/) {
            return false;
        }
 
        return true;
    }
}
 
#ifdef _MSC_VER
  #pragma warning (pop)
#endif
 
#endif