SerializeUtil.h

Go to the documentation of this file.

 
#ifndef ZSERIO_SERIALIZE_UTIL_H_INC
#define ZSERIO_SERIALIZE_UTIL_H_INC
 
#include <string_view>
#include <type_traits>
#include <utility>
 
#include "zserio/BitBuffer.h"
#include "zserio/BitSize.h"
#include "zserio/BitStreamReader.h"
#include "zserio/BitStreamWriter.h"
#include "zserio/DataView.h"
#include "zserio/FileUtil.h"
#include "zserio/Traits.h"
#include "zserio/View.h"
 
namespace zserio
{
 
template <typename T, typename ALLOC, typename... ARGS, std::enable_if_t<is_allocator_v<ALLOC>, int> = 0>
BasicBitBuffer<ALLOC> serialize(const T& data, const ALLOC& allocator, ARGS&&... arguments)
{
    const View<T> view(data, std::forward<ARGS>(arguments)...);
 
    return serialize(view, allocator);
}
 
template <typename T, typename ALLOC, typename... ARGS, std::enable_if_t<is_allocator_v<ALLOC>, int> = 0>
Vector<uint8_t, ALLOC> serializeToBytes(const T& data, const ALLOC& allocator, ARGS&&... arguments)
{
    const View<T> view(data, std::forward<ARGS>(arguments)...);
 
    return serializeToBytes(view, allocator);
}
 
template <typename T, typename... ARGS,
        typename std::enable_if_t<!is_first_allocator_v<ARGS...> && !is_first_array_preallocation_v<ARGS...>,
                int> = 0>
BasicBitBuffer<typename T::allocator_type> serialize(const T& data, ARGS&&... arguments)
{
    return serialize(data, typename T::allocator_type(), std::forward<ARGS>(arguments)...);
}
 
template <typename T, typename... ARGS,
        typename std::enable_if_t<!is_first_allocator_v<ARGS...> && !is_first_array_preallocation_v<ARGS...>,
                int> = 0>
Vector<uint8_t, typename T::allocator_type> serializeToBytes(const T& data, ARGS&&... arguments)
{
    return serializeToBytes(data, typename T::allocator_type(), std::forward<ARGS>(arguments)...);
}
 
template <typename T, typename ALLOC, typename... ARGS>
View<T> deserialize(
        const BasicBitBuffer<ALLOC>& buffer, ArrayPreallocation maxArrayPrealloc, T& data, ARGS&&... arguments)
{
    BitStreamReader reader(buffer, maxArrayPrealloc);
 
    return detail::read(reader, data, std::forward<ARGS>(arguments)...);
}
 
template <typename T, typename ALLOC, typename... ARGS>
View<T> deserialize(const BasicBitBuffer<ALLOC>& buffer, T& data, ARGS&&... arguments)
{
    return deserialize<T>(buffer, ArrayPreallocation(), data, std::forward<ARGS>(arguments)...);
}
 
template <typename T, typename... ARGS>
View<T> deserializeFromBytes(
        Span<const uint8_t> buffer, ArrayPreallocation maxArrayPrealloc, T& data, ARGS&&... arguments)
{
    BitStreamReader reader(buffer, maxArrayPrealloc);
 
    return detail::read(reader, data, std::forward<ARGS>(arguments)...);
}
 
template <typename T, typename... ARGS>
View<T> deserializeFromBytes(Span<const uint8_t> buffer, T& data, ARGS&&... arguments)
{
    return deserializeFromBytes(buffer, ArrayPreallocation(), data, std::forward<ARGS>(arguments)...);
}
 
template <typename T, typename ALLOC>
BasicBitBuffer<ALLOC> serialize(const View<T>& view, const ALLOC& allocator)
{
    detail::validate(view, "");
    const BitSize bitSize = detail::initializeOffsets(view, 0);
    BasicBitBuffer<ALLOC> buffer(bitSize, allocator);
    BitStreamWriter writer(buffer);
    detail::write(writer, view);
 
    return buffer;
}
 
template <typename T, typename ALLOC>
Vector<uint8_t, ALLOC> serializeToBytes(const View<T>& view, const ALLOC& allocator)
{
    detail::validate(view, "");
    const BitSize bitSize = detail::initializeOffsets(view, 0);
    Vector<uint8_t, ALLOC> buffer((bitSize + 7) / 8, allocator);
    BitStreamWriter writer(buffer);
    detail::write(writer, view);
 
    return buffer;
}
 
template <typename T>
BasicBitBuffer<typename T::allocator_type> serialize(const View<T>& view)
{
    return serialize(view, typename T::allocator_type());
}
 
template <typename T>
Vector<uint8_t, typename T::allocator_type> serializeToBytes(const View<T>& view)
{
    return serializeToBytes(view, typename T::allocator_type());
}
 
template <typename T, typename ALLOC>
BasicBitBuffer<ALLOC> serialize(const DataView<T>& dataView, const ALLOC& allocator)
{
    // there is no need to set offsets or call validation here, DataView is already consistent
    size_t bitSize = detail::bitSizeOf(dataView, 0);
    BasicBitBuffer<ALLOC> buffer(bitSize, allocator);
    BitStreamWriter writer(buffer);
 
    detail::write(writer, dataView);
    return buffer;
}
 
template <typename T, typename ALLOC>
Vector<uint8_t, ALLOC> serializeToBytes(const DataView<T>& dataView, const ALLOC& allocator)
{
    // there is no need to set offsets or call validation here, DataView is already consistent
    size_t bitSize = detail::bitSizeOf(dataView, 0);
    Vector<uint8_t, ALLOC> buffer((bitSize + 7) / 8, allocator);
    BitStreamWriter writer(buffer);
 
    detail::write(writer, dataView);
    return buffer;
}
 
template <typename T>
BasicBitBuffer<typename T::allocator_type> serialize(const DataView<T>& dataView)
{
    return serialize(dataView, typename T::allocator_type());
}
 
template <typename T>
Vector<uint8_t, typename T::allocator_type> serializeToBytes(const DataView<T>& dataView)
{
    return serializeToBytes(dataView, typename T::allocator_type());
}
 
template <typename T, typename ALLOC, typename... ARGS>
DataView<T> deserialize(const BasicBitBuffer<ALLOC>& buffer, ArrayPreallocation maxArrayPreallocation,
        const typename T::allocator_type& allocator, ARGS&&... arguments)
{
    BitStreamReader reader(buffer, maxArrayPreallocation);
    T data{allocator};
 
    return DataView<T>(reader, std::move(data), std::forward<ARGS>(arguments)...);
}
 
template <typename T, typename ALLOC, typename... ARGS>
DataView<T> deserialize(
        const BasicBitBuffer<ALLOC>& buffer, const typename T::allocator_type& allocator, ARGS&&... arguments)
{
    return deserialize<T>(buffer, ArrayPreallocation(), allocator, std::forward<ARGS>(arguments)...);
}
 
template <typename T, typename... ARGS>
DataView<T> deserializeFromBytes(Span<const uint8_t> buffer, ArrayPreallocation maxArrayPreallocation,
        const typename T::allocator_type& allocator, ARGS&&... arguments)
{
    BitStreamReader reader(buffer, maxArrayPreallocation);
    T data{allocator};
 
    return DataView<T>(reader, std::move(data), std::forward<ARGS>(arguments)...);
}
 
template <typename T, typename... ARGS>
DataView<T> deserializeFromBytes(
        Span<const uint8_t> buffer, const typename T::allocator_type& allocator, ARGS&&... arguments)
{
    return deserializeFromBytes<T>(buffer, ArrayPreallocation(), allocator, std::forward<ARGS>(arguments)...);
}
 
template <typename T, typename ALLOC, typename... ARGS,
        std::enable_if_t<!is_first_allocator_v<ARGS...>, int> = 0>
DataView<T> deserialize(
        const BasicBitBuffer<ALLOC>& buffer, ArrayPreallocation maxArrayAlloc, ARGS&&... arguments)
{
    return deserialize<T>(
            buffer, maxArrayAlloc, typename T::allocator_type(), std::forward<ARGS>(arguments)...);
}
 
template <typename T, typename ALLOC, typename... ARGS,
        std::enable_if_t<!is_first_allocator_v<ARGS...> && !is_first_array_preallocation_v<ARGS...>, int> = 0>
DataView<T> deserialize(const BasicBitBuffer<ALLOC>& buffer, ARGS&&... arguments)
{
    return deserialize<T>(buffer, ArrayPreallocation(), std::forward<ARGS>(arguments)...);
}
 
template <typename T, typename... ARGS, std::enable_if_t<!is_first_allocator_v<ARGS...>, int> = 0>
DataView<T> deserializeFromBytes(
        Span<const uint8_t> buffer, ArrayPreallocation maxArrayPrealloc, ARGS&&... arguments)
{
    return deserializeFromBytes<T>(
            buffer, maxArrayPrealloc, typename T::allocator_type(), std::forward<ARGS>(arguments)...);
}
 
template <typename T, typename... ARGS,
        std::enable_if_t<!is_first_allocator_v<ARGS...> && !is_first_array_preallocation_v<ARGS...>, int> = 0>
DataView<T> deserializeFromBytes(Span<const uint8_t> buffer, ARGS&&... arguments)
{
    return deserializeFromBytes<T>(buffer, ArrayPreallocation(), std::forward<ARGS>(arguments)...);
}
 
template <typename T>
void serializeToFile(const View<T>& view, std::string_view fileName)
{
    const auto bitBuffer = serialize(view);
    writeBufferToFile(bitBuffer, fileName);
}
 
template <typename T>
void serializeToFile(const DataView<T>& dataView, std::string_view fileName)
{
    const auto bitBuffer = serialize(dataView);
    writeBufferToFile(bitBuffer, fileName);
}
 
template <typename T, typename... ARGS>
void serializeToFile(const T& data, std::string_view fileName, ARGS&&... arguments)
{
    const View<T> view(data, std::forward<ARGS>(arguments)...);
    serializeToFile(view, fileName);
}
 
template <typename T, typename... ARGS>
View<T> deserializeFromFile(
        std::string_view fileName, ArrayPreallocation maxArrayPrealloc, T& data, ARGS&&... arguments)
{
    const BitBuffer bitBuffer = readBufferFromFile(fileName);
    return deserialize(bitBuffer, maxArrayPrealloc, data, std::forward<ARGS>(arguments)...);
}
 
template <typename T, typename... ARGS>
View<T> deserializeFromFile(std::string_view fileName, T& data, ARGS&&... arguments)
{
    return deserializeFromFile(fileName, ArrayPreallocation(), data, std::forward<ARGS>(arguments)...);
}
 
template <typename T, typename... ARGS>
DataView<T> deserializeFromFile(
        std::string_view fileName, ArrayPreallocation maxArrayPrealloc, ARGS&&... arguments)
{
    const BitBuffer bitBuffer = readBufferFromFile(fileName);
    return deserialize<T>(bitBuffer, maxArrayPrealloc, std::forward<ARGS>(arguments)...);
}
 
template <typename T, typename... ARGS>
DataView<T> deserializeFromFile(std::string_view fileName, ARGS&&... arguments)
{
    return deserializeFromFile<T>(fileName, ArrayPreallocation(), std::forward<ARGS>(arguments)...);
}
 
} // namespace zserio
 
#endif // ZSERIO_SERIALIZE_UTIL_H_INC