BinarySerialization.hpp

Go to the documentation of this file.

#pragma once
#ifndef BIL_BINARYSERIALIZATION_HPP
#define BIL_BINARYSERIALIZATION_HPP

#include <istream>
#include <ostream>
#include <map>
#include <string>
#include <vector>
#include <boost/type_traits/is_pod.hpp>
#include <boost/utility/enable_if.hpp>
#include <exception/IOException.hpp>


namespace bil {

    template <typename T> inline
    typename boost::enable_if<boost::is_pod<T>, void>::type
    writeBinary(const T& data, std::ostream& outputStream)
    {
        // write data as one block
        outputStream.write(reinterpret_cast<const char*>(&data), sizeof(T));
        if (!outputStream) throw IOException();
    }

    template <typename T> inline
    typename boost::enable_if<boost::is_pod<T>, void>::type
    writeBinary(const std::vector<T>& data, std::ostream& outputStream)
    {
        // write vector length
        size_t length = data.size();
        outputStream.write(reinterpret_cast<const char*>(&length), sizeof(length));
        if (!outputStream) throw IOException();
        // write vector data as one block
        if (0 < length)
        {
            outputStream.write(reinterpret_cast<const char*>(&(data[0])), sizeof(T) * length);
            if (!outputStream) throw IOException();
        }
    }

    template <typename T> inline
    typename boost::disable_if<boost::is_pod<T>, void>::type
    writeBinary(const std::vector<T>& data, std::ostream& outputStream)
    {
        // write vector length
        size_t length = data.size();
        outputStream.write(reinterpret_cast<const char*>(&length), sizeof(length));
        if (!outputStream) throw IOException();
        // write vector data one by one
        for (size_t i = 0; i < length; ++i)
            writeBinary(data[i], outputStream);
    }

    template <typename K, typename V, typename C, typename A> inline
    void writeBinary(const std::map<K, V, C, A>& data, std::ostream& outputStream)
    {
        // write map entry count
        size_t length = data.size();
        outputStream.write(reinterpret_cast<const char*>(&length), sizeof(length));
        if (!outputStream) throw IOException();
        // write map data one by one
        std::map<K, V, C, A>::const_iterator it = data.begin();
        std::map<K, V, C, A>::const_iterator itEnd = data.end();
        for (; it != itEnd; ++it)
        {
            writeBinary(it->first, outputStream);
            writeBinary(it->second, outputStream);
        }
    }

    void writeBinary(const std::string& data, std::ostream& outputStream);


    template <typename T> inline
    typename boost::enable_if<boost::is_pod<T>, void>::type
    readBinary(T& data, std::istream& inputStream)
    {
        // read data as one block
        inputStream.read(reinterpret_cast<char*>(&data), sizeof(T));
        if (!inputStream) throw IOException();
    }

    template <typename T> inline
    typename boost::enable_if<boost::is_pod<T>, void>::type
    readBinary(std::vector<T>& data, std::istream& inputStream)
    {
        // read vector length
        size_t length;
        inputStream.read(reinterpret_cast<char*>(&length), sizeof(length));
        if (!inputStream) throw IOException();
        // read vector data as one block
        data.resize(length);
        if (0 < length)
        {
            inputStream.read(reinterpret_cast<char*>(&(data[0])), sizeof(T) * length);
            if (!inputStream) throw IOException();
        }
    }

    template <typename T> inline
    typename boost::disable_if<boost::is_pod<T>, void>::type
    readBinary(std::vector<T>& data, std::istream& inputStream)
    {
        // read vector length
        size_t length;
        inputStream.read(reinterpret_cast<char*>(&length), sizeof(length));
        if (!inputStream) throw IOException();
        // write vector data one by one
        data.resize(length);
        for (size_t i = 0; i < length; ++i)
            readBinary(data[i], inputStream);
    }

    template <typename K, typename V, typename C, typename A> inline
    void readBinary(std::map<K, V, C, A>& data, std::istream& inputStream)
    {
        // read map entry count
        size_t length = data.size();
        inputStream.read(reinterpret_cast<char*>(&length), sizeof(length));
        if (!inputStream) throw IOException();
        // read map entries one by one
        data.clear();
        for (size_t i = 0; i < length; ++i)
        {
            // read key
            K key;
            readBinary(key, inputStream);
            // add it to map
            std::pair<std::map<K, V>::iterator, bool> ret =
                data.insert(std::make_pair(key, V()));
            V& value = (ret.first)->second;
            // read value
            readBinary(value, inputStream);
        }
    }

    void readBinary(std::string& data, std::istream& inputStream);

}

#endif