feat formats: automatic serialization/deserialization based on Boost.PFR

[linuxnyasha]

Example

#include <userver/formats/json.hpp>
#include <iostream>


struct SomeStruct {
  std::optional<int> field;
  std::string field2;
};

template <>
inline constexpr auto userver::formats::universal::kSerialization<SomeStruct> =
  userver::formats::universal::SerializationConfig<SomeStruct>::Create()
  .With<"field">(Default<124>, Min<12>, Max<1221>)
  .With<"field2">(Pattern<"^[0-9]+$">);

int main() {
  userver::formats::json::ValueBuilder builder(SomeStruct{{}, "121"});
  auto json = builder.ExtractValue();
  std::cout << userver::formats::json::ToString(json) << std::endl; // {"field":124,"field2":"121"}
  std::cout << json.As<SomeStruct>().field << std::endl; // 124
};

[Anton3]

Wut

[Anton3]

It seems like operator+ is not really needed for now

[linuxnyasha]

It can be used, for example, to generate constexpr SQL queries via Boost.PFR

[Anton3]

Okay, I'll give it a second thought later

[Anton3]

<array> brings in <algorithm> in typical stdlib implementations, and that's a very heavy header. We try to minimize the usage of <array> in public headers

[Anton3]

double and bool are convertible to int64_t

[Anton3]

[big] After some internal discussion: we want to reduce the amount of template metaprogramming and make SerializationConfig value-based. Details of struct fields serialization and so on will be stored inside SerializationConfig itself, not inside its template parameters.

SerializationConfig should contain a tuple of FieldConfig for each field. FieldConfig should be parametrized with the parsed type. The config creation will look like this:

.With<"field">({.max_items = 10, .items = {.min = 42}})

With takes a single parameter of type FieldConfig<(type of "field")>, which is a struct with all optional members, like std::optional<std::size_t> max_items and FieldConfig<(type of items)> items. This config is assigned to the SerializationConfig's tuple element corresponding to "field".

FieldConfig should be able to be specialized for the parsed type. For example, FieldConfig will be specialized for array-like ranges to include min_items, max_items and items fields, and for numeric types to include min and max fields of appropriate type.

FieldConfig for structs should contain a single reference to the struct's SerializationConfig, which should be default-initialized with formats::universal::kSerialization<T>. The "reference" part is important, as it allows to create recursive structs.

Add a test that contains a simple recursive type:

struct Node {
  int value;
  std::vector<Node> children;
};

Test universal serialization on it.

That's the gist of the vision for value-based serialization config. Feel free to ask questions here or in PM.

[Anton3]

Functions will still be able to use if constexpr and alike by passing around const FieldConfig<T>& in template parameters. Remember that all those SerializationConfig and FieldConfig are stored inside variable templates, so it's possible to use addresses of those variables and their contents in templates, even in C++17

[Anton3]

Continuing in #472