@@ -63,41 +63,34 @@ class KeyValueParser : public TokenParser {
63
63
64
64
void onMember (InternalNameType member);
65
65
66
- template <typename ... ParserTDs>
67
- struct NthTypes {
68
- using Tuple = std::tuple<ParserTDs...>;
69
- static constexpr auto Size = sizeof ...(ParserTDs);
66
+ using ParserTupleType = std::tuple<ParserTs...>;
70
67
71
- template <std::size_t N >
72
- using Nth = typename std::tuple_element<N, Tuple >::type;
68
+ template <std::size_t n >
69
+ using Nth = typename std::tuple_element<n, ParserTupleType >::type;
73
70
74
- template <std::size_t N >
75
- using ParserType = std::decay_t <Nth<N >>;
71
+ template <std::size_t n >
72
+ using ParserType = std::decay_t <Nth<n >>;
76
73
77
- template <std::size_t N , typename U = ParserType<N >>
78
- using ValueType = typename U::ValueType;
74
+ template <std::size_t n , typename U = ParserType<n >>
75
+ using ValueType = typename U::ValueType;
79
76
80
- template <std::size_t N>
81
- static constexpr bool has_value_type = IsStorageParser<ParserType<N>>;
82
- };
77
+ template <std::size_t n>
78
+ static constexpr bool has_value_type = IsStorageParser<ParserType<n>>;
83
79
84
- template < size_t n>
85
- using ParserType = typename NthTypes<ParserTs...>:: template ParserType<n >;
80
+ using ParsersArrayType = std::array<TokenParser *, sizeof ...(ParserTs)>;
81
+ using ParsersMapType = std::unordered_map<InternalNameType, TokenParser * >;
86
82
87
- // Returns NthTypes<ParserTs...>::template ValueType<n> if it is
88
- // available, otherwise NthTypes<ParserTs...>:: template ParserType< n>
89
- template < size_t n> [[nodiscard]] auto &get ();
83
+ // Returns ValueType<n> if it is available, otherwise ParserType<n>
84
+ template < size_t n>
85
+ [[nodiscard]] auto &get ();
90
86
91
87
template <size_t n>
92
- [[nodiscard]] typename NthTypes<ParserTs...>:: template ParserType<n> &parser ();
88
+ [[nodiscard]] ParserType<n> &parser ();
93
89
94
90
template <size_t n>
95
- typename NthTypes<ParserTs...>:: template ValueType<n> pop ();
91
+ ValueType<n> pop ();
96
92
97
93
protected:
98
- using parsers_array_t = std::array<TokenParser *, sizeof ...(ParserTs)>;
99
- using parsers_map_t = std::unordered_map<InternalNameType, TokenParser *>;
100
-
101
94
template <typename ParserT>
102
95
struct MemberParser {
103
96
MemberParser () = delete ;
@@ -125,8 +118,8 @@ class KeyValueParser : public TokenParser {
125
118
MemberParsers (MemberParsers&& other) noexcept = default ;
126
119
MemberParsers& operator =(MemberParsers&& other) noexcept = default ;
127
120
128
- MemberParsers (parsers_array_t & parsers_array,
129
- parsers_map_t & parsers_map,
121
+ MemberParsers (ParsersArrayType & parsers_array,
122
+ ParsersMapType & parsers_map,
130
123
std::tuple<Member<NameT, ParserTs>...>& members)
131
124
: mbr_parsers(to_member_parser_tuple(members)) {
132
125
registerParsers (parsers_array, parsers_map);
@@ -137,13 +130,13 @@ class KeyValueParser : public TokenParser {
137
130
return std::get<n>(mbr_parsers);
138
131
}
139
132
140
- void registerParsers (parsers_array_t & parsers_array, parsers_map_t & parsers_map);
133
+ void registerParsers (ParsersArrayType & parsers_array, ParsersMapType & parsers_map);
141
134
142
135
private:
143
136
template <typename ParserT>
144
137
void registerParser (ParserT& parser, NameT& name, int i,
145
- parsers_array_t & parsers_array,
146
- parsers_map_t & parsers_map);
138
+ ParsersArrayType & parsers_array,
139
+ ParsersMapType & parsers_map);
147
140
148
141
void check_duplicate (bool inserted, NameT& name);
149
142
@@ -164,8 +157,8 @@ class KeyValueParser : public TokenParser {
164
157
[[nodiscard]] auto &memberParsers ();
165
158
166
159
private:
167
- parsers_array_t _parsers_array;
168
- parsers_map_t _parsers_map;
160
+ ParsersArrayType _parsers_array;
161
+ ParsersMapType _parsers_map;
169
162
MemberParsers _member_parsers;
170
163
Ignore _ignore_parser;
171
164
ObjectOptions _options;
@@ -258,7 +251,7 @@ template <size_t n>
258
251
auto &KeyValueParser<NameT, ParserTs...>::get() {
259
252
auto &member = _member_parsers.template get <n>();
260
253
261
- if constexpr (NthTypes<ParserTs...>:: template has_value_type<n>) {
254
+ if constexpr (has_value_type<n>) {
262
255
if (!member.parser .isSet () && member.default_value .value ) {
263
256
return static_cast <const typename decltype (
264
257
member.default_value .value )::value_type &>(
@@ -273,14 +266,14 @@ auto &KeyValueParser<NameT, ParserTs...>::get() {
273
266
274
267
template <typename NameT, typename ... ParserTs>
275
268
template <size_t n>
276
- typename KeyValueParser<NameT, ParserTs...>::template NthTypes<ParserTs...>:: template ParserType<n> &
269
+ typename KeyValueParser<NameT, ParserTs...>::template ParserType<n> &
277
270
KeyValueParser<NameT, ParserTs...>::parser() {
278
271
return _member_parsers.template get <n>().parser ;
279
272
}
280
273
281
274
template <typename NameT, typename ... ParserTs>
282
275
template <size_t n>
283
- typename KeyValueParser<NameT, ParserTs...>::template NthTypes<ParserTs...>:: template ValueType<n>
276
+ typename KeyValueParser<NameT, ParserTs...>::template ValueType<n>
284
277
KeyValueParser<NameT, ParserTs...>::pop() {
285
278
auto &member = _member_parsers.template get <n>();
286
279
@@ -312,8 +305,8 @@ auto &KeyValueParser<NameT, ParserTs...>::memberParsers() {
312
305
313
306
template <typename NameT, typename ... ParserTs>
314
307
void KeyValueParser<NameT, ParserTs...>::MemberParsers::registerParsers(
315
- parsers_array_t &parsers_array,
316
- parsers_map_t &parsers_map) {
308
+ ParsersArrayType &parsers_array,
309
+ ParsersMapType &parsers_map) {
317
310
318
311
parsers_map.clear ();
319
312
@@ -330,12 +323,12 @@ template <typename NameT, typename... ParserTs>
330
323
template <typename ParserT>
331
324
void KeyValueParser< NameT, ParserTs... >::MemberParsers::registerParser(
332
325
ParserT &parser, NameT &name, int i,
333
- parsers_array_t &parsers_array,
334
- parsers_map_t &parsers_map) {
326
+ ParsersArrayType &parsers_array,
327
+ ParsersMapType &parsers_map) {
335
328
336
329
parsers_array[i] = &parser;
337
330
338
- auto [_, inserted] = parsers_map.insert ( { name, &parser });
331
+ auto [_, inserted] = parsers_map.insert ({ name, &parser });
339
332
std::ignore = _;
340
333
341
334
check_duplicate (inserted, name);
0 commit comments