1// __ _____ _____ _____
2// __| | __| | | | JSON for Modern C++
3// | | |__ | | | | | | version 3.11.3
4// |_____|_____|_____|_|___| https://github.com/nlohmann/json
5//
6// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
7// SPDX-License-Identifier: MIT
8
9#pragma once
10
11#include <algorithm> // all_of
12#include <cctype> // isdigit
13#include <cerrno> // errno, ERANGE
14#include <cstdlib> // strtoull
15#ifndef JSON_NO_IO
16 #include <iosfwd> // ostream
17#endif // JSON_NO_IO
18#include <limits> // max
19#include <numeric> // accumulate
20#include <string> // string
21#include <utility> // move
22#include <vector> // vector
23
24#include <nlohmann/detail/exceptions.hpp>
25#include <nlohmann/detail/macro_scope.hpp>
26#include <nlohmann/detail/string_concat.hpp>
27#include <nlohmann/detail/string_escape.hpp>
28#include <nlohmann/detail/value_t.hpp>
29
30NLOHMANN_JSON_NAMESPACE_BEGIN
31
32/// @brief JSON Pointer defines a string syntax for identifying a specific value within a JSON document
33/// @sa https://json.nlohmann.me/api/json_pointer/
34template<typename RefStringType>
35class json_pointer
36{
37 // allow basic_json to access private members
38 NLOHMANN_BASIC_JSON_TPL_DECLARATION
39 friend class basic_json;
40
41 template<typename>
42 friend class json_pointer;
43
44 template<typename T>
45 struct string_t_helper
46 {
47 using type = T;
48 };
49
50 NLOHMANN_BASIC_JSON_TPL_DECLARATION
51 struct string_t_helper<NLOHMANN_BASIC_JSON_TPL>
52 {
53 using type = StringType;
54 };
55
56 public:
57 // for backwards compatibility accept BasicJsonType
58 using string_t = typename string_t_helper<RefStringType>::type;
59
60 /// @brief create JSON pointer
61 /// @sa https://json.nlohmann.me/api/json_pointer/json_pointer/
62 explicit json_pointer(const string_t& s = "")
63 : reference_tokens(split(reference_string: s))
64 {}
65
66 /// @brief return a string representation of the JSON pointer
67 /// @sa https://json.nlohmann.me/api/json_pointer/to_string/
68 string_t to_string() const
69 {
70 return std::accumulate(reference_tokens.begin(), reference_tokens.end(),
71 string_t{},
72 [](const string_t& a, const string_t& b)
73 {
74 return detail::concat(a, '/', detail::escape(b));
75 });
76 }
77
78 /// @brief return a string representation of the JSON pointer
79 /// @sa https://json.nlohmann.me/api/json_pointer/operator_string/
80 JSON_HEDLEY_DEPRECATED_FOR(3.11.0, to_string())
81 operator string_t() const
82 {
83 return to_string();
84 }
85
86#ifndef JSON_NO_IO
87 /// @brief write string representation of the JSON pointer to stream
88 /// @sa https://json.nlohmann.me/api/basic_json/operator_ltlt/
89 friend std::ostream& operator<<(std::ostream& o, const json_pointer& ptr)
90 {
91 o << ptr.to_string();
92 return o;
93 }
94#endif
95
96 /// @brief append another JSON pointer at the end of this JSON pointer
97 /// @sa https://json.nlohmann.me/api/json_pointer/operator_slasheq/
98 json_pointer& operator/=(const json_pointer& ptr)
99 {
100 reference_tokens.insert(reference_tokens.end(),
101 ptr.reference_tokens.begin(),
102 ptr.reference_tokens.end());
103 return *this;
104 }
105
106 /// @brief append an unescaped reference token at the end of this JSON pointer
107 /// @sa https://json.nlohmann.me/api/json_pointer/operator_slasheq/
108 json_pointer& operator/=(string_t token)
109 {
110 push_back(std::move(token));
111 return *this;
112 }
113
114 /// @brief append an array index at the end of this JSON pointer
115 /// @sa https://json.nlohmann.me/api/json_pointer/operator_slasheq/
116 json_pointer& operator/=(std::size_t array_idx)
117 {
118 return *this /= std::to_string(val: array_idx);
119 }
120
121 /// @brief create a new JSON pointer by appending the right JSON pointer at the end of the left JSON pointer
122 /// @sa https://json.nlohmann.me/api/json_pointer/operator_slash/
123 friend json_pointer operator/(const json_pointer& lhs,
124 const json_pointer& rhs)
125 {
126 return json_pointer(lhs) /= rhs;
127 }
128
129 /// @brief create a new JSON pointer by appending the unescaped token at the end of the JSON pointer
130 /// @sa https://json.nlohmann.me/api/json_pointer/operator_slash/
131 friend json_pointer operator/(const json_pointer& lhs, string_t token) // NOLINT(performance-unnecessary-value-param)
132 {
133 return json_pointer(lhs) /= std::move(token);
134 }
135
136 /// @brief create a new JSON pointer by appending the array-index-token at the end of the JSON pointer
137 /// @sa https://json.nlohmann.me/api/json_pointer/operator_slash/
138 friend json_pointer operator/(const json_pointer& lhs, std::size_t array_idx)
139 {
140 return json_pointer(lhs) /= array_idx;
141 }
142
143 /// @brief returns the parent of this JSON pointer
144 /// @sa https://json.nlohmann.me/api/json_pointer/parent_pointer/
145 json_pointer parent_pointer() const
146 {
147 if (empty())
148 {
149 return *this;
150 }
151
152 json_pointer res = *this;
153 res.pop_back();
154 return res;
155 }
156
157 /// @brief remove last reference token
158 /// @sa https://json.nlohmann.me/api/json_pointer/pop_back/
159 void pop_back()
160 {
161 if (JSON_HEDLEY_UNLIKELY(empty()))
162 {
163 JSON_THROW(detail::out_of_range::create(405, "JSON pointer has no parent", nullptr));
164 }
165
166 reference_tokens.pop_back();
167 }
168
169 /// @brief return last reference token
170 /// @sa https://json.nlohmann.me/api/json_pointer/back/
171 const string_t& back() const
172 {
173 if (JSON_HEDLEY_UNLIKELY(empty()))
174 {
175 JSON_THROW(detail::out_of_range::create(405, "JSON pointer has no parent", nullptr));
176 }
177
178 return reference_tokens.back();
179 }
180
181 /// @brief append an unescaped token at the end of the reference pointer
182 /// @sa https://json.nlohmann.me/api/json_pointer/push_back/
183 void push_back(const string_t& token)
184 {
185 reference_tokens.push_back(token);
186 }
187
188 /// @brief append an unescaped token at the end of the reference pointer
189 /// @sa https://json.nlohmann.me/api/json_pointer/push_back/
190 void push_back(string_t&& token)
191 {
192 reference_tokens.push_back(std::move(token));
193 }
194
195 /// @brief return whether pointer points to the root document
196 /// @sa https://json.nlohmann.me/api/json_pointer/empty/
197 bool empty() const noexcept
198 {
199 return reference_tokens.empty();
200 }
201
202 private:
203 /*!
204 @param[in] s reference token to be converted into an array index
205
206 @return integer representation of @a s
207
208 @throw parse_error.106 if an array index begins with '0'
209 @throw parse_error.109 if an array index begins not with a digit
210 @throw out_of_range.404 if string @a s could not be converted to an integer
211 @throw out_of_range.410 if an array index exceeds size_type
212 */
213 template<typename BasicJsonType>
214 static typename BasicJsonType::size_type array_index(const string_t& s)
215 {
216 using size_type = typename BasicJsonType::size_type;
217
218 // error condition (cf. RFC 6901, Sect. 4)
219 if (JSON_HEDLEY_UNLIKELY(s.size() > 1 && s[0] == '0'))
220 {
221 JSON_THROW(detail::parse_error::create(106, 0, detail::concat("array index '", s, "' must not begin with '0'"), nullptr));
222 }
223
224 // error condition (cf. RFC 6901, Sect. 4)
225 if (JSON_HEDLEY_UNLIKELY(s.size() > 1 && !(s[0] >= '1' && s[0] <= '9')))
226 {
227 JSON_THROW(detail::parse_error::create(109, 0, detail::concat("array index '", s, "' is not a number"), nullptr));
228 }
229
230 const char* p = s.c_str();
231 char* p_end = nullptr;
232 errno = 0; // strtoull doesn't reset errno
233 const unsigned long long res = std::strtoull(nptr: p, endptr: &p_end, base: 10); // NOLINT(runtime/int)
234 if (p == p_end // invalid input or empty string
235 || errno == ERANGE // out of range
236 || JSON_HEDLEY_UNLIKELY(static_cast<std::size_t>(p_end - p) != s.size())) // incomplete read
237 {
238 JSON_THROW(detail::out_of_range::create(404, detail::concat("unresolved reference token '", s, "'"), nullptr));
239 }
240
241 // only triggered on special platforms (like 32bit), see also
242 // https://github.com/nlohmann/json/pull/2203
243 if (res >= static_cast<unsigned long long>((std::numeric_limits<size_type>::max)())) // NOLINT(runtime/int)
244 {
245 JSON_THROW(detail::out_of_range::create(410, detail::concat("array index ", s, " exceeds size_type"), nullptr)); // LCOV_EXCL_LINE
246 }
247
248 return static_cast<size_type>(res);
249 }
250
251 JSON_PRIVATE_UNLESS_TESTED:
252 json_pointer top() const
253 {
254 if (JSON_HEDLEY_UNLIKELY(empty()))
255 {
256 JSON_THROW(detail::out_of_range::create(405, "JSON pointer has no parent", nullptr));
257 }
258
259 json_pointer result = *this;
260 result.reference_tokens = {reference_tokens[0]};
261 return result;
262 }
263
264 private:
265 /*!
266 @brief create and return a reference to the pointed to value
267
268 @complexity Linear in the number of reference tokens.
269
270 @throw parse_error.109 if array index is not a number
271 @throw type_error.313 if value cannot be unflattened
272 */
273 template<typename BasicJsonType>
274 BasicJsonType& get_and_create(BasicJsonType& j) const
275 {
276 auto* result = &j;
277
278 // in case no reference tokens exist, return a reference to the JSON value
279 // j which will be overwritten by a primitive value
280 for (const auto& reference_token : reference_tokens)
281 {
282 switch (result->type())
283 {
284 case detail::value_t::null:
285 {
286 if (reference_token == "0")
287 {
288 // start a new array if reference token is 0
289 result = &result->operator[](0);
290 }
291 else
292 {
293 // start a new object otherwise
294 result = &result->operator[](reference_token);
295 }
296 break;
297 }
298
299 case detail::value_t::object:
300 {
301 // create an entry in the object
302 result = &result->operator[](reference_token);
303 break;
304 }
305
306 case detail::value_t::array:
307 {
308 // create an entry in the array
309 result = &result->operator[](array_index<BasicJsonType>(reference_token));
310 break;
311 }
312
313 /*
314 The following code is only reached if there exists a reference
315 token _and_ the current value is primitive. In this case, we have
316 an error situation, because primitive values may only occur as
317 single value; that is, with an empty list of reference tokens.
318 */
319 case detail::value_t::string:
320 case detail::value_t::boolean:
321 case detail::value_t::number_integer:
322 case detail::value_t::number_unsigned:
323 case detail::value_t::number_float:
324 case detail::value_t::binary:
325 case detail::value_t::discarded:
326 default:
327 JSON_THROW(detail::type_error::create(313, "invalid value to unflatten", &j));
328 }
329 }
330
331 return *result;
332 }
333
334 /*!
335 @brief return a reference to the pointed to value
336
337 @note This version does not throw if a value is not present, but tries to
338 create nested values instead. For instance, calling this function
339 with pointer `"/this/that"` on a null value is equivalent to calling
340 `operator[]("this").operator[]("that")` on that value, effectively
341 changing the null value to an object.
342
343 @param[in] ptr a JSON value
344
345 @return reference to the JSON value pointed to by the JSON pointer
346
347 @complexity Linear in the length of the JSON pointer.
348
349 @throw parse_error.106 if an array index begins with '0'
350 @throw parse_error.109 if an array index was not a number
351 @throw out_of_range.404 if the JSON pointer can not be resolved
352 */
353 template<typename BasicJsonType>
354 BasicJsonType& get_unchecked(BasicJsonType* ptr) const
355 {
356 for (const auto& reference_token : reference_tokens)
357 {
358 // convert null values to arrays or objects before continuing
359 if (ptr->is_null())
360 {
361 // check if reference token is a number
362 const bool nums =
363 std::all_of(reference_token.begin(), reference_token.end(),
364 [](const unsigned char x)
365 {
366 return std::isdigit(x);
367 });
368
369 // change value to array for numbers or "-" or to object otherwise
370 *ptr = (nums || reference_token == "-")
371 ? detail::value_t::array
372 : detail::value_t::object;
373 }
374
375 switch (ptr->type())
376 {
377 case detail::value_t::object:
378 {
379 // use unchecked object access
380 ptr = &ptr->operator[](reference_token);
381 break;
382 }
383
384 case detail::value_t::array:
385 {
386 if (reference_token == "-")
387 {
388 // explicitly treat "-" as index beyond the end
389 ptr = &ptr->operator[](ptr->m_data.m_value.array->size());
390 }
391 else
392 {
393 // convert array index to number; unchecked access
394 ptr = &ptr->operator[](array_index<BasicJsonType>(reference_token));
395 }
396 break;
397 }
398
399 case detail::value_t::null:
400 case detail::value_t::string:
401 case detail::value_t::boolean:
402 case detail::value_t::number_integer:
403 case detail::value_t::number_unsigned:
404 case detail::value_t::number_float:
405 case detail::value_t::binary:
406 case detail::value_t::discarded:
407 default:
408 JSON_THROW(detail::out_of_range::create(404, detail::concat("unresolved reference token '", reference_token, "'"), ptr));
409 }
410 }
411
412 return *ptr;
413 }
414
415 /*!
416 @throw parse_error.106 if an array index begins with '0'
417 @throw parse_error.109 if an array index was not a number
418 @throw out_of_range.402 if the array index '-' is used
419 @throw out_of_range.404 if the JSON pointer can not be resolved
420 */
421 template<typename BasicJsonType>
422 BasicJsonType& get_checked(BasicJsonType* ptr) const
423 {
424 for (const auto& reference_token : reference_tokens)
425 {
426 switch (ptr->type())
427 {
428 case detail::value_t::object:
429 {
430 // note: at performs range check
431 ptr = &ptr->at(reference_token);
432 break;
433 }
434
435 case detail::value_t::array:
436 {
437 if (JSON_HEDLEY_UNLIKELY(reference_token == "-"))
438 {
439 // "-" always fails the range check
440 JSON_THROW(detail::out_of_range::create(402, detail::concat(
441 "array index '-' (", std::to_string(ptr->m_data.m_value.array->size()),
442 ") is out of range"), ptr));
443 }
444
445 // note: at performs range check
446 ptr = &ptr->at(array_index<BasicJsonType>(reference_token));
447 break;
448 }
449
450 case detail::value_t::null:
451 case detail::value_t::string:
452 case detail::value_t::boolean:
453 case detail::value_t::number_integer:
454 case detail::value_t::number_unsigned:
455 case detail::value_t::number_float:
456 case detail::value_t::binary:
457 case detail::value_t::discarded:
458 default:
459 JSON_THROW(detail::out_of_range::create(404, detail::concat("unresolved reference token '", reference_token, "'"), ptr));
460 }
461 }
462
463 return *ptr;
464 }
465
466 /*!
467 @brief return a const reference to the pointed to value
468
469 @param[in] ptr a JSON value
470
471 @return const reference to the JSON value pointed to by the JSON
472 pointer
473
474 @throw parse_error.106 if an array index begins with '0'
475 @throw parse_error.109 if an array index was not a number
476 @throw out_of_range.402 if the array index '-' is used
477 @throw out_of_range.404 if the JSON pointer can not be resolved
478 */
479 template<typename BasicJsonType>
480 const BasicJsonType& get_unchecked(const BasicJsonType* ptr) const
481 {
482 for (const auto& reference_token : reference_tokens)
483 {
484 switch (ptr->type())
485 {
486 case detail::value_t::object:
487 {
488 // use unchecked object access
489 ptr = &ptr->operator[](reference_token);
490 break;
491 }
492
493 case detail::value_t::array:
494 {
495 if (JSON_HEDLEY_UNLIKELY(reference_token == "-"))
496 {
497 // "-" cannot be used for const access
498 JSON_THROW(detail::out_of_range::create(402, detail::concat("array index '-' (", std::to_string(ptr->m_data.m_value.array->size()), ") is out of range"), ptr));
499 }
500
501 // use unchecked array access
502 ptr = &ptr->operator[](array_index<BasicJsonType>(reference_token));
503 break;
504 }
505
506 case detail::value_t::null:
507 case detail::value_t::string:
508 case detail::value_t::boolean:
509 case detail::value_t::number_integer:
510 case detail::value_t::number_unsigned:
511 case detail::value_t::number_float:
512 case detail::value_t::binary:
513 case detail::value_t::discarded:
514 default:
515 JSON_THROW(detail::out_of_range::create(404, detail::concat("unresolved reference token '", reference_token, "'"), ptr));
516 }
517 }
518
519 return *ptr;
520 }
521
522 /*!
523 @throw parse_error.106 if an array index begins with '0'
524 @throw parse_error.109 if an array index was not a number
525 @throw out_of_range.402 if the array index '-' is used
526 @throw out_of_range.404 if the JSON pointer can not be resolved
527 */
528 template<typename BasicJsonType>
529 const BasicJsonType& get_checked(const BasicJsonType* ptr) const
530 {
531 for (const auto& reference_token : reference_tokens)
532 {
533 switch (ptr->type())
534 {
535 case detail::value_t::object:
536 {
537 // note: at performs range check
538 ptr = &ptr->at(reference_token);
539 break;
540 }
541
542 case detail::value_t::array:
543 {
544 if (JSON_HEDLEY_UNLIKELY(reference_token == "-"))
545 {
546 // "-" always fails the range check
547 JSON_THROW(detail::out_of_range::create(402, detail::concat(
548 "array index '-' (", std::to_string(ptr->m_data.m_value.array->size()),
549 ") is out of range"), ptr));
550 }
551
552 // note: at performs range check
553 ptr = &ptr->at(array_index<BasicJsonType>(reference_token));
554 break;
555 }
556
557 case detail::value_t::null:
558 case detail::value_t::string:
559 case detail::value_t::boolean:
560 case detail::value_t::number_integer:
561 case detail::value_t::number_unsigned:
562 case detail::value_t::number_float:
563 case detail::value_t::binary:
564 case detail::value_t::discarded:
565 default:
566 JSON_THROW(detail::out_of_range::create(404, detail::concat("unresolved reference token '", reference_token, "'"), ptr));
567 }
568 }
569
570 return *ptr;
571 }
572
573 /*!
574 @throw parse_error.106 if an array index begins with '0'
575 @throw parse_error.109 if an array index was not a number
576 */
577 template<typename BasicJsonType>
578 bool contains(const BasicJsonType* ptr) const
579 {
580 for (const auto& reference_token : reference_tokens)
581 {
582 switch (ptr->type())
583 {
584 case detail::value_t::object:
585 {
586 if (!ptr->contains(reference_token))
587 {
588 // we did not find the key in the object
589 return false;
590 }
591
592 ptr = &ptr->operator[](reference_token);
593 break;
594 }
595
596 case detail::value_t::array:
597 {
598 if (JSON_HEDLEY_UNLIKELY(reference_token == "-"))
599 {
600 // "-" always fails the range check
601 return false;
602 }
603 if (JSON_HEDLEY_UNLIKELY(reference_token.size() == 1 && !("0" <= reference_token && reference_token <= "9")))
604 {
605 // invalid char
606 return false;
607 }
608 if (JSON_HEDLEY_UNLIKELY(reference_token.size() > 1))
609 {
610 if (JSON_HEDLEY_UNLIKELY(!('1' <= reference_token[0] && reference_token[0] <= '9')))
611 {
612 // first char should be between '1' and '9'
613 return false;
614 }
615 for (std::size_t i = 1; i < reference_token.size(); i++)
616 {
617 if (JSON_HEDLEY_UNLIKELY(!('0' <= reference_token[i] && reference_token[i] <= '9')))
618 {
619 // other char should be between '0' and '9'
620 return false;
621 }
622 }
623 }
624
625 const auto idx = array_index<BasicJsonType>(reference_token);
626 if (idx >= ptr->size())
627 {
628 // index out of range
629 return false;
630 }
631
632 ptr = &ptr->operator[](idx);
633 break;
634 }
635
636 case detail::value_t::null:
637 case detail::value_t::string:
638 case detail::value_t::boolean:
639 case detail::value_t::number_integer:
640 case detail::value_t::number_unsigned:
641 case detail::value_t::number_float:
642 case detail::value_t::binary:
643 case detail::value_t::discarded:
644 default:
645 {
646 // we do not expect primitive values if there is still a
647 // reference token to process
648 return false;
649 }
650 }
651 }
652
653 // no reference token left means we found a primitive value
654 return true;
655 }
656
657 /*!
658 @brief split the string input to reference tokens
659
660 @note This function is only called by the json_pointer constructor.
661 All exceptions below are documented there.
662
663 @throw parse_error.107 if the pointer is not empty or begins with '/'
664 @throw parse_error.108 if character '~' is not followed by '0' or '1'
665 */
666 static std::vector<string_t> split(const string_t& reference_string)
667 {
668 std::vector<string_t> result;
669
670 // special case: empty reference string -> no reference tokens
671 if (reference_string.empty())
672 {
673 return result;
674 }
675
676 // check if nonempty reference string begins with slash
677 if (JSON_HEDLEY_UNLIKELY(reference_string[0] != '/'))
678 {
679 JSON_THROW(detail::parse_error::create(107, 1, detail::concat("JSON pointer must be empty or begin with '/' - was: '", reference_string, "'"), nullptr));
680 }
681
682 // extract the reference tokens:
683 // - slash: position of the last read slash (or end of string)
684 // - start: position after the previous slash
685 for (
686 // search for the first slash after the first character
687 std::size_t slash = reference_string.find_first_of('/', 1),
688 // set the beginning of the first reference token
689 start = 1;
690 // we can stop if start == 0 (if slash == string_t::npos)
691 start != 0;
692 // set the beginning of the next reference token
693 // (will eventually be 0 if slash == string_t::npos)
694 start = (slash == string_t::npos) ? 0 : slash + 1,
695 // find next slash
696 slash = reference_string.find_first_of('/', start))
697 {
698 // use the text between the beginning of the reference token
699 // (start) and the last slash (slash).
700 auto reference_token = reference_string.substr(start, slash - start);
701
702 // check reference tokens are properly escaped
703 for (std::size_t pos = reference_token.find_first_of('~');
704 pos != string_t::npos;
705 pos = reference_token.find_first_of('~', pos + 1))
706 {
707 JSON_ASSERT(reference_token[pos] == '~');
708
709 // ~ must be followed by 0 or 1
710 if (JSON_HEDLEY_UNLIKELY(pos == reference_token.size() - 1 ||
711 (reference_token[pos + 1] != '0' &&
712 reference_token[pos + 1] != '1')))
713 {
714 JSON_THROW(detail::parse_error::create(108, 0, "escape character '~' must be followed with '0' or '1'", nullptr));
715 }
716 }
717
718 // finally, store the reference token
719 detail::unescape(reference_token);
720 result.push_back(reference_token);
721 }
722
723 return result;
724 }
725
726 private:
727 /*!
728 @param[in] reference_string the reference string to the current value
729 @param[in] value the value to consider
730 @param[in,out] result the result object to insert values to
731
732 @note Empty objects or arrays are flattened to `null`.
733 */
734 template<typename BasicJsonType>
735 static void flatten(const string_t& reference_string,
736 const BasicJsonType& value,
737 BasicJsonType& result)
738 {
739 switch (value.type())
740 {
741 case detail::value_t::array:
742 {
743 if (value.m_data.m_value.array->empty())
744 {
745 // flatten empty array as null
746 result[reference_string] = nullptr;
747 }
748 else
749 {
750 // iterate array and use index as reference string
751 for (std::size_t i = 0; i < value.m_data.m_value.array->size(); ++i)
752 {
753 flatten(detail::concat(reference_string, '/', std::to_string(val: i)),
754 value.m_data.m_value.array->operator[](i), result);
755 }
756 }
757 break;
758 }
759
760 case detail::value_t::object:
761 {
762 if (value.m_data.m_value.object->empty())
763 {
764 // flatten empty object as null
765 result[reference_string] = nullptr;
766 }
767 else
768 {
769 // iterate object and use keys as reference string
770 for (const auto& element : *value.m_data.m_value.object)
771 {
772 flatten(detail::concat(reference_string, '/', detail::escape(element.first)), element.second, result);
773 }
774 }
775 break;
776 }
777
778 case detail::value_t::null:
779 case detail::value_t::string:
780 case detail::value_t::boolean:
781 case detail::value_t::number_integer:
782 case detail::value_t::number_unsigned:
783 case detail::value_t::number_float:
784 case detail::value_t::binary:
785 case detail::value_t::discarded:
786 default:
787 {
788 // add primitive value with its reference string
789 result[reference_string] = value;
790 break;
791 }
792 }
793 }
794
795 /*!
796 @param[in] value flattened JSON
797
798 @return unflattened JSON
799
800 @throw parse_error.109 if array index is not a number
801 @throw type_error.314 if value is not an object
802 @throw type_error.315 if object values are not primitive
803 @throw type_error.313 if value cannot be unflattened
804 */
805 template<typename BasicJsonType>
806 static BasicJsonType
807 unflatten(const BasicJsonType& value)
808 {
809 if (JSON_HEDLEY_UNLIKELY(!value.is_object()))
810 {
811 JSON_THROW(detail::type_error::create(314, "only objects can be unflattened", &value));
812 }
813
814 BasicJsonType result;
815
816 // iterate the JSON object values
817 for (const auto& element : *value.m_data.m_value.object)
818 {
819 if (JSON_HEDLEY_UNLIKELY(!element.second.is_primitive()))
820 {
821 JSON_THROW(detail::type_error::create(315, "values in object must be primitive", &element.second));
822 }
823
824 // assign value to reference pointed to by JSON pointer; Note that if
825 // the JSON pointer is "" (i.e., points to the whole value), function
826 // get_and_create returns a reference to result itself. An assignment
827 // will then create a primitive value.
828 json_pointer(element.first).get_and_create(result) = element.second;
829 }
830
831 return result;
832 }
833
834 // can't use conversion operator because of ambiguity
835 json_pointer<string_t> convert() const&
836 {
837 json_pointer<string_t> result;
838 result.reference_tokens = reference_tokens;
839 return result;
840 }
841
842 json_pointer<string_t> convert()&&
843 {
844 json_pointer<string_t> result;
845 result.reference_tokens = std::move(reference_tokens);
846 return result;
847 }
848
849 public:
850#if JSON_HAS_THREE_WAY_COMPARISON
851 /// @brief compares two JSON pointers for equality
852 /// @sa https://json.nlohmann.me/api/json_pointer/operator_eq/
853 template<typename RefStringTypeRhs>
854 bool operator==(const json_pointer<RefStringTypeRhs>& rhs) const noexcept
855 {
856 return reference_tokens == rhs.reference_tokens;
857 }
858
859 /// @brief compares JSON pointer and string for equality
860 /// @sa https://json.nlohmann.me/api/json_pointer/operator_eq/
861 JSON_HEDLEY_DEPRECATED_FOR(3.11.2, operator==(json_pointer))
862 bool operator==(const string_t& rhs) const
863 {
864 return *this == json_pointer(rhs);
865 }
866
867 /// @brief 3-way compares two JSON pointers
868 template<typename RefStringTypeRhs>
869 std::strong_ordering operator<=>(const json_pointer<RefStringTypeRhs>& rhs) const noexcept // *NOPAD*
870 {
871 return reference_tokens <=> rhs.reference_tokens; // *NOPAD*
872 }
873#else
874 /// @brief compares two JSON pointers for equality
875 /// @sa https://json.nlohmann.me/api/json_pointer/operator_eq/
876 template<typename RefStringTypeLhs, typename RefStringTypeRhs>
877 // NOLINTNEXTLINE(readability-redundant-declaration)
878 friend bool operator==(const json_pointer<RefStringTypeLhs>& lhs,
879 const json_pointer<RefStringTypeRhs>& rhs) noexcept;
880
881 /// @brief compares JSON pointer and string for equality
882 /// @sa https://json.nlohmann.me/api/json_pointer/operator_eq/
883 template<typename RefStringTypeLhs, typename StringType>
884 // NOLINTNEXTLINE(readability-redundant-declaration)
885 friend bool operator==(const json_pointer<RefStringTypeLhs>& lhs,
886 const StringType& rhs);
887
888 /// @brief compares string and JSON pointer for equality
889 /// @sa https://json.nlohmann.me/api/json_pointer/operator_eq/
890 template<typename RefStringTypeRhs, typename StringType>
891 // NOLINTNEXTLINE(readability-redundant-declaration)
892 friend bool operator==(const StringType& lhs,
893 const json_pointer<RefStringTypeRhs>& rhs);
894
895 /// @brief compares two JSON pointers for inequality
896 /// @sa https://json.nlohmann.me/api/json_pointer/operator_ne/
897 template<typename RefStringTypeLhs, typename RefStringTypeRhs>
898 // NOLINTNEXTLINE(readability-redundant-declaration)
899 friend bool operator!=(const json_pointer<RefStringTypeLhs>& lhs,
900 const json_pointer<RefStringTypeRhs>& rhs) noexcept;
901
902 /// @brief compares JSON pointer and string for inequality
903 /// @sa https://json.nlohmann.me/api/json_pointer/operator_ne/
904 template<typename RefStringTypeLhs, typename StringType>
905 // NOLINTNEXTLINE(readability-redundant-declaration)
906 friend bool operator!=(const json_pointer<RefStringTypeLhs>& lhs,
907 const StringType& rhs);
908
909 /// @brief compares string and JSON pointer for inequality
910 /// @sa https://json.nlohmann.me/api/json_pointer/operator_ne/
911 template<typename RefStringTypeRhs, typename StringType>
912 // NOLINTNEXTLINE(readability-redundant-declaration)
913 friend bool operator!=(const StringType& lhs,
914 const json_pointer<RefStringTypeRhs>& rhs);
915
916 /// @brief compares two JSON pointer for less-than
917 template<typename RefStringTypeLhs, typename RefStringTypeRhs>
918 // NOLINTNEXTLINE(readability-redundant-declaration)
919 friend bool operator<(const json_pointer<RefStringTypeLhs>& lhs,
920 const json_pointer<RefStringTypeRhs>& rhs) noexcept;
921#endif
922
923 private:
924 /// the reference tokens
925 std::vector<string_t> reference_tokens;
926};
927
928#if !JSON_HAS_THREE_WAY_COMPARISON
929// functions cannot be defined inside class due to ODR violations
930template<typename RefStringTypeLhs, typename RefStringTypeRhs>
931inline bool operator==(const json_pointer<RefStringTypeLhs>& lhs,
932 const json_pointer<RefStringTypeRhs>& rhs) noexcept
933{
934 return lhs.reference_tokens == rhs.reference_tokens;
935}
936
937template<typename RefStringTypeLhs,
938 typename StringType = typename json_pointer<RefStringTypeLhs>::string_t>
939JSON_HEDLEY_DEPRECATED_FOR(3.11.2, operator==(json_pointer, json_pointer))
940inline bool operator==(const json_pointer<RefStringTypeLhs>& lhs,
941 const StringType& rhs)
942{
943 return lhs == json_pointer<RefStringTypeLhs>(rhs);
944}
945
946template<typename RefStringTypeRhs,
947 typename StringType = typename json_pointer<RefStringTypeRhs>::string_t>
948JSON_HEDLEY_DEPRECATED_FOR(3.11.2, operator==(json_pointer, json_pointer))
949inline bool operator==(const StringType& lhs,
950 const json_pointer<RefStringTypeRhs>& rhs)
951{
952 return json_pointer<RefStringTypeRhs>(lhs) == rhs;
953}
954
955template<typename RefStringTypeLhs, typename RefStringTypeRhs>
956inline bool operator!=(const json_pointer<RefStringTypeLhs>& lhs,
957 const json_pointer<RefStringTypeRhs>& rhs) noexcept
958{
959 return !(lhs == rhs);
960}
961
962template<typename RefStringTypeLhs,
963 typename StringType = typename json_pointer<RefStringTypeLhs>::string_t>
964JSON_HEDLEY_DEPRECATED_FOR(3.11.2, operator!=(json_pointer, json_pointer))
965inline bool operator!=(const json_pointer<RefStringTypeLhs>& lhs,
966 const StringType& rhs)
967{
968 return !(lhs == rhs);
969}
970
971template<typename RefStringTypeRhs,
972 typename StringType = typename json_pointer<RefStringTypeRhs>::string_t>
973JSON_HEDLEY_DEPRECATED_FOR(3.11.2, operator!=(json_pointer, json_pointer))
974inline bool operator!=(const StringType& lhs,
975 const json_pointer<RefStringTypeRhs>& rhs)
976{
977 return !(lhs == rhs);
978}
979
980template<typename RefStringTypeLhs, typename RefStringTypeRhs>
981inline bool operator<(const json_pointer<RefStringTypeLhs>& lhs,
982 const json_pointer<RefStringTypeRhs>& rhs) noexcept
983{
984 return lhs.reference_tokens < rhs.reference_tokens;
985}
986#endif
987
988NLOHMANN_JSON_NAMESPACE_END
989