serialization_traits.h

Go to the documentation of this file.

// === serialization_traits.h ==========================================================================================
//                                               Sen Infrastructure
//                   Released under the Apache License v2.0 (SPDX-License-Identifier Apache-2.0).
//                                    See the LICENSE.txt file for more information.
//                   © Airbus SAS, Airbus Helicopters, and Airbus Defence and Space SAU/GmbH/SAS.
// =====================================================================================================================
 
#ifndef SEN_CORE_IO_DETAIL_SERIALIZATION_TRAITS_H
#define SEN_CORE_IO_DETAIL_SERIALIZATION_TRAITS_H
 
// sen
#include "sen/core/base/timestamp.h"
#include "sen/core/io/detail/endianness.h"
 
// std
#include <limits>
#include <string>
#include <tuple>
#include <type_traits>
#include <vector>
 
namespace sen::impl
{
 
// clang-format off

template <typename T>
[[nodiscard]] constexpr bool isPureIntegral() noexcept
{
    return std::is_same_v<int8_t, T>  || std::is_same_v<uint8_t, T>  ||
           std::is_same_v<int16_t, T> || std::is_same_v<uint16_t, T> ||
           std::is_same_v<int32_t, T> || std::is_same_v<uint32_t, T> ||
           std::is_same_v<int64_t, T> || std::is_same_v<uint64_t, T>;
}
 
// clang-format on

template <typename T>
[[nodiscard]] constexpr bool isNumeric() noexcept
{
  return isPureIntegral<T>() || (std::is_floating_point_v<T> && std::numeric_limits<T>::is_iec559);
}

template <typename T>
[[nodiscard]] constexpr bool isBasic() noexcept
{
  return isNumeric<T>() || std::is_same_v<char, T> || std::is_same_v<unsigned char, T>;
}

template <typename T>
[[nodiscard]] constexpr bool allowsContiguousIO() noexcept
{
  constexpr bool isBasicBuiltinType = isBasic<T>() || std::is_enum_v<T>;
  constexpr bool isTrivialType = std::is_trivially_copyable_v<T> && !std::is_class_v<T>;
  constexpr bool wouldNotRequireSwap = hostIsLittleEndian() || sizeof(T) == 1U;
 
  return !std::is_same_v<T, bool> && (isBasicBuiltinType || isTrivialType) && wouldNotRequireSwap;
}
 
static_assert(!allowsContiguousIO<std::vector<std::string>>());
static_assert(!allowsContiguousIO<std::vector<bool>>());

template <typename T, typename R>
using IfBasic = typename std::enable_if_t<isBasic<T>(), R>;

template <typename T, typename R>
using IfEnum = typename std::enable_if_t<std::is_enum_v<T>, R>;

using BoolTransportType = uint8_t;

template <typename S, typename T>
struct IsStreamable
{
private:
  template <typename SS, typename TT>
  static auto outputTest(unsigned) -> decltype(std::declval<SS&>() << std::declval<TT>(), std::true_type());
 
  template <typename, typename>
  static auto outputTest(...) -> std::false_type;
 
  template <typename SS, typename TT>
  static auto inputTest(unsigned) -> decltype(std::declval<SS&>() >> std::declval<TT&>(), std::true_type());
 
  template <typename, typename>
  static auto inputTest(...) -> std::false_type;
 
public:
  static constexpr bool output = decltype(outputTest<S, T>(0U))::value;
  static constexpr bool input = decltype(inputTest<S, T>(0U))::value;
};
 
[[nodiscard]] constexpr uint32_t getSerializedSize(bool val) noexcept
{
  std::ignore = val;
  return sizeof(BoolTransportType);
}
 
template <typename T>
[[nodiscard]] constexpr IfBasic<T, uint32_t> getSerializedSize(T val) noexcept
{
  std::ignore = val;
  return sizeof(T);
}
 
template <typename T>
[[nodiscard]] constexpr IfEnum<T, uint32_t> getSerializedSize(T val) noexcept
{
  return getSerializedSize(static_cast<std::underlying_type_t<T>>(val));
}
 
[[nodiscard]] inline uint32_t getSerializedSize(const std::string& val) noexcept
{
  const auto size = static_cast<uint32_t>(val.size());
  const auto sizeSize = getSerializedSize(size);
 
  // early exit
  if (size == 0U)
  {
    return sizeSize;
  }
 
  return sizeSize + size;
}
 
[[nodiscard]] constexpr uint32_t getSerializedSize(TimeStamp val) noexcept
{
  std::ignore = val;
  return getSerializedSize(int64_t {0});
}
 
}  // namespace sen::impl
 
#endif  // SEN_CORE_IO_DETAIL_SERIALIZATION_TRAITS_H