1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
|
#ifndef RFL_PARSING_TUPLEREADER_HPP_
#define RFL_PARSING_TUPLEREADER_HPP_
#include <sstream>
#include <string_view>
#include <tuple>
#include <type_traits>
#include <vector>
#include "../Result.hpp"
#include "../Tuple.hpp"
#include "../internal/is_array.hpp"
namespace rfl::parsing {
template <class R, class W, class TupleType, bool _ignore_empty_containers,
bool _all_required, class ProcessorsType>
class TupleReader {
private:
using InputVarType = typename R::InputVarType;
static constexpr size_t size_ = rfl::tuple_size_v<TupleType>;
public:
TupleReader(const R* _r, TupleType* _tuple)
: num_set_(0), r_(_r), tuple_(_tuple) {}
~TupleReader() = default;
std::optional<Error> handle_missing_fields() const {
std::optional<Error> err;
if (num_set_ < size_) {
handle_missing_fields_impl(&err);
}
return err;
}
size_t num_set() const { return num_set_; }
std::optional<Error> read(const InputVarType& _var) const {
std::optional<Error> err;
read_impl(_var, &err);
return err;
}
private:
template <int _i = 0>
void handle_missing_fields_impl(std::optional<Error>* _err) const noexcept {
if constexpr (_i < size_) {
if (num_set_ == _i) {
using CurrentType =
std::remove_cvref_t<rfl::tuple_element_t<_i, TupleType>>;
if constexpr (_all_required ||
is_required<CurrentType, _ignore_empty_containers>()) {
*_err = Error("Field " + std::to_string(_i) +
" was required, but missing.");
return;
} else {
::new (&(rfl::get<_i>(*tuple_))) CurrentType();
++num_set_;
}
}
handle_missing_fields_impl<_i + 1>(_err);
}
}
template <size_t _i = 0>
void read_impl(const InputVarType& _var, std::optional<Error>* _err) const {
if constexpr (_i < size_) {
if (num_set_ == _i) {
using CurrentType =
std::remove_cvref_t<rfl::tuple_element_t<_i, TupleType>>;
auto res = Parser<R, W, CurrentType, ProcessorsType>::read(*r_, _var);
if (res) {
move_to(&(rfl::get<_i>(*tuple_)), &(*res));
++num_set_;
} else {
std::stringstream stream;
stream << "Failed to parse field " << _i << ": "
<< res.error().what();
*_err = Error(stream.str());
}
return;
}
read_impl<_i + 1>(_var, _err);
} else {
std::stringstream stream;
stream << "Expected " << size_ << " fields, but got at least one more.";
*_err = Error(stream.str());
return;
}
}
template <class Target, class Source>
void move_to(Target* _t, Source* _s) const {
if constexpr (std::is_const_v<Target>) {
return move_to(const_cast<std::remove_const_t<Target>*>(_t), _s);
} else if constexpr (!internal::is_array_v<Source> &&
!std::is_array_v<Target>) {
::new (_t) Target(std::move(*_s));
} else if constexpr (internal::is_array_v<Source>) {
for (size_t i = 0; i < _s->arr_.size(); ++i) {
move_to(&((*_t)[i]), &(_s->arr_[i]));
}
} else {
for (size_t i = 0; i < _s->size(); ++i) {
move_to(&((*_t)[i]), &((*_s)[i]));
}
}
}
private:
/// Indicates the last field that was set.
mutable size_t num_set_;
/// The underlying reader.
const R* r_;
/// The underlying tuple.
TupleType* tuple_;
};
} // namespace rfl::parsing
#endif
|
