aggregates.hpp

Go to the documentation of this file.

#pragma once
 
/// @file userver/dump/aggregates.hpp
/// @brief Dumping support for aggregates
///
/// @ingroup userver_dump_read_write
 
#include <type_traits>
 
#include <boost/pfr/core.hpp>
#include <boost/pfr/tuple_size.hpp>
 
#include <userver/dump/operations.hpp>
 
USERVER_NAMESPACE_BEGIN
 
namespace dump {
 
template <typename T>
struct IsDumpedAggregate {};
 
namespace impl {
 
// Only the non-specialized IsDumpedAggregate struct is defined,
// the specializations are declared without a definition
template <typename T>
using IsNotDumpedAggregate = decltype(sizeof(IsDumpedAggregate<T>));
 
template <typename T, std::size_t... Indices>
constexpr bool AreAllDumpable(std::index_sequence<Indices...>) {
  return (kIsDumpable<boost::pfr::tuple_element_t<Indices, T>> && ...);
}
 
template <typename T>
constexpr bool IsDumpableAggregate() {
  if constexpr (std::is_aggregate_v<T> &&
                !meta::kIsDetected<IsNotDumpedAggregate, T>) {
    constexpr auto kSize = boost::pfr::tuple_size_v<T>;
    static_assert(
        AreAllDumpable<T>(std::make_index_sequence<kSize>{}),
        "One of the member of an aggregate that was marked as dumpable "
        "with dump::IsDumpedAggregate is not dumpable. Did you forget "
        "to include <userver/dump/common.hpp>, "
        "<userver/dump/common_containers.hpp> or some other header with "
        "Read and Write functions declarations?");
    return true;
  } else {
    return false;
  }
}
 
template <typename T, std::size_t... Indices>
T ReadAggregate(Reader& reader, std::index_sequence<Indices...>) {
  // `Read`s are guaranteed to occur left-to-right in brace-init
  return T{reader.Read<boost::pfr::tuple_element_t<Indices, T>>()...};
}
 
}  // namespace impl
 
/// @brief Aggregates dumping support
///
/// To enable dumps and loads for an aggregate, add in the global namespace:
///
/// @code
/// template <>
/// struct dump::IsDumpedAggregate<MyStruct>;
/// @endcode
///
/// @warning Don't forget to increment format-version if data layout changes
template <typename T>
std::enable_if_t<impl::IsDumpableAggregate<T>()> Write(Writer& writer,
                                                       const T& value) {
  boost::pfr::for_each_field(
      value, [&writer](const auto& field) { writer.Write(field); });
}
 
/// @brief Aggregates deserialization from dump support
///
/// To enable dumps and loads for an aggregate, add in the global namespace:
///
/// @code
/// template <>
/// struct dump::IsDumpedAggregate<MyStruct>;
/// @endcode
///
/// @warning Don't forget to increment format-version if data layout changes
template <typename T>
std::enable_if_t<impl::IsDumpableAggregate<T>(), T> Read(Reader& reader,
                                                         To<T>) {
  constexpr auto kSize = boost::pfr::tuple_size_v<T>;
  return impl::ReadAggregate<T>(reader, std::make_index_sequence<kSize>{});
}
 
}  // namespace dump
 
USERVER_NAMESPACE_END