SerializeUtil.h

Go to the documentation of this file.

 
#ifndef ZSERIO_SERIALIZE_UTIL_H_INC
#define ZSERIO_SERIALIZE_UTIL_H_INC
 
#include "zserio/BitStreamReader.h"
#include "zserio/BitStreamWriter.h"
#include "zserio/FileUtil.h"
#include "zserio/Traits.h"
#include "zserio/Types.h"
#include "zserio/Vector.h"
 
namespace zserio
{
 
namespace detail
{
 
template <typename T>
void initializeChildrenImpl(std::true_type, T& object)
{
    object.initializeChildren();
}
 
template <typename T>
void initializeChildrenImpl(std::false_type, T&)
{}
 
template <typename T>
void initializeChildren(T& object)
{
    initializeChildrenImpl(has_initialize_children<T>(), object);
}
 
template <typename T, typename... ARGS>
void initializeImpl(std::true_type, T& object, ARGS&&... arguments)
{
    object.initialize(std::forward<ARGS>(arguments)...);
}
 
template <typename T>
void initializeImpl(std::false_type, T& object)
{
    initializeChildren(object);
}
 
template <typename T, typename... ARGS>
void initialize(T& object, ARGS&&... arguments)
{
    initializeImpl(has_initialize<T>(), object, std::forward<ARGS>(arguments)...);
}
 
template <typename T, typename = void>
struct allocator_chooser
{
    using type = std::allocator<uint8_t>;
};
 
template <typename T>
struct allocator_chooser<T, detail::void_t<typename T::allocator_type>>
{
    using type = typename T::allocator_type;
};
 
// This implementation needs to be in detail because old MSVC compiler 2015 has problems with calling overload.
template <typename T, typename ALLOC, typename... ARGS>
BasicBitBuffer<ALLOC> serialize(T& object, const ALLOC& allocator, ARGS&&... arguments)
{
    detail::initialize(object, std::forward<ARGS>(arguments)...);
    BasicBitBuffer<ALLOC> bitBuffer(object.initializeOffsets(), allocator);
    BitStreamWriter writer(bitBuffer);
    object.write(writer);
    return bitBuffer;
}
 
} // namespace detail
 
template <typename T, typename ALLOC, typename... ARGS,
        typename std::enable_if<!std::is_enum<T>::value && is_allocator<ALLOC>::value, int>::type = 0>
BasicBitBuffer<ALLOC> serialize(T& object, const ALLOC& allocator, ARGS&&... arguments)
{
    return detail::serialize(object, allocator, std::forward<ARGS>(arguments)...);
}
 
template <typename T, typename ALLOC = typename detail::allocator_chooser<T>::type, typename... ARGS,
        typename std::enable_if<!std::is_enum<T>::value &&
                        !is_first_allocator<typename std::decay<ARGS>::type...>::value,
                int>::type = 0>
BasicBitBuffer<ALLOC> serialize(T& object, ARGS&&... arguments)
{
    return detail::serialize(object, ALLOC(), std::forward<ARGS>(arguments)...);
}
 
template <typename T, typename ALLOC = std::allocator<uint8_t>,
        typename std::enable_if<std::is_enum<T>::value, int>::type = 0>
BasicBitBuffer<ALLOC> serialize(T enumValue, const ALLOC& allocator = ALLOC())
{
    BasicBitBuffer<ALLOC> bitBuffer(zserio::bitSizeOf(enumValue), allocator);
    BitStreamWriter writer(bitBuffer);
    zserio::write(writer, enumValue);
    return bitBuffer;
}
 
template <typename T, typename ALLOC, typename... ARGS>
typename std::enable_if<!std::is_enum<T>::value, T>::type deserialize(
        const BasicBitBuffer<ALLOC>& bitBuffer, ARGS&&... arguments)
{
    BitStreamReader reader(bitBuffer);
    return T(reader, std::forward<ARGS>(arguments)...);
}
 
template <typename T, typename ALLOC>
typename std::enable_if<std::is_enum<T>::value, T>::type deserialize(const BasicBitBuffer<ALLOC>& bitBuffer)
{
    BitStreamReader reader(bitBuffer);
    return zserio::read<T>(reader);
}
 
template <typename T, typename ALLOC, typename... ARGS,
        typename std::enable_if<!std::is_enum<T>::value && is_allocator<ALLOC>::value, int>::type = 0>
vector<uint8_t, ALLOC> serializeToBytes(T& object, const ALLOC& allocator, ARGS&&... arguments)
{
    const BasicBitBuffer<ALLOC> bitBuffer =
            detail::serialize(object, allocator, std::forward<ARGS>(arguments)...);
 
    return bitBuffer.getBytes();
}
 
template <typename T, typename ALLOC = typename detail::allocator_chooser<T>::type, typename... ARGS,
        typename std::enable_if<!std::is_enum<T>::value &&
                        !is_first_allocator<typename std::decay<ARGS>::type...>::value,
                int>::type = 0>
vector<uint8_t, ALLOC> serializeToBytes(T& object, ARGS&&... arguments)
{
    const BasicBitBuffer<ALLOC> bitBuffer =
            detail::serialize(object, ALLOC(), std::forward<ARGS>(arguments)...);
 
    return bitBuffer.getBytes();
}
 
template <typename T, typename ALLOC = std::allocator<uint8_t>,
        typename std::enable_if<std::is_enum<T>::value, int>::type = 0>
vector<uint8_t, ALLOC> serializeToBytes(T enumValue, const ALLOC& allocator = ALLOC())
{
    const BasicBitBuffer<ALLOC> bitBuffer = serialize(enumValue, allocator);
 
    return bitBuffer.getBytes();
}
 
template <typename T, typename... ARGS>
typename std::enable_if<!std::is_enum<T>::value, T>::type deserializeFromBytes(
        Span<const uint8_t> buffer, ARGS&&... arguments)
{
    BitStreamReader reader(buffer);
    return T(reader, std::forward<ARGS>(arguments)...);
}
 
template <typename T>
typename std::enable_if<std::is_enum<T>::value, T>::type deserializeFromBytes(Span<const uint8_t> buffer)
{
    BitStreamReader reader(buffer);
    return zserio::read<T>(reader);
}
 
template <typename T, typename... ARGS>
void serializeToFile(T& object, const std::string& fileName, ARGS&&... arguments)
{
    const auto bitBuffer = serialize(object, std::forward<ARGS>(arguments)...);
    writeBufferToFile(bitBuffer, fileName);
}
 
template <typename T, typename... ARGS>
T deserializeFromFile(const std::string& fileName, ARGS&&... arguments)
{
    const BitBuffer bitBuffer = readBufferFromFile(fileName);
    return deserialize<T>(bitBuffer, std::forward<ARGS>(arguments)...);
}
 
} // namespace zserio
 
#endif // ZSERIO_SERIALIZE_UTIL_H_INC