Branch data Line data Source code
1 : : #pragma once
2 : :
3 : : #include <algorithm> // transform
4 : : #include <array> // array
5 : : #include <ciso646> // and, not
6 : : #include <forward_list> // forward_list
7 : : #include <iterator> // inserter, front_inserter, end
8 : : #include <map> // map
9 : : #include <string> // string
10 : : #include <tuple> // tuple, make_tuple
11 : : #include <type_traits> // is_arithmetic, is_same, is_enum, underlying_type, is_convertible
12 : : #include <unordered_map> // unordered_map
13 : : #include <utility> // pair, declval
14 : : #include <valarray> // valarray
15 : :
16 : : #include <nlohmann/detail/exceptions.hpp>
17 : : #include <nlohmann/detail/macro_scope.hpp>
18 : : #include <nlohmann/detail/meta/cpp_future.hpp>
19 : : #include <nlohmann/detail/meta/type_traits.hpp>
20 : : #include <nlohmann/detail/value_t.hpp>
21 : :
22 : : namespace nlohmann
23 : : {
24 : : namespace detail
25 : : {
26 : : template<typename BasicJsonType>
27 : : void from_json(const BasicJsonType& j, typename std::nullptr_t& n)
28 : : {
29 : : if (JSON_UNLIKELY(not j.is_null()))
30 : : {
31 : : JSON_THROW(type_error::create(302, "type must be null, but is " + std::string(j.type_name())));
32 : : }
33 : : n = nullptr;
34 : : }
35 : :
36 : : // overloads for basic_json template parameters
37 : : template<typename BasicJsonType, typename ArithmeticType,
38 : : enable_if_t<std::is_arithmetic<ArithmeticType>::value and
39 : : not std::is_same<ArithmeticType, typename BasicJsonType::boolean_t>::value,
40 : : int> = 0>
41 : 0 : void get_arithmetic_value(const BasicJsonType& j, ArithmeticType& val)
42 : : {
43 : 0 : switch (static_cast<value_t>(j))
44 : : {
45 : : case value_t::number_unsigned:
46 : : {
47 : 0 : val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_unsigned_t*>());
48 : 0 : break;
49 : : }
50 : : case value_t::number_integer:
51 : : {
52 : 0 : val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_integer_t*>());
53 : 0 : break;
54 : : }
55 : : case value_t::number_float:
56 : : {
57 : 0 : val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_float_t*>());
58 : 0 : break;
59 : : }
60 : :
61 : : default:
62 : 0 : JSON_THROW(type_error::create(302, "type must be number, but is " + std::string(j.type_name())));
63 : : }
64 : 0 : }
65 : :
66 : : template<typename BasicJsonType>
67 : 0 : void from_json(const BasicJsonType& j, typename BasicJsonType::boolean_t& b)
68 : : {
69 : 0 : if (JSON_UNLIKELY(not j.is_boolean()))
70 : : {
71 : 0 : JSON_THROW(type_error::create(302, "type must be boolean, but is " + std::string(j.type_name())));
72 : : }
73 : 0 : b = *j.template get_ptr<const typename BasicJsonType::boolean_t*>();
74 : 0 : }
75 : :
76 : : template<typename BasicJsonType>
77 : 0 : void from_json(const BasicJsonType& j, typename BasicJsonType::string_t& s)
78 : : {
79 : 0 : if (JSON_UNLIKELY(not j.is_string()))
80 : : {
81 : 0 : JSON_THROW(type_error::create(302, "type must be string, but is " + std::string(j.type_name())));
82 : : }
83 : 0 : s = *j.template get_ptr<const typename BasicJsonType::string_t*>();
84 : 0 : }
85 : :
86 : : template <
87 : : typename BasicJsonType, typename ConstructibleStringType,
88 : : enable_if_t <
89 : : is_constructible_string_type<BasicJsonType, ConstructibleStringType>::value and
90 : : not std::is_same<typename BasicJsonType::string_t,
91 : : ConstructibleStringType>::value,
92 : : int > = 0 >
93 : : void from_json(const BasicJsonType& j, ConstructibleStringType& s)
94 : : {
95 : : if (JSON_UNLIKELY(not j.is_string()))
96 : : {
97 : : JSON_THROW(type_error::create(302, "type must be string, but is " + std::string(j.type_name())));
98 : : }
99 : :
100 : : s = *j.template get_ptr<const typename BasicJsonType::string_t*>();
101 : : }
102 : :
103 : : template<typename BasicJsonType>
104 : 0 : void from_json(const BasicJsonType& j, typename BasicJsonType::number_float_t& val)
105 : : {
106 : 0 : get_arithmetic_value(j, val);
107 : 0 : }
108 : :
109 : : template<typename BasicJsonType>
110 : : void from_json(const BasicJsonType& j, typename BasicJsonType::number_unsigned_t& val)
111 : : {
112 : : get_arithmetic_value(j, val);
113 : : }
114 : :
115 : : template<typename BasicJsonType>
116 : : void from_json(const BasicJsonType& j, typename BasicJsonType::number_integer_t& val)
117 : : {
118 : : get_arithmetic_value(j, val);
119 : : }
120 : :
121 : : template<typename BasicJsonType, typename EnumType,
122 : : enable_if_t<std::is_enum<EnumType>::value, int> = 0>
123 : : void from_json(const BasicJsonType& j, EnumType& e)
124 : : {
125 : : typename std::underlying_type<EnumType>::type val;
126 : : get_arithmetic_value(j, val);
127 : : e = static_cast<EnumType>(val);
128 : : }
129 : :
130 : : // forward_list doesn't have an insert method
131 : : template<typename BasicJsonType, typename T, typename Allocator,
132 : : enable_if_t<std::is_convertible<BasicJsonType, T>::value, int> = 0>
133 : : void from_json(const BasicJsonType& j, std::forward_list<T, Allocator>& l)
134 : : {
135 : : if (JSON_UNLIKELY(not j.is_array()))
136 : : {
137 : : JSON_THROW(type_error::create(302, "type must be array, but is " + std::string(j.type_name())));
138 : : }
139 : : std::transform(j.rbegin(), j.rend(),
140 : : std::front_inserter(l), [](const BasicJsonType & i)
141 : : {
142 : : return i.template get<T>();
143 : : });
144 : : }
145 : :
146 : : // valarray doesn't have an insert method
147 : : template<typename BasicJsonType, typename T,
148 : : enable_if_t<std::is_convertible<BasicJsonType, T>::value, int> = 0>
149 : : void from_json(const BasicJsonType& j, std::valarray<T>& l)
150 : : {
151 : : if (JSON_UNLIKELY(not j.is_array()))
152 : : {
153 : : JSON_THROW(type_error::create(302, "type must be array, but is " + std::string(j.type_name())));
154 : : }
155 : : l.resize(j.size());
156 : : std::copy(j.m_value.array->begin(), j.m_value.array->end(), std::begin(l));
157 : : }
158 : :
159 : : template<typename BasicJsonType>
160 : : void from_json_array_impl(const BasicJsonType& j, typename BasicJsonType::array_t& arr, priority_tag<3> /*unused*/)
161 : : {
162 : : arr = *j.template get_ptr<const typename BasicJsonType::array_t*>();
163 : : }
164 : :
165 : : template <typename BasicJsonType, typename T, std::size_t N>
166 : : auto from_json_array_impl(const BasicJsonType& j, std::array<T, N>& arr,
167 : : priority_tag<2> /*unused*/)
168 : : -> decltype(j.template get<T>(), void())
169 : : {
170 : : for (std::size_t i = 0; i < N; ++i)
171 : : {
172 : : arr[i] = j.at(i).template get<T>();
173 : : }
174 : : }
175 : :
176 : : template<typename BasicJsonType, typename ConstructibleArrayType>
177 : : auto from_json_array_impl(const BasicJsonType& j, ConstructibleArrayType& arr, priority_tag<1> /*unused*/)
178 : : -> decltype(
179 : : arr.reserve(std::declval<typename ConstructibleArrayType::size_type>()),
180 : : j.template get<typename ConstructibleArrayType::value_type>(),
181 : : void())
182 : : {
183 : : using std::end;
184 : :
185 : : arr.reserve(j.size());
186 : : std::transform(j.begin(), j.end(),
187 : : std::inserter(arr, end(arr)), [](const BasicJsonType & i)
188 : : {
189 : : // get<BasicJsonType>() returns *this, this won't call a from_json
190 : : // method when value_type is BasicJsonType
191 : : return i.template get<typename ConstructibleArrayType::value_type>();
192 : : });
193 : : }
194 : :
195 : : template <typename BasicJsonType, typename ConstructibleArrayType>
196 : : void from_json_array_impl(const BasicJsonType& j, ConstructibleArrayType& arr,
197 : : priority_tag<0> /*unused*/)
198 : : {
199 : : using std::end;
200 : :
201 : : std::transform(
202 : : j.begin(), j.end(), std::inserter(arr, end(arr)),
203 : : [](const BasicJsonType & i)
204 : : {
205 : : // get<BasicJsonType>() returns *this, this won't call a from_json
206 : : // method when value_type is BasicJsonType
207 : : return i.template get<typename ConstructibleArrayType::value_type>();
208 : : });
209 : : }
210 : :
211 : : template <typename BasicJsonType, typename ConstructibleArrayType,
212 : : enable_if_t <
213 : : is_constructible_array_type<BasicJsonType, ConstructibleArrayType>::value and
214 : : not is_constructible_object_type<BasicJsonType, ConstructibleArrayType>::value and
215 : : not is_constructible_string_type<BasicJsonType, ConstructibleArrayType>::value and
216 : : not is_basic_json<ConstructibleArrayType>::value,
217 : : int > = 0 >
218 : :
219 : : auto from_json(const BasicJsonType& j, ConstructibleArrayType& arr)
220 : : -> decltype(from_json_array_impl(j, arr, priority_tag<3> {}),
221 : : j.template get<typename ConstructibleArrayType::value_type>(),
222 : : void())
223 : : {
224 : : if (JSON_UNLIKELY(not j.is_array()))
225 : : {
226 : : JSON_THROW(type_error::create(302, "type must be array, but is " +
227 : : std::string(j.type_name())));
228 : : }
229 : :
230 : : from_json_array_impl(j, arr, priority_tag<3> {});
231 : : }
232 : :
233 : : template<typename BasicJsonType, typename ConstructibleObjectType,
234 : : enable_if_t<is_constructible_object_type<BasicJsonType, ConstructibleObjectType>::value, int> = 0>
235 : : void from_json(const BasicJsonType& j, ConstructibleObjectType& obj)
236 : : {
237 : : if (JSON_UNLIKELY(not j.is_object()))
238 : : {
239 : : JSON_THROW(type_error::create(302, "type must be object, but is " + std::string(j.type_name())));
240 : : }
241 : :
242 : : auto inner_object = j.template get_ptr<const typename BasicJsonType::object_t*>();
243 : : using value_type = typename ConstructibleObjectType::value_type;
244 : : std::transform(
245 : : inner_object->begin(), inner_object->end(),
246 : : std::inserter(obj, obj.begin()),
247 : : [](typename BasicJsonType::object_t::value_type const & p)
248 : : {
249 : : return value_type(p.first, p.second.template get<typename ConstructibleObjectType::mapped_type>());
250 : : });
251 : : }
252 : :
253 : : // overload for arithmetic types, not chosen for basic_json template arguments
254 : : // (BooleanType, etc..); note: Is it really necessary to provide explicit
255 : : // overloads for boolean_t etc. in case of a custom BooleanType which is not
256 : : // an arithmetic type?
257 : : template<typename BasicJsonType, typename ArithmeticType,
258 : : enable_if_t <
259 : : std::is_arithmetic<ArithmeticType>::value and
260 : : not std::is_same<ArithmeticType, typename BasicJsonType::number_unsigned_t>::value and
261 : : not std::is_same<ArithmeticType, typename BasicJsonType::number_integer_t>::value and
262 : : not std::is_same<ArithmeticType, typename BasicJsonType::number_float_t>::value and
263 : : not std::is_same<ArithmeticType, typename BasicJsonType::boolean_t>::value,
264 : : int> = 0>
265 : 0 : void from_json(const BasicJsonType& j, ArithmeticType& val)
266 : : {
267 : 0 : switch (static_cast<value_t>(j))
268 : : {
269 : : case value_t::number_unsigned:
270 : : {
271 : 0 : val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_unsigned_t*>());
272 : 0 : break;
273 : : }
274 : : case value_t::number_integer:
275 : : {
276 : 0 : val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_integer_t*>());
277 : 0 : break;
278 : : }
279 : : case value_t::number_float:
280 : : {
281 : 0 : val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_float_t*>());
282 : 0 : break;
283 : : }
284 : : case value_t::boolean:
285 : : {
286 : 0 : val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::boolean_t*>());
287 : 0 : break;
288 : : }
289 : :
290 : : default:
291 : 0 : JSON_THROW(type_error::create(302, "type must be number, but is " + std::string(j.type_name())));
292 : : }
293 : 0 : }
294 : :
295 : : template<typename BasicJsonType, typename A1, typename A2>
296 : : void from_json(const BasicJsonType& j, std::pair<A1, A2>& p)
297 : : {
298 : : p = {j.at(0).template get<A1>(), j.at(1).template get<A2>()};
299 : : }
300 : :
301 : : template<typename BasicJsonType, typename Tuple, std::size_t... Idx>
302 : : void from_json_tuple_impl(const BasicJsonType& j, Tuple& t, index_sequence<Idx...> /*unused*/)
303 : : {
304 : : t = std::make_tuple(j.at(Idx).template get<typename std::tuple_element<Idx, Tuple>::type>()...);
305 : : }
306 : :
307 : : template<typename BasicJsonType, typename... Args>
308 : : void from_json(const BasicJsonType& j, std::tuple<Args...>& t)
309 : : {
310 : : from_json_tuple_impl(j, t, index_sequence_for<Args...> {});
311 : : }
312 : :
313 : : template <typename BasicJsonType, typename Key, typename Value, typename Compare, typename Allocator,
314 : : typename = enable_if_t<not std::is_constructible<
315 : : typename BasicJsonType::string_t, Key>::value>>
316 : : void from_json(const BasicJsonType& j, std::map<Key, Value, Compare, Allocator>& m)
317 : : {
318 : : if (JSON_UNLIKELY(not j.is_array()))
319 : : {
320 : : JSON_THROW(type_error::create(302, "type must be array, but is " + std::string(j.type_name())));
321 : : }
322 : : for (const auto& p : j)
323 : : {
324 : : if (JSON_UNLIKELY(not p.is_array()))
325 : : {
326 : : JSON_THROW(type_error::create(302, "type must be array, but is " + std::string(p.type_name())));
327 : : }
328 : : m.emplace(p.at(0).template get<Key>(), p.at(1).template get<Value>());
329 : : }
330 : : }
331 : :
332 : : template <typename BasicJsonType, typename Key, typename Value, typename Hash, typename KeyEqual, typename Allocator,
333 : : typename = enable_if_t<not std::is_constructible<
334 : : typename BasicJsonType::string_t, Key>::value>>
335 : : void from_json(const BasicJsonType& j, std::unordered_map<Key, Value, Hash, KeyEqual, Allocator>& m)
336 : : {
337 : : if (JSON_UNLIKELY(not j.is_array()))
338 : : {
339 : : JSON_THROW(type_error::create(302, "type must be array, but is " + std::string(j.type_name())));
340 : : }
341 : : for (const auto& p : j)
342 : : {
343 : : if (JSON_UNLIKELY(not p.is_array()))
344 : : {
345 : : JSON_THROW(type_error::create(302, "type must be array, but is " + std::string(p.type_name())));
346 : : }
347 : : m.emplace(p.at(0).template get<Key>(), p.at(1).template get<Value>());
348 : : }
349 : : }
350 : :
351 : : struct from_json_fn
352 : : {
353 : : template<typename BasicJsonType, typename T>
354 : 0 : auto operator()(const BasicJsonType& j, T& val) const
355 : : noexcept(noexcept(from_json(j, val)))
356 : : -> decltype(from_json(j, val), void())
357 : : {
358 : 0 : return from_json(j, val);
359 : : }
360 : : };
361 : : } // namespace detail
362 : :
363 : : /// namespace to hold default `from_json` function
364 : : /// to see why this is required:
365 : : /// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4381.html
366 : : namespace
367 : : {
368 : : constexpr const auto& from_json = detail::static_const<detail::from_json_fn>::value;
369 : : } // namespace
370 : : } // namespace nlohmann
|
