1 #pragma once
2
3 #include <algorithm> // transform
4 #include <array> // array
5 #include <forward_list> // forward_list
6 #include <iterator> // inserter, front_inserter, end
7 #include <map> // map
8 #include <string> // string
9 #include <tuple> // tuple, make_tuple
10 #include <type_traits> // is_arithmetic, is_same, is_enum, underlying_type, is_convertible
11 #include <unordered_map> // unordered_map
12 #include <utility> // pair, declval
13 #include <valarray> // valarray
14
15 #include <nlohmann/detail/exceptions.hpp>
16 #include <nlohmann/detail/macro_scope.hpp>
17 #include <nlohmann/detail/meta/cpp_future.hpp>
18 #include <nlohmann/detail/meta/identity_tag.hpp>
19 #include <nlohmann/detail/meta/type_traits.hpp>
20 #include <nlohmann/detail/value_t.hpp>
21
22 #ifdef JSON_HAS_CPP_17
23 #include <filesystem>
24 #endif
25
26 namespace nlohmann
27 {
28 namespace detail
29 {
30 template<typename BasicJsonType>
from_json(const BasicJsonType & j,typename std::nullptr_t & n)31 void from_json(const BasicJsonType& j, typename std::nullptr_t& n)
32 {
33 if (JSON_HEDLEY_UNLIKELY(!j.is_null()))
34 {
35 JSON_THROW(type_error::create(302, "type must be null, but is " + std::string(j.type_name()), j));
36 }
37 n = nullptr;
38 }
39
40 // overloads for basic_json template parameters
41 template < typename BasicJsonType, typename ArithmeticType,
42 enable_if_t < std::is_arithmetic<ArithmeticType>::value&&
43 !std::is_same<ArithmeticType, typename BasicJsonType::boolean_t>::value,
44 int > = 0 >
get_arithmetic_value(const BasicJsonType & j,ArithmeticType & val)45 void get_arithmetic_value(const BasicJsonType& j, ArithmeticType& val)
46 {
47 switch (static_cast<value_t>(j))
48 {
49 case value_t::number_unsigned:
50 {
51 val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_unsigned_t*>());
52 break;
53 }
54 case value_t::number_integer:
55 {
56 val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_integer_t*>());
57 break;
58 }
59 case value_t::number_float:
60 {
61 val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_float_t*>());
62 break;
63 }
64
65 case value_t::null:
66 case value_t::object:
67 case value_t::array:
68 case value_t::string:
69 case value_t::boolean:
70 case value_t::binary:
71 case value_t::discarded:
72 default:
73 JSON_THROW(type_error::create(302, "type must be number, but is " + std::string(j.type_name()), j));
74 }
75 }
76
77 template<typename BasicJsonType>
from_json(const BasicJsonType & j,typename BasicJsonType::boolean_t & b)78 void from_json(const BasicJsonType& j, typename BasicJsonType::boolean_t& b)
79 {
80 if (JSON_HEDLEY_UNLIKELY(!j.is_boolean()))
81 {
82 JSON_THROW(type_error::create(302, "type must be boolean, but is " + std::string(j.type_name()), j));
83 }
84 b = *j.template get_ptr<const typename BasicJsonType::boolean_t*>();
85 }
86
87 template<typename BasicJsonType>
from_json(const BasicJsonType & j,typename BasicJsonType::string_t & s)88 void from_json(const BasicJsonType& j, typename BasicJsonType::string_t& s)
89 {
90 if (JSON_HEDLEY_UNLIKELY(!j.is_string()))
91 {
92 JSON_THROW(type_error::create(302, "type must be string, but is " + std::string(j.type_name()), j));
93 }
94 s = *j.template get_ptr<const typename BasicJsonType::string_t*>();
95 }
96
97 template <
98 typename BasicJsonType, typename ConstructibleStringType,
99 enable_if_t <
100 is_constructible_string_type<BasicJsonType, ConstructibleStringType>::value&&
101 !std::is_same<typename BasicJsonType::string_t,
102 ConstructibleStringType>::value,
103 int > = 0 >
from_json(const BasicJsonType & j,ConstructibleStringType & s)104 void from_json(const BasicJsonType& j, ConstructibleStringType& s)
105 {
106 if (JSON_HEDLEY_UNLIKELY(!j.is_string()))
107 {
108 JSON_THROW(type_error::create(302, "type must be string, but is " + std::string(j.type_name()), j));
109 }
110
111 s = *j.template get_ptr<const typename BasicJsonType::string_t*>();
112 }
113
114 template<typename BasicJsonType>
from_json(const BasicJsonType & j,typename BasicJsonType::number_float_t & val)115 void from_json(const BasicJsonType& j, typename BasicJsonType::number_float_t& val)
116 {
117 get_arithmetic_value(j, val);
118 }
119
120 template<typename BasicJsonType>
from_json(const BasicJsonType & j,typename BasicJsonType::number_unsigned_t & val)121 void from_json(const BasicJsonType& j, typename BasicJsonType::number_unsigned_t& val)
122 {
123 get_arithmetic_value(j, val);
124 }
125
126 template<typename BasicJsonType>
from_json(const BasicJsonType & j,typename BasicJsonType::number_integer_t & val)127 void from_json(const BasicJsonType& j, typename BasicJsonType::number_integer_t& val)
128 {
129 get_arithmetic_value(j, val);
130 }
131
132 template<typename BasicJsonType, typename EnumType,
133 enable_if_t<std::is_enum<EnumType>::value, int> = 0>
from_json(const BasicJsonType & j,EnumType & e)134 void from_json(const BasicJsonType& j, EnumType& e)
135 {
136 typename std::underlying_type<EnumType>::type val;
137 get_arithmetic_value(j, val);
138 e = static_cast<EnumType>(val);
139 }
140
141 // forward_list doesn't have an insert method
142 template<typename BasicJsonType, typename T, typename Allocator,
143 enable_if_t<is_getable<BasicJsonType, T>::value, int> = 0>
from_json(const BasicJsonType & j,std::forward_list<T,Allocator> & l)144 void from_json(const BasicJsonType& j, std::forward_list<T, Allocator>& l)
145 {
146 if (JSON_HEDLEY_UNLIKELY(!j.is_array()))
147 {
148 JSON_THROW(type_error::create(302, "type must be array, but is " + std::string(j.type_name()), j));
149 }
150 l.clear();
151 std::transform(j.rbegin(), j.rend(),
152 std::front_inserter(l), [](const BasicJsonType & i)
153 {
154 return i.template get<T>();
155 });
156 }
157
158 // valarray doesn't have an insert method
159 template<typename BasicJsonType, typename T,
160 enable_if_t<is_getable<BasicJsonType, T>::value, int> = 0>
from_json(const BasicJsonType & j,std::valarray<T> & l)161 void from_json(const BasicJsonType& j, std::valarray<T>& l)
162 {
163 if (JSON_HEDLEY_UNLIKELY(!j.is_array()))
164 {
165 JSON_THROW(type_error::create(302, "type must be array, but is " + std::string(j.type_name()), j));
166 }
167 l.resize(j.size());
168 std::transform(j.begin(), j.end(), std::begin(l),
169 [](const BasicJsonType & elem)
170 {
171 return elem.template get<T>();
172 });
173 }
174
175 template<typename BasicJsonType, typename T, std::size_t N>
from_json(const BasicJsonType & j,T (& arr)[N])176 auto from_json(const BasicJsonType& j, T (&arr)[N]) // NOLINT(cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays)
177 -> decltype(j.template get<T>(), void())
178 {
179 for (std::size_t i = 0; i < N; ++i)
180 {
181 arr[i] = j.at(i).template get<T>();
182 }
183 }
184
185 template<typename BasicJsonType>
from_json_array_impl(const BasicJsonType & j,typename BasicJsonType::array_t & arr,priority_tag<3>)186 void from_json_array_impl(const BasicJsonType& j, typename BasicJsonType::array_t& arr, priority_tag<3> /*unused*/)
187 {
188 arr = *j.template get_ptr<const typename BasicJsonType::array_t*>();
189 }
190
191 template<typename BasicJsonType, typename T, std::size_t N>
from_json_array_impl(const BasicJsonType & j,std::array<T,N> & arr,priority_tag<2>)192 auto from_json_array_impl(const BasicJsonType& j, std::array<T, N>& arr,
193 priority_tag<2> /*unused*/)
194 -> decltype(j.template get<T>(), void())
195 {
196 for (std::size_t i = 0; i < N; ++i)
197 {
198 arr[i] = j.at(i).template get<T>();
199 }
200 }
201
202 template<typename BasicJsonType, typename ConstructibleArrayType,
203 enable_if_t<
204 std::is_assignable<ConstructibleArrayType&, ConstructibleArrayType>::value,
205 int> = 0>
from_json_array_impl(const BasicJsonType & j,ConstructibleArrayType & arr,priority_tag<1>)206 auto from_json_array_impl(const BasicJsonType& j, ConstructibleArrayType& arr, priority_tag<1> /*unused*/)
207 -> decltype(
208 arr.reserve(std::declval<typename ConstructibleArrayType::size_type>()),
209 j.template get<typename ConstructibleArrayType::value_type>(),
210 void())
211 {
212 using std::end;
213
214 ConstructibleArrayType ret;
215 ret.reserve(j.size());
216 std::transform(j.begin(), j.end(),
217 std::inserter(ret, end(ret)), [](const BasicJsonType & i)
218 {
219 // get<BasicJsonType>() returns *this, this won't call a from_json
220 // method when value_type is BasicJsonType
221 return i.template get<typename ConstructibleArrayType::value_type>();
222 });
223 arr = std::move(ret);
224 }
225
226 template<typename BasicJsonType, typename ConstructibleArrayType,
227 enable_if_t<
228 std::is_assignable<ConstructibleArrayType&, ConstructibleArrayType>::value,
229 int> = 0>
from_json_array_impl(const BasicJsonType & j,ConstructibleArrayType & arr,priority_tag<0>)230 void from_json_array_impl(const BasicJsonType& j, ConstructibleArrayType& arr,
231 priority_tag<0> /*unused*/)
232 {
233 using std::end;
234
235 ConstructibleArrayType ret;
236 std::transform(
237 j.begin(), j.end(), std::inserter(ret, end(ret)),
238 [](const BasicJsonType & i)
239 {
240 // get<BasicJsonType>() returns *this, this won't call a from_json
241 // method when value_type is BasicJsonType
242 return i.template get<typename ConstructibleArrayType::value_type>();
243 });
244 arr = std::move(ret);
245 }
246
247 template < typename BasicJsonType, typename ConstructibleArrayType,
248 enable_if_t <
249 is_constructible_array_type<BasicJsonType, ConstructibleArrayType>::value&&
250 !is_constructible_object_type<BasicJsonType, ConstructibleArrayType>::value&&
251 !is_constructible_string_type<BasicJsonType, ConstructibleArrayType>::value&&
252 !std::is_same<ConstructibleArrayType, typename BasicJsonType::binary_t>::value&&
253 !is_basic_json<ConstructibleArrayType>::value,
254 int > = 0 >
from_json(const BasicJsonType & j,ConstructibleArrayType & arr)255 auto from_json(const BasicJsonType& j, ConstructibleArrayType& arr)
256 -> decltype(from_json_array_impl(j, arr, priority_tag<3> {}),
257 j.template get<typename ConstructibleArrayType::value_type>(),
258 void())
259 {
260 if (JSON_HEDLEY_UNLIKELY(!j.is_array()))
261 {
262 JSON_THROW(type_error::create(302, "type must be array, but is " + std::string(j.type_name()), j));
263 }
264
265 from_json_array_impl(j, arr, priority_tag<3> {});
266 }
267
268 template < typename BasicJsonType, typename T, std::size_t... Idx >
from_json_inplace_array_impl(BasicJsonType && j,identity_tag<std::array<T,sizeof...(Idx)>>,index_sequence<Idx...>)269 std::array<T, sizeof...(Idx)> from_json_inplace_array_impl(BasicJsonType&& j,
270 identity_tag<std::array<T, sizeof...(Idx)>> /*unused*/, index_sequence<Idx...> /*unused*/)
271 {
272 return { { std::forward<BasicJsonType>(j).at(Idx).template get<T>()... } };
273 }
274
275 template < typename BasicJsonType, typename T, std::size_t N >
from_json(BasicJsonType && j,identity_tag<std::array<T,N>> tag)276 auto from_json(BasicJsonType&& j, identity_tag<std::array<T, N>> tag)
277 -> decltype(from_json_inplace_array_impl(std::forward<BasicJsonType>(j), tag, make_index_sequence<N> {}))
278 {
279 if (JSON_HEDLEY_UNLIKELY(!j.is_array()))
280 {
281 JSON_THROW(type_error::create(302, "type must be array, but is " + std::string(j.type_name()), j));
282 }
283
284 return from_json_inplace_array_impl(std::forward<BasicJsonType>(j), tag, make_index_sequence<N> {});
285 }
286
287 template<typename BasicJsonType>
from_json(const BasicJsonType & j,typename BasicJsonType::binary_t & bin)288 void from_json(const BasicJsonType& j, typename BasicJsonType::binary_t& bin)
289 {
290 if (JSON_HEDLEY_UNLIKELY(!j.is_binary()))
291 {
292 JSON_THROW(type_error::create(302, "type must be binary, but is " + std::string(j.type_name()), j));
293 }
294
295 bin = *j.template get_ptr<const typename BasicJsonType::binary_t*>();
296 }
297
298 template<typename BasicJsonType, typename ConstructibleObjectType,
299 enable_if_t<is_constructible_object_type<BasicJsonType, ConstructibleObjectType>::value, int> = 0>
from_json(const BasicJsonType & j,ConstructibleObjectType & obj)300 void from_json(const BasicJsonType& j, ConstructibleObjectType& obj)
301 {
302 if (JSON_HEDLEY_UNLIKELY(!j.is_object()))
303 {
304 JSON_THROW(type_error::create(302, "type must be object, but is " + std::string(j.type_name()), j));
305 }
306
307 ConstructibleObjectType ret;
308 const auto* inner_object = j.template get_ptr<const typename BasicJsonType::object_t*>();
309 using value_type = typename ConstructibleObjectType::value_type;
310 std::transform(
311 inner_object->begin(), inner_object->end(),
312 std::inserter(ret, ret.begin()),
313 [](typename BasicJsonType::object_t::value_type const & p)
314 {
315 return value_type(p.first, p.second.template get<typename ConstructibleObjectType::mapped_type>());
316 });
317 obj = std::move(ret);
318 }
319
320 // overload for arithmetic types, not chosen for basic_json template arguments
321 // (BooleanType, etc..); note: Is it really necessary to provide explicit
322 // overloads for boolean_t etc. in case of a custom BooleanType which is not
323 // an arithmetic type?
324 template < typename BasicJsonType, typename ArithmeticType,
325 enable_if_t <
326 std::is_arithmetic<ArithmeticType>::value&&
327 !std::is_same<ArithmeticType, typename BasicJsonType::number_unsigned_t>::value&&
328 !std::is_same<ArithmeticType, typename BasicJsonType::number_integer_t>::value&&
329 !std::is_same<ArithmeticType, typename BasicJsonType::number_float_t>::value&&
330 !std::is_same<ArithmeticType, typename BasicJsonType::boolean_t>::value,
331 int > = 0 >
from_json(const BasicJsonType & j,ArithmeticType & val)332 void from_json(const BasicJsonType& j, ArithmeticType& val)
333 {
334 switch (static_cast<value_t>(j))
335 {
336 case value_t::number_unsigned:
337 {
338 val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_unsigned_t*>());
339 break;
340 }
341 case value_t::number_integer:
342 {
343 val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_integer_t*>());
344 break;
345 }
346 case value_t::number_float:
347 {
348 val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_float_t*>());
349 break;
350 }
351 case value_t::boolean:
352 {
353 val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::boolean_t*>());
354 break;
355 }
356
357 case value_t::null:
358 case value_t::object:
359 case value_t::array:
360 case value_t::string:
361 case value_t::binary:
362 case value_t::discarded:
363 default:
364 JSON_THROW(type_error::create(302, "type must be number, but is " + std::string(j.type_name()), j));
365 }
366 }
367
368 template<typename BasicJsonType, typename... Args, std::size_t... Idx>
from_json_tuple_impl_base(BasicJsonType && j,index_sequence<Idx...>)369 std::tuple<Args...> from_json_tuple_impl_base(BasicJsonType&& j, index_sequence<Idx...> /*unused*/)
370 {
371 return std::make_tuple(std::forward<BasicJsonType>(j).at(Idx).template get<Args>()...);
372 }
373
374 template < typename BasicJsonType, class A1, class A2 >
from_json_tuple_impl(BasicJsonType && j,identity_tag<std::pair<A1,A2>>,priority_tag<0>)375 std::pair<A1, A2> from_json_tuple_impl(BasicJsonType&& j, identity_tag<std::pair<A1, A2>> /*unused*/, priority_tag<0> /*unused*/)
376 {
377 return {std::forward<BasicJsonType>(j).at(0).template get<A1>(),
378 std::forward<BasicJsonType>(j).at(1).template get<A2>()};
379 }
380
381 template<typename BasicJsonType, typename A1, typename A2>
from_json_tuple_impl(BasicJsonType && j,std::pair<A1,A2> & p,priority_tag<1>)382 void from_json_tuple_impl(BasicJsonType&& j, std::pair<A1, A2>& p, priority_tag<1> /*unused*/)
383 {
384 p = from_json_tuple_impl(std::forward<BasicJsonType>(j), identity_tag<std::pair<A1, A2>> {}, priority_tag<0> {});
385 }
386
387 template<typename BasicJsonType, typename... Args>
from_json_tuple_impl(BasicJsonType && j,identity_tag<std::tuple<Args...>>,priority_tag<2>)388 std::tuple<Args...> from_json_tuple_impl(BasicJsonType&& j, identity_tag<std::tuple<Args...>> /*unused*/, priority_tag<2> /*unused*/)
389 {
390 return from_json_tuple_impl_base<BasicJsonType, Args...>(std::forward<BasicJsonType>(j), index_sequence_for<Args...> {});
391 }
392
393 template<typename BasicJsonType, typename... Args>
from_json_tuple_impl(BasicJsonType && j,std::tuple<Args...> & t,priority_tag<3>)394 void from_json_tuple_impl(BasicJsonType&& j, std::tuple<Args...>& t, priority_tag<3> /*unused*/)
395 {
396 t = from_json_tuple_impl_base<BasicJsonType, Args...>(std::forward<BasicJsonType>(j), index_sequence_for<Args...> {});
397 }
398
399 template<typename BasicJsonType, typename TupleRelated>
from_json(BasicJsonType && j,TupleRelated && t)400 auto from_json(BasicJsonType&& j, TupleRelated&& t)
401 -> decltype(from_json_tuple_impl(std::forward<BasicJsonType>(j), std::forward<TupleRelated>(t), priority_tag<3> {}))
402 {
403 if (JSON_HEDLEY_UNLIKELY(!j.is_array()))
404 {
405 JSON_THROW(type_error::create(302, "type must be array, but is " + std::string(j.type_name()), j));
406 }
407
408 return from_json_tuple_impl(std::forward<BasicJsonType>(j), std::forward<TupleRelated>(t), priority_tag<3> {});
409 }
410
411 template < typename BasicJsonType, typename Key, typename Value, typename Compare, typename Allocator,
412 typename = enable_if_t < !std::is_constructible <
413 typename BasicJsonType::string_t, Key >::value >>
from_json(const BasicJsonType & j,std::map<Key,Value,Compare,Allocator> & m)414 void from_json(const BasicJsonType& j, std::map<Key, Value, Compare, Allocator>& m)
415 {
416 if (JSON_HEDLEY_UNLIKELY(!j.is_array()))
417 {
418 JSON_THROW(type_error::create(302, "type must be array, but is " + std::string(j.type_name()), j));
419 }
420 m.clear();
421 for (const auto& p : j)
422 {
423 if (JSON_HEDLEY_UNLIKELY(!p.is_array()))
424 {
425 JSON_THROW(type_error::create(302, "type must be array, but is " + std::string(p.type_name()), j));
426 }
427 m.emplace(p.at(0).template get<Key>(), p.at(1).template get<Value>());
428 }
429 }
430
431 template < typename BasicJsonType, typename Key, typename Value, typename Hash, typename KeyEqual, typename Allocator,
432 typename = enable_if_t < !std::is_constructible <
433 typename BasicJsonType::string_t, Key >::value >>
from_json(const BasicJsonType & j,std::unordered_map<Key,Value,Hash,KeyEqual,Allocator> & m)434 void from_json(const BasicJsonType& j, std::unordered_map<Key, Value, Hash, KeyEqual, Allocator>& m)
435 {
436 if (JSON_HEDLEY_UNLIKELY(!j.is_array()))
437 {
438 JSON_THROW(type_error::create(302, "type must be array, but is " + std::string(j.type_name()), j));
439 }
440 m.clear();
441 for (const auto& p : j)
442 {
443 if (JSON_HEDLEY_UNLIKELY(!p.is_array()))
444 {
445 JSON_THROW(type_error::create(302, "type must be array, but is " + std::string(p.type_name()), j));
446 }
447 m.emplace(p.at(0).template get<Key>(), p.at(1).template get<Value>());
448 }
449 }
450
451 #ifdef JSON_HAS_CPP_17
452 template<typename BasicJsonType>
from_json(const BasicJsonType & j,std::filesystem::path & p)453 void from_json(const BasicJsonType& j, std::filesystem::path& p)
454 {
455 if (JSON_HEDLEY_UNLIKELY(!j.is_string()))
456 {
457 JSON_THROW(type_error::create(302, "type must be string, but is " + std::string(j.type_name()), j));
458 }
459 p = *j.template get_ptr<const typename BasicJsonType::string_t*>();
460 }
461 #endif
462
463 struct from_json_fn
464 {
465 template<typename BasicJsonType, typename T>
operator ()nlohmann::detail::from_json_fn466 auto operator()(const BasicJsonType& j, T&& val) const
467 noexcept(noexcept(from_json(j, std::forward<T>(val))))
468 -> decltype(from_json(j, std::forward<T>(val)))
469 {
470 return from_json(j, std::forward<T>(val));
471 }
472 };
473 } // namespace detail
474
475 /// namespace to hold default `from_json` function
476 /// to see why this is required:
477 /// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4381.html
478 namespace // NOLINT(cert-dcl59-cpp,fuchsia-header-anon-namespaces,google-build-namespaces)
479 {
480 constexpr const auto& from_json = detail::static_const<detail::from_json_fn>::value; // NOLINT(misc-definitions-in-headers)
481 } // namespace
482 } // namespace nlohmann
483