SerializeToVector.h

Go to the documentation of this file.

// This file is part of CoreLibrary containing useful reusable utility
// classes.
//
// Copyright (C) 2014 to present, Duncan Crutchley
// Contact <dac1976github@outlook.com>
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as published
// by the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License and GNU Lesser General Public License
// for more details.
//
// You should have received a copy of the GNU General Public License
// and GNU Lesser General Public License along with this program. If
// not, see <http://www.gnu.org/licenses/>.

#ifndef SERIALIZETOVECTOR
#define SERIALIZETOVECTOR

#include "CoreLibraryDllGlobal.h"
#include "SerializationIncludes.h"
#include <vector>
#include <utility>
#include <sstream>
#include <iterator>
#include <type_traits>
#include <algorithm>
#include <cereal/types/vector.hpp>
#include <boost/throw_exception.hpp>

namespace core_lib
{
namespace serialize
{

using char_vector_t = std::vector<char>;

struct CORE_LIBRARY_DLL_SHARED_API raw_iarchive
{
};

struct CORE_LIBRARY_DLL_SHARED_API raw_oarchive
{
};

struct CORE_LIBRARY_DLL_SHARED_API protobuf_iarchive
{
};

struct CORE_LIBRARY_DLL_SHARED_API protobuf_oarchive
{
};

namespace archives
{

using out_port_bin_t = cereal::PortableBinaryOutputArchive;
using out_bin_t = cereal::BinaryOutputArchive;
using out_xml_t = cereal::XMLOutputArchive;
using out_json_t = cereal::JSONOutputArchive;
using out_raw_t = raw_oarchive;
using out_protobuf_t = protobuf_oarchive;
using in_port_bin_t = cereal::PortableBinaryInputArchive;
using in_bin_t = cereal::BinaryInputArchive;
using in_xml_t = cereal::XMLInputArchive;
using in_json_t = cereal::JSONInputArchive;
using in_raw_t = raw_iarchive;
using in_protobuf_t = protobuf_iarchive;

} // namespace archives

namespace impl
{

template <typename T, typename A> struct ToCharVectorImpl
{
    char_vector_t operator()(const T& object) const
    {
        std::stringstream os;
        // Reduce scope of archive to make sure it has
        // flushed its contents to the stream before
        // we try and do anything with it.
        {
            A oa(os);
            // CEREAL_NVP is required to fully support xml archives.
            oa(CEREAL_NVP(object));
        }

        char_vector_t charVector;
        charVector.assign(std::istreambuf_iterator<char>(os), std::istreambuf_iterator<char>());
        return charVector;
    }

    void operator()(const T& object, char_vector_t& result) const
    {
        std::stringstream os;
        // Reduce scope of archive to make sure it has
        // flushed its contents to the stream before
        // we try and do anything with it.
        {
            A oa(os);
            // CEREAL_NVP is required to fully support xml archives.
            oa(CEREAL_NVP(object));
        }

        result.assign(std::istreambuf_iterator<char>(os), std::istreambuf_iterator<char>());
    }
};

template <typename T> struct ToCharVectorImpl<T, archives::out_raw_t>
{
    char_vector_t operator()(const T& object) const
    {
        if (!std::is_pod<T>::value)
        {
            BOOST_THROW_EXCEPTION(std::invalid_argument("object is not POD"));
        }

        auto          begin = reinterpret_cast<char const*>(&object);
        auto          end   = std::next(begin, static_cast<int>(sizeof(T)));
        char_vector_t charVector;
        std::copy(begin, end, std::back_inserter(charVector));
        return charVector;
    }

    void operator()(const T& object, char_vector_t& result) const
    {
        if (!std::is_pod<T>::value)
        {
            BOOST_THROW_EXCEPTION(std::invalid_argument("object is not POD"));
        }

        auto len = sizeof(T);
        result.clear();
        result.reserve(len);
        auto begin = reinterpret_cast<char const*>(&object);
        auto end   = std::next(begin, static_cast<int>(len));
        std::copy(begin, end, std::back_inserter(result));
    }
};

template <typename T> struct ToCharVectorImpl<T, archives::out_protobuf_t>
{
    char_vector_t operator()(const T& object) const
    {
        std::stringstream os;

        if (!object.SerializeToOstream(&os))
        {
            BOOST_THROW_EXCEPTION(std::runtime_error("failed to serialize protocol buffer"));
        }

        char_vector_t charVector;
        charVector.assign(std::istreambuf_iterator<char>(os), std::istreambuf_iterator<char>());
        return charVector;
    }

    void operator()(const T& object, char_vector_t& result) const
    {
        std::stringstream os;

        if (!object.SerializeToOstream(&os))
        {
            BOOST_THROW_EXCEPTION(std::runtime_error("failed to serialize protocol buffer"));
        }

        result.assign(std::istreambuf_iterator<char>(os), std::istreambuf_iterator<char>());
    }
};

template <typename T, typename A> struct ToObjectImpl
{
    T operator()(const char_vector_t& charVector) const
    {
        std::stringstream is;
        std::copy(charVector.begin(), charVector.end(), std::ostream_iterator<char>(is));
        T object;
        // Reduce scope of archive to make sure it has
        // flushed its contents to the stream before
        // we try and do anything with it.
        {
            A ia(is);
            // CEREAL_NVP is required to fully support xml archives.
            ia(CEREAL_NVP(object));
        }

        return object;
    }
};

template <typename T> struct ToObjectImpl<T, archives::in_raw_t>
{
    T operator()(const char_vector_t& charVector) const
    {
        if (!std::is_pod<T>::value)
        {
            BOOST_THROW_EXCEPTION(std::invalid_argument("object is not POD"));
        }

        if (charVector.size() != sizeof(T))
        {
            BOOST_THROW_EXCEPTION(std::invalid_argument("buffer to object size mismatch"));
        }

        T object{};
        memcpy(&object, charVector.data(), charVector.size());
        return object;
    }
};

template <typename T> struct ToObjectImpl<T, archives::in_protobuf_t>
{
    T operator()(const char_vector_t& charVector) const
    {
        std::stringstream is;
        std::copy(charVector.begin(), charVector.end(), std::ostream_iterator<char>(is));
        T object;

        if (!object.ParseFromIstream(&is))
        {
            BOOST_THROW_EXCEPTION(std::runtime_error("failed to deserialize to protocol buffer"));
        }

        return object;
    }
};

} // namespace impl

template <typename T, typename OA = archives::out_port_bin_t>
char_vector_t ToCharVector(const T& object)
{
    return impl::ToCharVectorImpl<T, OA>()(object);
}

template <typename T, typename OA = archives::out_port_bin_t>
void ToCharVector(const T& object, char_vector_t& result)
{
    impl::ToCharVectorImpl<T, OA>()(object, result);
}

template <typename T, typename IA = archives::in_port_bin_t>
T ToObject(const char_vector_t& charVector)
{
    return impl::ToObjectImpl<T, IA>()(charVector);
}

} // namespace serialize
} // namespace core_lib

#endif // #define SERIALIZETOVECTOR