common_containers.hpp

Go to the documentation of this file.

#pragma once
 
/// @file userver/formats/serialize/common_containers.hpp
/// @brief Serializers for standard containers and optional
/// @ingroup userver_universal userver_formats_serialize
 
#include <optional>
#include <type_traits>
 
#include <userver/formats/common/type.hpp>
#include <userver/formats/serialize/to.hpp>
#include <userver/utils/meta.hpp>
 
namespace boost::uuids {
struct uuid;
}
 
USERVER_NAMESPACE_BEGIN
 
namespace utils::impl::strong_typedef {
struct StrongTypedefTag;
}
 
/// Common serializers
namespace formats::serialize {
 
/// Common containers serialization (vector/set)
template <typename T, typename Value>
std::enable_if_t<
    meta::kIsRange<T> && !meta::kIsMap<T> && !std::is_same_v<T, boost::uuids::uuid> &&
        !std::is_convertible_v<T&, utils::impl::strong_typedef::StrongTypedefTag&>,
    Value>
Serialize(const T& value, To<Value>) {
    typename Value::Builder builder(formats::common::Type::kArray);
    for (const auto& item : value) {
        // explicit cast for vector<bool> shenanigans
        builder.PushBack(static_cast<const meta::RangeValueType<T>&>(item));
    }
    return builder.ExtractValue();
}
 
/// Mappings serialization
template <typename T, typename Value>
std::enable_if_t<meta::kIsUniqueMap<T>, Value> Serialize(const T& value, To<Value>) {
    typename Value::Builder builder(formats::common::Type::kObject);
    for (const auto& [key, value] : value) {
        builder[key] = value;
    }
    return builder.ExtractValue();
}
 
/// std::optional serialization
template <typename T, typename Value>
Value Serialize(const std::optional<T>& value, To<Value>) {
    if (!value) return {};
 
    return typename Value::Builder(*value).ExtractValue();
}
 
}  // namespace formats::serialize
 
USERVER_NAMESPACE_END