defaults.h

Go to the documentation of this file.

#pragma once
 
#include <parcel/list.h>
#include <parcel/map.h>
#include <parcel/primitive.h>
#include <parcel/union.h>
 
#include <array>
#include <cstddef>
#include <deque>
#include <list>
#include <map>
#include <memory>
#include <optional>
#include <set>
#include <string>
#include <type_traits>
#include <unordered_map>
#include <utility>
#include <variant>
#include <vector>
 
namespace parcel {
 
template <typename T, typename = void>
struct default_cell_for {};
 
template <PrimitiveStorage T>
struct default_cell_for<T> {
    using type = PrimitiveCell<T>;
};
 
template <typename T>
using default_cell_for_t = default_cell_for<T>::type;
 
template <typename T>
concept HasDefaultCellWrapper = requires { typename default_cell_for<T>::type; };
 
template <typename T>
    requires HasDefaultCellWrapper<T>
struct default_cell_for<std::vector<T>> {
    using type = TypedListCell<default_cell_for_t<T>>;
};
 
template <typename T>
    requires HasDefaultCellWrapper<T>
struct default_cell_for<std::map<std::string, T>> {
    using type = TypedMapCell<default_cell_for_t<T>>;
};
 
template <typename T>
    requires HasDefaultCellWrapper<T>
struct default_cell_for<std::unordered_map<std::string, T>> {
    using type = TypedMapCell<default_cell_for_t<T>>;
};
 
template <typename T, std::size_t N>
    requires HasDefaultCellWrapper<T>
struct default_cell_for<std::array<T, N>> {
    using type = TypedListCell<default_cell_for_t<T>>;
};
 
template <typename T>
    requires HasDefaultCellWrapper<T>
struct default_cell_for<std::deque<T>> {
    using type = TypedListCell<default_cell_for_t<T>>;
};
 
template <typename T>
    requires HasDefaultCellWrapper<T>
struct default_cell_for<std::list<T>> {
    using type = TypedListCell<default_cell_for_t<T>>;
};
 
template <typename T>
    requires HasDefaultCellWrapper<T>
struct default_cell_for<std::set<T>> {
    using type = TypedListCell<default_cell_for_t<T>>;
};
 
template <typename... Ts>
    requires(HasDefaultCellWrapper<Ts> && ...)
struct default_cell_for<std::variant<Ts...>> {
    using type = UnionCell<default_cell_for_t<Ts>...>;
};
 
template <typename T>
    requires HasDefaultCellWrapper<T>
struct default_cell_for<std::optional<T>> {
    using type = default_cell_for_t<T>;
};
 
namespace detail {
// Normalize raw call-site types into the canonical storage type that
// default_cell_for is keyed on. Without this, string literals (`const char[N]`)
// and `const char*` would not resolve to StringCell.
template <typename T>
struct cell_arg {
    using type = T;
};
template <std::size_t N>
struct cell_arg<char[N]> {  // NOLINT(modernize-avoid-c-arrays) — must match decay-from string
                            // literal
    using type = std::string;
};
template <std::size_t N>
struct cell_arg<const char[N]> {  // NOLINT(modernize-avoid-c-arrays) — must match decay-from string
                                  // literal
    using type = std::string;
};
template <>
struct cell_arg<char*> {
    using type = std::string;
};
template <>
struct cell_arg<const char*> {
    using type = std::string;
};
 
template <typename T>
using cell_arg_t = typename cell_arg<std::remove_cvref_t<T>>::type;
}  // namespace detail
 
template <typename T>
    requires HasDefaultCellWrapper<detail::cell_arg_t<T>>
auto cell(T&& v) {
    using Cell = default_cell_for_t<detail::cell_arg_t<T>>;
    return Cell::of(std::forward<T>(v));
}
 
template <typename... Ts>
    requires(HasDefaultCellWrapper<detail::cell_arg_t<Ts>> && ...)
[[nodiscard]] std::shared_ptr<ListCell> make_list(Ts&&... xs) {
    std::vector<cell_t> elems;
    elems.reserve(sizeof...(Ts));
    (elems.push_back(cell(std::forward<Ts>(xs))), ...);
    return ListCell::of(std::move(elems));
}
 
[[nodiscard]] inline std::shared_ptr<MapCell>
make_map(const std::initializer_list<std::pair<const std::string, cell_t>> entries) {
    std::map<std::string, cell_t> data(entries.begin(), entries.end());
    return MapCell::of(std::move(data));
}
 
}  // namespace parcel
 
#define PARCEL_DEFAULT_CELL(CellT)                                                                 \
    template <>                                                                                    \
    struct parcel::default_cell_for<typename CellT::storage_t> {                                   \
        using type = CellT;                                                                        \
    }