226 lines
8.7 KiB
C++
226 lines
8.7 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
|