216 lines
8.2 KiB
C++
216 lines
8.2 KiB
C++
#ifndef RFL_PARSING_NAMEDTUPLEPARSER_HPP_
|
|
#define RFL_PARSING_NAMEDTUPLEPARSER_HPP_
|
|
|
|
#include <array>
|
|
#include <map>
|
|
#include <tuple>
|
|
#include <type_traits>
|
|
#include <unordered_map>
|
|
#include <utility>
|
|
|
|
#include "../NamedTuple.hpp"
|
|
#include "../Result.hpp"
|
|
#include "../always_false.hpp"
|
|
#include "../internal/Memoization.hpp"
|
|
#include "../internal/is_array.hpp"
|
|
#include "../internal/is_attribute.hpp"
|
|
#include "../internal/is_basic_type.hpp"
|
|
#include "../internal/is_skip.hpp"
|
|
#include "../internal/strings/replace_all.hpp"
|
|
#include "../to_view.hpp"
|
|
#include "AreReaderAndWriter.hpp"
|
|
#include "Parent.hpp"
|
|
#include "Parser_base.hpp"
|
|
#include "ViewReader.hpp"
|
|
#include "is_empty.hpp"
|
|
#include "is_required.hpp"
|
|
#include "schema/Type.hpp"
|
|
#include "to_single_error_message.hpp"
|
|
|
|
namespace rfl {
|
|
namespace parsing {
|
|
|
|
template <
|
|
class R,
|
|
class W,
|
|
bool _ignore_empty_containers,
|
|
bool _all_required,
|
|
class ProcessorsType,
|
|
class... FieldTypes>
|
|
requires AreReaderAndWriter<R, W, NamedTuple<FieldTypes...>>
|
|
struct NamedTupleParser {
|
|
using InputObjectType = typename R::InputObjectType;
|
|
using InputVarType = typename R::InputVarType;
|
|
|
|
using OutputObjectType = typename W::OutputObjectType;
|
|
using OutputVarType = typename W::OutputVarType;
|
|
|
|
using ParentType = Parent<W>;
|
|
|
|
using NamedTupleType = NamedTuple<FieldTypes...>;
|
|
|
|
static constexpr size_t size_ = NamedTupleType::size();
|
|
|
|
public:
|
|
/// The way this works is that we allocate space on the stack in this size
|
|
/// of the named tuple in which we then write the individual fields using
|
|
/// views and placement new. This is how we deal with the fact that some
|
|
/// fields might not be default-constructible.
|
|
static Result<NamedTuple<FieldTypes...>>
|
|
read(const R& _r, const InputVarType& _var) noexcept {
|
|
alignas(NamedTuple<FieldTypes...>) unsigned char buf[sizeof(NamedTuple<FieldTypes...>)];
|
|
auto ptr = reinterpret_cast<NamedTuple<FieldTypes...>*>(buf);
|
|
auto view = rfl::to_view(*ptr);
|
|
using ViewType = std::remove_cvref_t<decltype(view)>;
|
|
const auto err = Parser<R, W, ViewType, ProcessorsType>::read_view(_r, _var, &view);
|
|
if (err) [[unlikely]] {
|
|
return *err;
|
|
}
|
|
return *ptr;
|
|
}
|
|
|
|
/// Reads the data into a view.
|
|
static std::optional<Error>
|
|
read_view(const R& _r, const InputVarType& _var, NamedTuple<FieldTypes...>* _view) noexcept {
|
|
auto obj = _r.to_object(_var);
|
|
if (!obj) [[unlikely]] {
|
|
return obj.error();
|
|
}
|
|
return read_object(_r, *obj, _view);
|
|
}
|
|
|
|
/// For writing, we do not need to make the distinction between
|
|
/// default-constructible and non-default constructible fields.
|
|
template <class P>
|
|
static void
|
|
write(const W& _w, const NamedTuple<FieldTypes...>& _tup, const P& _parent) noexcept {
|
|
auto obj = ParentType::add_object(_w, _tup.size(), _parent);
|
|
build_object_recursively(_w, _tup, &obj);
|
|
_w.end_object(&obj);
|
|
}
|
|
|
|
/// For generating the schema, we also do not need to make the distinction
|
|
/// between default-constructible and non-default constructible fields.
|
|
template <size_t _i = 0>
|
|
static schema::Type to_schema(
|
|
std::map<std::string, schema::Type>* _definitions,
|
|
std::map<std::string, schema::Type> _values = {}
|
|
) {
|
|
using Type = schema::Type;
|
|
using T = NamedTuple<FieldTypes...>;
|
|
constexpr size_t size = T::size();
|
|
if constexpr (_i == size) {
|
|
return Type { Type::Object { _values } };
|
|
} else {
|
|
using F = std::tuple_element_t<_i, typename NamedTuple<FieldTypes...>::Fields>;
|
|
using U = typename F::Type;
|
|
if constexpr (!internal::is_skip_v<U>) {
|
|
_values[std::string(F::name())] =
|
|
Parser<R, W, U, ProcessorsType>::to_schema(_definitions);
|
|
}
|
|
return to_schema<_i + 1>(_definitions, _values);
|
|
}
|
|
};
|
|
|
|
private:
|
|
template <int _i = 0>
|
|
static void build_object_recursively(
|
|
const W& _w,
|
|
const NamedTuple<FieldTypes...>& _tup,
|
|
OutputObjectType* _ptr
|
|
) noexcept {
|
|
if constexpr (_i >= sizeof...(FieldTypes)) {
|
|
return;
|
|
} else {
|
|
using FieldType = typename std::tuple_element<_i, std::tuple<FieldTypes...>>::type;
|
|
using ValueType = std::remove_cvref_t<typename FieldType::Type>;
|
|
const auto& value = rfl::get<_i>(_tup);
|
|
constexpr auto name = FieldType::name_.string_view();
|
|
const auto new_parent = typename ParentType::Object { name, _ptr };
|
|
if constexpr (!_all_required && !is_required<ValueType, _ignore_empty_containers>()) {
|
|
if (!is_empty(value)) {
|
|
if constexpr (internal::is_attribute_v<ValueType>) {
|
|
Parser<R, W, ValueType, ProcessorsType>::write(
|
|
_w, value, new_parent.as_attribute()
|
|
);
|
|
} else {
|
|
Parser<R, W, ValueType, ProcessorsType>::write(_w, value, new_parent);
|
|
}
|
|
}
|
|
} else {
|
|
if constexpr (internal::is_attribute_v<ValueType>) {
|
|
Parser<R, W, ValueType, ProcessorsType>::write(_w, value, new_parent.as_attribute());
|
|
} else {
|
|
Parser<R, W, ValueType, ProcessorsType>::write(_w, value, new_parent);
|
|
}
|
|
}
|
|
return build_object_recursively<_i + 1>(_w, _tup, _ptr);
|
|
}
|
|
}
|
|
|
|
/// Generates error messages for when fields are missing.
|
|
template <int _i>
|
|
static void handle_one_missing_field(
|
|
const std::array<bool, size_>& _found,
|
|
const NamedTupleType& _view,
|
|
std::array<bool, size_>* _set,
|
|
std::vector<Error>* _errors
|
|
) noexcept {
|
|
using FieldType = std::tuple_element_t<_i, typename NamedTupleType::Fields>;
|
|
using ValueType = std::remove_reference_t<std::remove_pointer_t<typename FieldType::Type>>;
|
|
|
|
if (!std::get<_i>(_found)) {
|
|
if constexpr (_all_required || is_required<ValueType, _ignore_empty_containers>()) {
|
|
constexpr auto current_name =
|
|
std::tuple_element_t<_i, typename NamedTupleType::Fields>::name();
|
|
_errors->emplace_back(
|
|
Error("Field named '" + std::string(current_name) + "' not found.")
|
|
);
|
|
} else {
|
|
if constexpr (!std::is_const_v<ValueType>) {
|
|
::new (rfl::get<_i>(_view)) ValueType();
|
|
} else {
|
|
using NonConstT = std::remove_const_t<ValueType>;
|
|
::new (const_cast<NonConstT*>(rfl::get<_i>(_view))) NonConstT();
|
|
}
|
|
std::get<_i>(*_set) = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Generates error messages for when fields are missing.
|
|
template <int... _is>
|
|
static void
|
|
handle_missing_fields(const std::array<bool, size_>& _found, const NamedTupleType& _view, std::array<bool, size_>* _set, std::vector<Error>* _errors, std::integer_sequence<int, _is...>) noexcept {
|
|
(handle_one_missing_field<_is>(_found, _view, _set, _errors), ...);
|
|
}
|
|
|
|
static std::optional<Error>
|
|
read_object(const R& _r, const InputObjectType& _obj, NamedTupleType* _view) noexcept {
|
|
auto found = std::array<bool, NamedTupleType::size()>();
|
|
found.fill(false);
|
|
auto set = std::array<bool, NamedTupleType::size()>();
|
|
set.fill(false);
|
|
std::vector<Error> errors;
|
|
const auto object_reader =
|
|
ViewReader<R, W, NamedTupleType, ProcessorsType>(&_r, _view, &found, &set, &errors);
|
|
const auto err = _r.read_object(object_reader, _obj);
|
|
if (err) {
|
|
return *err;
|
|
}
|
|
handle_missing_fields(
|
|
found, *_view, &set, &errors, std::make_integer_sequence<int, size_>()
|
|
);
|
|
if (errors.size() != 0) {
|
|
object_reader.call_destructors_where_necessary();
|
|
return to_single_error_message(errors);
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
};
|
|
|
|
} // namespace parsing
|
|
} // namespace rfl
|
|
|
|
#endif
|