json.hpp source code [include/nlohmann/json.hpp]

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	/**************************************************************************\
10	* Note on documentation: The source files contain links to the online *
11	* documentation of the public API at https://json.nlohmann.me. This URL *
12	* contains the most recent documentation and should also be applicable to *
13	* previous versions; documentation for deprecated functions is not *
14	* removed, but marked deprecated. See "Generate documentation" section in *
15	* file docs/README.md. *
16	\**************************************************************************/
17
18	#ifndef INCLUDE_NLOHMANN_JSON_HPP_
19	#define INCLUDE_NLOHMANN_JSON_HPP_
20
21	#include <algorithm> // all_of, find, for_each
22	#include <cstddef> // nullptr_t, ptrdiff_t, size_t
23	#include <functional> // hash, less
24	#include <initializer_list> // initializer_list
25	#ifndef JSON_NO_IO
26	#include <iosfwd> // istream, ostream
27	#endif // JSON_NO_IO
28	#include <iterator> // random_access_iterator_tag
29	#include <memory> // unique_ptr
30	#include <string> // string, stoi, to_string
31	#include <utility> // declval, forward, move, pair, swap
32	#include <vector> // vector
33
34	#include <nlohmann/adl_serializer.hpp>
35	#include <nlohmann/byte_container_with_subtype.hpp>
36	#include <nlohmann/detail/conversions/from_json.hpp>
37	#include <nlohmann/detail/conversions/to_json.hpp>
38	#include <nlohmann/detail/exceptions.hpp>
39	#include <nlohmann/detail/hash.hpp>
40	#include <nlohmann/detail/input/binary_reader.hpp>
41	#include <nlohmann/detail/input/input_adapters.hpp>
42	#include <nlohmann/detail/input/lexer.hpp>
43	#include <nlohmann/detail/input/parser.hpp>
44	#include <nlohmann/detail/iterators/internal_iterator.hpp>
45	#include <nlohmann/detail/iterators/iter_impl.hpp>
46	#include <nlohmann/detail/iterators/iteration_proxy.hpp>
47	#include <nlohmann/detail/iterators/json_reverse_iterator.hpp>
48	#include <nlohmann/detail/iterators/primitive_iterator.hpp>
49	#include <nlohmann/detail/json_custom_base_class.hpp>
50	#include <nlohmann/detail/json_pointer.hpp>
51	#include <nlohmann/detail/json_ref.hpp>
52	#include <nlohmann/detail/macro_scope.hpp>
53	#include <nlohmann/detail/string_concat.hpp>
54	#include <nlohmann/detail/string_escape.hpp>
55	#include <nlohmann/detail/meta/cpp_future.hpp>
56	#include <nlohmann/detail/meta/type_traits.hpp>
57	#include <nlohmann/detail/output/binary_writer.hpp>
58	#include <nlohmann/detail/output/output_adapters.hpp>
59	#include <nlohmann/detail/output/serializer.hpp>
60	#include <nlohmann/detail/value_t.hpp>
61	#include <nlohmann/json_fwd.hpp>
62	#include <nlohmann/ordered_map.hpp>
63
64	#if defined(JSON_HAS_CPP_17)
65	#if JSON_HAS_STATIC_RTTI
66	#include <any>
67	#endif
68	#include <string_view>
69	#endif
70
71	/!*
72	@brief namespace for Niels Lohmann
73	@see https://github.com/nlohmann
74	@since version 1.0.0
75	*/
76	NLOHMANN_JSON_NAMESPACE_BEGIN
77
78	/!*
79	@brief a class to store JSON values
80
81	@internal
82	@invariant The member variables @a m_value and @a m_type have the following
83	relationship:
84	- If `m_type == value_t::object`, then `m_value.object != nullptr`.
85	- If `m_type == value_t::array`, then `m_value.array != nullptr`.
86	- If `m_type == value_t::string`, then `m_value.string != nullptr`.
87	The invariants are checked by member function assert_invariant().
88
89	@note ObjectType trick from https://stackoverflow.com/a/9860911
90	@endinternal
91
92	@since version 1.0.0
93
94	@nosubgrouping
95	*/
96	NLOHMANN_BASIC_JSON_TPL_DECLARATION
97	class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-special-member-functions)
98	: public ::nlohmann::detail::json_base_class<CustomBaseClass>
99	{
100	private:
101	template<detail::value_t> friend struct detail::external_constructor;
102
103	template<typename>
104	friend class ::nlohmann::json_pointer;
105	// can be restored when json_pointer backwards compatibility is removed
106	// friend ::nlohmann::json_pointer<StringType>;
107
108	template<typename BasicJsonType, typename InputType>
109	friend class ::nlohmann::detail::parser;
110	friend ::nlohmann::detail::serializer<basic_json>;
111	template<typename BasicJsonType>
112	friend class ::nlohmann::detail::iter_impl;
113	template<typename BasicJsonType, typename CharType>
114	friend class ::nlohmann::detail::binary_writer;
115	template<typename BasicJsonType, typename InputType, typename SAX>
116	friend class ::nlohmann::detail::binary_reader;
117	template<typename BasicJsonType>
118	friend class ::nlohmann::detail::json_sax_dom_parser;
119	template<typename BasicJsonType>
120	friend class ::nlohmann::detail::json_sax_dom_callback_parser;
121	friend class ::nlohmann::detail::exception;
122
123	/// workaround type for MSVC
124	using basic_json_t = NLOHMANN_BASIC_JSON_TPL;
125	using json_base_class_t = ::nlohmann::detail::json_base_class<CustomBaseClass>;
126
127	JSON_PRIVATE_UNLESS_TESTED:
128	// convenience aliases for types residing in namespace detail;
129	using lexer = ::nlohmann::detail::lexer_base<basic_json>;
130
131	template<typename InputAdapterType>
132	static ::nlohmann::detail::parser<basic_json, InputAdapterType> parser(
133	InputAdapterType adapter,
134	detail::parser_callback_t<basic_json>cb = nullptr,
135	const bool allow_exceptions = true,
136	const bool ignore_comments = false
137	)
138	{
139	return ::nlohmann::detail::parser<basic_json, InputAdapterType>(std::move(adapter),
140	std::move(cb), allow_exceptions, ignore_comments);
141	}
142
143	private:
144	using primitive_iterator_t = ::nlohmann::detail::primitive_iterator_t;
145	template<typename BasicJsonType>
146	using internal_iterator = ::nlohmann::detail::internal_iterator<BasicJsonType>;
147	template<typename BasicJsonType>
148	using iter_impl = ::nlohmann::detail::iter_impl<BasicJsonType>;
149	template<typename Iterator>
150	using iteration_proxy = ::nlohmann::detail::iteration_proxy<Iterator>;
151	template<typename Base> using json_reverse_iterator = ::nlohmann::detail::json_reverse_iterator<Base>;
152
153	template<typename CharType>
154	using output_adapter_t = ::nlohmann::detail::output_adapter_t<CharType>;
155
156	template<typename InputType>
157	using binary_reader = ::nlohmann::detail::binary_reader<basic_json, InputType>;
158	template<typename CharType> using binary_writer = ::nlohmann::detail::binary_writer<basic_json, CharType>;
159
160	JSON_PRIVATE_UNLESS_TESTED:
161	using serializer = ::nlohmann::detail::serializer<basic_json>;
162
163	public:
164	using value_t = detail::value_t;
165	/// JSON Pointer, see @ref nlohmann::json_pointer
166	using json_pointer = ::nlohmann::json_pointer<StringType>;
167	template<typename T, typename SFINAE>
168	using json_serializer = JSONSerializer<T, SFINAE>;
169	/// how to treat decoding errors
170	using error_handler_t = detail::error_handler_t;
171	/// how to treat CBOR tags
172	using cbor_tag_handler_t = detail::cbor_tag_handler_t;
173	/// helper type for initializer lists of basic_json values
174	using initializer_list_t = std::initializer_list<detail::json_ref<basic_json>>;
175
176	using input_format_t = detail::input_format_t;
177	/// SAX interface type, see @ref nlohmann::json_sax
178	using json_sax_t = json_sax<basic_json>;
179
180	////////////////
181	// exceptions //
182	////////////////
183
184	/// @name exceptions
185	/// Classes to implement user-defined exceptions.
186	/// @{
187
188	using exception = detail::exception;
189	using parse_error = detail::parse_error;
190	using invalid_iterator = detail::invalid_iterator;
191	using type_error = detail::type_error;
192	using out_of_range = detail::out_of_range;
193	using other_error = detail::other_error;
194
195	/// @}
196
197	/////////////////////
198	// container types //
199	/////////////////////
200
201	/// @name container types
202	/// The canonic container types to use @ref basic_json like any other STL
203	/// container.
204	/// @{
205
206	/// the type of elements in a basic_json container
207	using value_type = basic_json;
208
209	/// the type of an element reference
210	using reference = value_type&;
211	/// the type of an element const reference
212	using const_reference = const value_type&;
213
214	/// a type to represent differences between iterators
215	using difference_type = std::ptrdiff_t;
216	/// a type to represent container sizes
217	using size_type = std::size_t;
218
219	/// the allocator type
220	using allocator_type = AllocatorType<basic_json>;
221
222	/// the type of an element pointer
223	using pointer = typename std::allocator_traits<allocator_type>::pointer;
224	/// the type of an element const pointer
225	using const_pointer = typename std::allocator_traits<allocator_type>::const_pointer;
226
227	/// an iterator for a basic_json container
228	using iterator = iter_impl<basic_json>;
229	/// a const iterator for a basic_json container
230	using const_iterator = iter_impl<const basic_json>;
231	/// a reverse iterator for a basic_json container
232	using reverse_iterator = json_reverse_iterator<typename basic_json::iterator>;
233	/// a const reverse iterator for a basic_json container
234	using const_reverse_iterator = json_reverse_iterator<typename basic_json::const_iterator>;
235
236	/// @}
237
238	/// @brief returns the allocator associated with the container
239	/// @sa https://json.nlohmann.me/api/basic_json/get_allocator/
240	static allocator_type get_allocator()
241	{
242	return allocator_type();
243	}
244
245	/// @brief returns version information on the library
246	/// @sa https://json.nlohmann.me/api/basic_json/meta/
247	JSON_HEDLEY_WARN_UNUSED_RESULT
248	static basic_json meta()
249	{
250	basic_json result;
251
252	result["copyright"] = "(C) 2013-2023 Niels Lohmann";
253	result["name"] = "JSON for Modern C++";
254	result["url"] = "https://github.com/nlohmann/json";
255	result["version"]["string"] =
256	detail::concat(args: std::to_string(NLOHMANN_JSON_VERSION_MAJOR), args: `'.'`,
257	args: std::to_string(NLOHMANN_JSON_VERSION_MINOR), args: `'.'`,
258	args: std::to_string(NLOHMANN_JSON_VERSION_PATCH));
259	result["version"]["major"] = NLOHMANN_JSON_VERSION_MAJOR;
260	result["version"]["minor"] = NLOHMANN_JSON_VERSION_MINOR;
261	result["version"]["patch"] = NLOHMANN_JSON_VERSION_PATCH;
262
263	#ifdef _WIN32
264	result["platform"] = "win32";
265	#elif defined __linux__
266	result["platform"] = "linux";
267	#elif defined __APPLE__
268	result["platform"] = "apple";
269	#elif defined __unix__
270	result["platform"] = "unix";
271	#else
272	result["platform"] = "unknown";
273	#endif
274
275	#if defined(__ICC) \|\| defined(__INTEL_COMPILER)
276	result["compiler"] = {{"family", "icc"}, {"version", __INTEL_COMPILER}};
277	#elif defined(__clang__)
278	result["compiler"] = {{"family", "clang"}, {"version", __clang_version__}};
279	#elif defined(__GNUC__) \|\| defined(__GNUG__)
280	result["compiler"] = {{"family", "gcc"}, {"version", detail::concat(
281	std::to_string(__GNUC__), `'.'`,
282	std::to_string(__GNUC_MINOR__), `'.'`,
283	std::to_string(__GNUC_PATCHLEVEL__))
284	}
285	};
286	#elif defined(__HP_cc) \|\| defined(__HP_aCC)
287	result["compiler"] = "hp"
288	#elif defined(__IBMCPP__)
289	result["compiler"] = {{"family", "ilecpp"}, {"version", __IBMCPP__}};
290	#elif defined(_MSC_VER)
291	result["compiler"] = {{"family", "msvc"}, {"version", _MSC_VER}};
292	#elif defined(__PGI)
293	result["compiler"] = {{"family", "pgcpp"}, {"version", __PGI}};
294	#elif defined(__SUNPRO_CC)
295	result["compiler"] = {{"family", "sunpro"}, {"version", __SUNPRO_CC}};
296	#else
297	result["compiler"] = {{"family", "unknown"}, {"version", "unknown"}};
298	#endif
299
300	#if defined(_MSVC_LANG)
301	result["compiler"]["c++"] = std::to_string(_MSVC_LANG);
302	#elif defined(__cplusplus)
303	result["compiler"]["c++"] = std::to_string(__cplusplus);
304	#else
305	result["compiler"]["c++"] = "unknown";
306	#endif
307	return result;
308	}
309
310	///////////////////////////
311	// JSON value data types //
312	///////////////////////////
313
314	/// @name JSON value data types
315	/// The data types to store a JSON value. These types are derived from
316	/// the template arguments passed to class @ref basic_json.
317	/// @{
318
319	/// @brief default object key comparator type
320	/// The actual object key comparator type (@ref object_comparator_t) may be
321	/// different.
322	/// @sa https://json.nlohmann.me/api/basic_json/default_object_comparator_t/
323	#if defined(JSON_HAS_CPP_14)
324	// use of transparent comparator avoids unnecessary repeated construction of temporaries
325	// in functions involving lookup by key with types other than object_t::key_type (aka. StringType)
326	using default_object_comparator_t = std::less<>;
327	#else
328	using default_object_comparator_t = std::less<StringType>;
329	#endif
330
331	/// @brief a type for an object
332	/// @sa https://json.nlohmann.me/api/basic_json/object_t/
333	using object_t = ObjectType<StringType,
334	basic_json,
335	default_object_comparator_t,
336	AllocatorType<std::pair<const StringType,
337	basic_json>>>;
338
339	/// @brief a type for an array
340	/// @sa https://json.nlohmann.me/api/basic_json/array_t/
341	using array_t = ArrayType<basic_json, AllocatorType<basic_json>>;
342
343	/// @brief a type for a string
344	/// @sa https://json.nlohmann.me/api/basic_json/string_t/
345	using string_t = StringType;
346
347	/// @brief a type for a boolean
348	/// @sa https://json.nlohmann.me/api/basic_json/boolean_t/
349	using boolean_t = BooleanType;
350
351	/// @brief a type for a number (integer)
352	/// @sa https://json.nlohmann.me/api/basic_json/number_integer_t/
353	using number_integer_t = NumberIntegerType;
354
355	/// @brief a type for a number (unsigned)
356	/// @sa https://json.nlohmann.me/api/basic_json/number_unsigned_t/
357	using number_unsigned_t = NumberUnsignedType;
358
359	/// @brief a type for a number (floating-point)
360	/// @sa https://json.nlohmann.me/api/basic_json/number_float_t/
361	using number_float_t = NumberFloatType;
362
363	/// @brief a type for a packed binary type
364	/// @sa https://json.nlohmann.me/api/basic_json/binary_t/
365	using binary_t = nlohmann::byte_container_with_subtype<BinaryType>;
366
367	/// @brief object key comparator type
368	/// @sa https://json.nlohmann.me/api/basic_json/object_comparator_t/
369	using object_comparator_t = detail::actual_object_comparator_t<basic_json>;
370
371	/// @}
372
373	private:
374
375	/// helper for exception-safe object creation
376	template<typename T, typename... Args>
377	JSON_HEDLEY_RETURNS_NON_NULL
378	static T* create(Args&& ... args)
379	{
380	AllocatorType<T> alloc;
381	using AllocatorTraits = std::allocator_traits<AllocatorType<T>>;
382
383	auto deleter = [&](T * obj)
384	{
385	AllocatorTraits::deallocate(alloc, obj, `1`);
386	};
387	std::unique_ptr<T, decltype(deleter)> obj(AllocatorTraits::allocate(alloc, `1`), deleter);
388	AllocatorTraits::construct(alloc, obj.get(), std::forward<Args>(args)...);
389	JSON_ASSERT(obj != nullptr);
390	return obj.release();
391	}
392
393	////////////////////////
394	// JSON value storage //
395	////////////////////////
396
397	JSON_PRIVATE_UNLESS_TESTED:
398	/!*
399	@brief a JSON value
400
401	The actual storage for a JSON value of the @ref basic_json class. This
402	union combines the different storage types for the JSON value types
403	defined in @ref value_t.
404
405	JSON type \| value_t type \| used type
406	--------- \| --------------- \| ------------------------
407	object \| object \| pointer to @ref object_t
408	array \| array \| pointer to @ref array_t
409	string \| string \| pointer to @ref string_t
410	boolean \| boolean \| @ref boolean_t
411	number \| number_integer \| @ref number_integer_t
412	number \| number_unsigned \| @ref number_unsigned_t
413	number \| number_float \| @ref number_float_t
414	binary \| binary \| pointer to @ref binary_t
415	null \| null \| no value is stored
416
417	@note Variable-length types (objects, arrays, and strings) are stored as
418	pointers. The size of the union should not exceed 64 bits if the default
419	value types are used.
420
421	@since version 1.0.0
422	*/
423	union json_value
424	{
425	/// object (stored with pointer to save storage)
426	object_t* object;
427	/// array (stored with pointer to save storage)
428	array_t* array;
429	/// string (stored with pointer to save storage)
430	string_t* string;
431	/// binary (stored with pointer to save storage)
432	binary_t* binary;
433	/// boolean
434	boolean_t boolean;
435	/// number (integer)
436	number_integer_t number_integer;
437	/// number (unsigned integer)
438	number_unsigned_t number_unsigned;
439	/// number (floating-point)
440	number_float_t number_float;
441
442	/// default constructor (for null values)
443	json_value() = default;
444	/// constructor for booleans
445	json_value(boolean_t v) noexcept : boolean(v) {}
446	/// constructor for numbers (integer)
447	json_value(number_integer_t v) noexcept : number_integer(v) {}
448	/// constructor for numbers (unsigned)
449	json_value(number_unsigned_t v) noexcept : number_unsigned(v) {}
450	/// constructor for numbers (floating-point)
451	json_value(number_float_t v) noexcept : number_float(v) {}
452	/// constructor for empty values of a given type
453	json_value(value_t t)
454	{
455	switch (t)
456	{
457	case value_t::object:
458	{
459	object = create<object_t>();
460	break;
461	}
462
463	case value_t::array:
464	{
465	array = create<array_t>();
466	break;
467	}
468
469	case value_t::string:
470	{
471	string = create<string_t>("");
472	break;
473	}
474
475	case value_t::binary:
476	{
477	binary = create<binary_t>();
478	break;
479	}
480
481	case value_t::boolean:
482	{
483	boolean = static_cast<boolean_t>(false);
484	break;
485	}
486
487	case value_t::number_integer:
488	{
489	number_integer = static_cast<number_integer_t>(`0`);
490	break;
491	}
492
493	case value_t::number_unsigned:
494	{
495	number_unsigned = static_cast<number_unsigned_t>(`0`);
496	break;
497	}
498
499	case value_t::number_float:
500	{
501	number_float = static_cast<number_float_t>(`0.0`);
502	break;
503	}
504
505	case value_t::null:
506	{
507	object = nullptr; // silence warning, see #821
508	break;
509	}
510
511	case value_t::discarded:
512	default:
513	{
514	object = nullptr; // silence warning, see #821
515	if (JSON_HEDLEY_UNLIKELY(t == value_t::null))
516	{
517	JSON_THROW(other_error::create(`500`, "961c151d2e87f2686a955a9be24d316f1362bf21 3.11.3", nullptr)); // LCOV_EXCL_LINE
518	}
519	break;
520	}
521	}
522	}
523
524	/// constructor for strings
525	json_value(const string_t& value) : string(create<string_t>(value)) {}
526
527	/// constructor for rvalue strings
528	json_value(string_t&& value) : string(create<string_t>(std::move(value))) {}
529
530	/// constructor for objects
531	json_value(const object_t& value) : object(create<object_t>(value)) {}
532
533	/// constructor for rvalue objects
534	json_value(object_t&& value) : object(create<object_t>(std::move(value))) {}
535
536	/// constructor for arrays
537	json_value(const array_t& value) : array(create<array_t>(value)) {}
538
539	/// constructor for rvalue arrays
540	json_value(array_t&& value) : array(create<array_t>(std::move(value))) {}
541
542	/// constructor for binary arrays
543	json_value(const typename binary_t::container_type& value) : binary(create<binary_t>(value)) {}
544
545	/// constructor for rvalue binary arrays
546	json_value(typename binary_t::container_type&& value) : binary(create<binary_t>(std::move(value))) {}
547
548	/// constructor for binary arrays (internal type)
549	json_value(const binary_t& value) : binary(create<binary_t>(value)) {}
550
551	/// constructor for rvalue binary arrays (internal type)
552	json_value(binary_t&& value) : binary(create<binary_t>(std::move(value))) {}
553
554	void destroy(value_t t)
555	{
556	if (
557	(t == value_t::object && object == nullptr) \|\|
558	(t == value_t::array && array == nullptr) \|\|
559	(t == value_t::string && string == nullptr) \|\|
560	(t == value_t::binary && binary == nullptr)
561	)
562	{
563	//not initialized (e.g. due to exception in the ctor)
564	return;
565	}
566	if (t == value_t::array \|\| t == value_t::object)
567	{
568	// flatten the current json_value to a heap-allocated stack
569	std::vector<basic_json> stack;
570
571	// move the top-level items to stack
572	if (t == value_t::array)
573	{
574	stack.reserve(array->size());
575	std::move(array->begin(), array->end(), std::back_inserter(stack));
576	}
577	else
578	{
579	stack.reserve(object->size());
580	for (auto&& it : *object)
581	{
582	stack.push_back(std::move(it.second));
583	}
584	}
585
586	while (!stack.empty())
587	{
588	// move the last item to local variable to be processed
589	basic_json current_item(std::move(stack.back()));
590	stack.pop_back();
591
592	// if current_item is array/object, move
593	// its children to the stack to be processed later
594	if (current_item.is_array())
595	{
596	std::move(current_item.m_data.m_value.array->begin(), current_item.m_data.m_value.array->end(), std::back_inserter(stack));
597
598	current_item.m_data.m_value.array->clear();
599	}
600	else if (current_item.is_object())
601	{
602	for (auto&& it : *current_item.m_data.m_value.object)
603	{
604	stack.push_back(std::move(it.second));
605	}
606
607	current_item.m_data.m_value.object->clear();
608	}
609
610	// it's now safe that current_item get destructed
611	// since it doesn't have any children
612	}
613	}
614
615	switch (t)
616	{
617	case value_t::object:
618	{
619	AllocatorType<object_t> alloc;
620	std::allocator_traits<decltype(alloc)>::destroy(alloc, object);
621	std::allocator_traits<decltype(alloc)>::deallocate(alloc, object, `1`);
622	break;
623	}
624
625	case value_t::array:
626	{
627	AllocatorType<array_t> alloc;
628	std::allocator_traits<decltype(alloc)>::destroy(alloc, array);
629	std::allocator_traits<decltype(alloc)>::deallocate(alloc, array, `1`);
630	break;
631	}
632
633	case value_t::string:
634	{
635	AllocatorType<string_t> alloc;
636	std::allocator_traits<decltype(alloc)>::destroy(alloc, string);
637	std::allocator_traits<decltype(alloc)>::deallocate(alloc, string, `1`);
638	break;
639	}
640
641	case value_t::binary:
642	{
643	AllocatorType<binary_t> alloc;
644	std::allocator_traits<decltype(alloc)>::destroy(alloc, binary);
645	std::allocator_traits<decltype(alloc)>::deallocate(alloc, binary, `1`);
646	break;
647	}
648
649	case value_t::null:
650	case value_t::boolean:
651	case value_t::number_integer:
652	case value_t::number_unsigned:
653	case value_t::number_float:
654	case value_t::discarded:
655	default:
656	{
657	break;
658	}
659	}
660	}
661	};
662
663	private:
664	/!*
665	@brief checks the class invariants
666
667	This function asserts the class invariants. It needs to be called at the
668	end of every constructor to make sure that created objects respect the
669	invariant. Furthermore, it has to be called each time the type of a JSON
670	value is changed, because the invariant expresses a relationship between
671	@a m_type and @a m_value.
672
673	Furthermore, the parent relation is checked for arrays and objects: If
674	@a check_parents true and the value is an array or object, then the
675	container's elements must have the current value as parent.
676
677	@param[in] check_parents whether the parent relation should be checked.
678	The value is true by default and should only be set to false
679	during destruction of objects when the invariant does not
680	need to hold.
681	*/
682	void assert_invariant(bool check_parents = true) const noexcept
683	{
684	JSON_ASSERT(m_data.m_type != value_t::object \|\| m_data.m_value.object != nullptr);
685	JSON_ASSERT(m_data.m_type != value_t::array \|\| m_data.m_value.array != nullptr);
686	JSON_ASSERT(m_data.m_type != value_t::string \|\| m_data.m_value.string != nullptr);
687	JSON_ASSERT(m_data.m_type != value_t::binary \|\| m_data.m_value.binary != nullptr);
688
689	#if JSON_DIAGNOSTICS
690	JSON_TRY
691	{
692	// cppcheck-suppress assertWithSideEffect
693	JSON_ASSERT(!check_parents \|\| !is_structured() \|\| std::all_of(begin(), end(), [this](const basic_json & j)
694	{
695	return j.m_parent == this;
696	}));
697	}
698	JSON_CATCH(...) {} // LCOV_EXCL_LINE
699	#endif
700	static_cast<void>(check_parents);
701	}
702
703	void set_parents()
704	{
705	#if JSON_DIAGNOSTICS
706	switch (m_data.m_type)
707	{
708	case value_t::array:
709	{
710	for (auto& element : *m_data.m_value.array)
711	{
712	element.m_parent = this;
713	}
714	break;
715	}
716
717	case value_t::object:
718	{
719	for (auto& element : *m_data.m_value.object)
720	{
721	element.second.m_parent = this;
722	}
723	break;
724	}
725
726	case value_t::null:
727	case value_t::string:
728	case value_t::boolean:
729	case value_t::number_integer:
730	case value_t::number_unsigned:
731	case value_t::number_float:
732	case value_t::binary:
733	case value_t::discarded:
734	default:
735	break;
736	}
737	#endif
738	}
739
740	iterator set_parents(iterator it, typename iterator::difference_type count_set_parents)
741	{
742	#if JSON_DIAGNOSTICS
743	for (typename iterator::difference_type i = `0`; i < count_set_parents; ++i)
744	{
745	(it + i)->m_parent = this;
746	}
747	#else
748	static_cast<void>(count_set_parents);
749	#endif
750	return it;
751	}
752
753	reference set_parent(reference j, std::size_t old_capacity = static_cast<std::size_t>(-`1`))
754	{
755	#if JSON_DIAGNOSTICS
756	if (old_capacity != static_cast<std::size_t>(-`1`))
757	{
758	// see https://github.com/nlohmann/json/issues/2838
759	JSON_ASSERT(type() == value_t::array);
760	if (JSON_HEDLEY_UNLIKELY(m_data.m_value.array->capacity() != old_capacity))
761	{
762	// capacity has changed: update all parents
763	set_parents();
764	return j;
765	}
766	}
767
768	// ordered_json uses a vector internally, so pointers could have
769	// been invalidated; see https://github.com/nlohmann/json/issues/2962
770	#ifdef JSON_HEDLEY_MSVC_VERSION
771	#pragma warning(push )
772	#pragma warning(disable : 4127) // ignore warning to replace if with if constexpr
773	#endif
774	if (detail::is_ordered_map<object_t>::value)
775	{
776	set_parents();
777	return j;
778	}
779	#ifdef JSON_HEDLEY_MSVC_VERSION
780	#pragma warning( pop )
781	#endif
782
783	j.m_parent = this;
784	#else
785	static_cast<void>(j);
786	static_cast<void>(old_capacity);
787	#endif
788	return j;
789	}
790
791	public:
792	//////////////////////////
793	// JSON parser callback //
794	//////////////////////////
795
796	/// @brief parser event types
797	/// @sa https://json.nlohmann.me/api/basic_json/parse_event_t/
798	using parse_event_t = detail::parse_event_t;
799
800	/// @brief per-element parser callback type
801	/// @sa https://json.nlohmann.me/api/basic_json/parser_callback_t/
802	using parser_callback_t = detail::parser_callback_t<basic_json>;
803
804	//////////////////
805	// constructors //
806	//////////////////
807
808	/// @name constructors and destructors
809	/// Constructors of class @ref basic_json, copy/move constructor, copy
810	/// assignment, static functions creating objects, and the destructor.
811	/// @{
812
813	/// @brief create an empty value with a given type
814	/// @sa https://json.nlohmann.me/api/basic_json/basic_json/
815	basic_json(const value_t v)
816	: m_data(v)
817	{
818	assert_invariant();
819	}
820
821	/// @brief create a null object
822	/// @sa https://json.nlohmann.me/api/basic_json/basic_json/
823	basic_json(std::nullptr_t = nullptr) noexcept // NOLINT(bugprone-exception-escape)
824	: basic_json(value_t::null)
825	{
826	assert_invariant();
827	}
828
829	/// @brief create a JSON value from compatible types
830	/// @sa https://json.nlohmann.me/api/basic_json/basic_json/
831	template < typename CompatibleType,
832	typename U = detail::uncvref_t<CompatibleType>,
833	detail::enable_if_t <
834	!detail::is_basic_json<U>::value && detail::is_compatible_type<basic_json_t, U>::value, int > = `0` >
835	basic_json(CompatibleType && val) noexcept(noexcept( // NOLINT(bugprone-forwarding-reference-overload,bugprone-exception-escape)
836	JSONSerializer<U>::to_json(std::declval<basic_json_t&>(),
837	std::forward<CompatibleType>(val))))
838	{
839	JSONSerializer<U>::to_json(*this, std::forward<CompatibleType>(val));
840	set_parents();
841	assert_invariant();
842	}
843
844	/// @brief create a JSON value from an existing one
845	/// @sa https://json.nlohmann.me/api/basic_json/basic_json/
846	template < typename BasicJsonType,
847	detail::enable_if_t <
848	detail::is_basic_json<BasicJsonType>::value&& !std::is_same<basic_json, BasicJsonType>::value, int > = `0` >
849	basic_json(const BasicJsonType& val)
850	{
851	using other_boolean_t = typename BasicJsonType::boolean_t;
852	using other_number_float_t = typename BasicJsonType::number_float_t;
853	using other_number_integer_t = typename BasicJsonType::number_integer_t;
854	using other_number_unsigned_t = typename BasicJsonType::number_unsigned_t;
855	using other_string_t = typename BasicJsonType::string_t;
856	using other_object_t = typename BasicJsonType::object_t;
857	using other_array_t = typename BasicJsonType::array_t;
858	using other_binary_t = typename BasicJsonType::binary_t;
859
860	switch (val.type())
861	{
862	case value_t::boolean:
863	JSONSerializer<other_boolean_t>::to_json(*this, val.template get<other_boolean_t>());
864	break;
865	case value_t::number_float:
866	JSONSerializer<other_number_float_t>::to_json(*this, val.template get<other_number_float_t>());
867	break;
868	case value_t::number_integer:
869	JSONSerializer<other_number_integer_t>::to_json(*this, val.template get<other_number_integer_t>());
870	break;
871	case value_t::number_unsigned:
872	JSONSerializer<other_number_unsigned_t>::to_json(*this, val.template get<other_number_unsigned_t>());
873	break;
874	case value_t::string:
875	JSONSerializer<other_string_t>::to_json(*this, val.template get_ref<const other_string_t&>());
876	break;
877	case value_t::object:
878	JSONSerializer<other_object_t>::to_json(*this, val.template get_ref<const other_object_t&>());
879	break;
880	case value_t::array:
881	JSONSerializer<other_array_t>::to_json(*this, val.template get_ref<const other_array_t&>());
882	break;
883	case value_t::binary:
884	JSONSerializer<other_binary_t>::to_json(*this, val.template get_ref<const other_binary_t&>());
885	break;
886	case value_t::null:
887	*this = nullptr;
888	break;
889	case value_t::discarded:
890	m_data.m_type = value_t::discarded;
891	break;
892	default: // LCOV_EXCL_LINE
893	JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert) LCOV_EXCL_LINE
894	}
895	JSON_ASSERT(m_data.m_type == val.type());
896	set_parents();
897	assert_invariant();
898	}
899
900	/// @brief create a container (array or object) from an initializer list
901	/// @sa https://json.nlohmann.me/api/basic_json/basic_json/
902	basic_json(initializer_list_t init,
903	bool type_deduction = true,
904	value_t manual_type = value_t::array)
905	{
906	// check if each element is an array with two elements whose first
907	// element is a string
908	bool is_an_object = std::all_of(init.begin(), init.end(),
909	[](const detail::json_ref<basic_json>& element_ref)
910	{
911	// The cast is to ensure op[size_type] is called, bearing in mind size_type may not be int;
912	// (many string types can be constructed from 0 via its null-pointer guise, so we get a
913	// broken call to op[key_type], the wrong semantics and a 4804 warning on Windows)
914	return element_ref->is_array() && element_ref->size() == `2` && (element_ref)[static_cast*<size_type>(`0`)].is_string();
915	});
916
917	// adjust type if type deduction is not wanted
918	if (!type_deduction)
919	{
920	// if array is wanted, do not create an object though possible
921	if (manual_type == value_t::array)
922	{
923	is_an_object = false;
924	}
925
926	// if object is wanted but impossible, throw an exception
927	if (JSON_HEDLEY_UNLIKELY(manual_type == value_t::object && !is_an_object))
928	{
929	JSON_THROW(type_error::create(`301`, "cannot create object from initializer list", nullptr));
930	}
931	}
932
933	if (is_an_object)
934	{
935	// the initializer list is a list of pairs -> create object
936	m_data.m_type = value_t::object;
937	m_data.m_value = value_t::object;
938
939	for (auto& element_ref : init)
940	{
941	auto element = element_ref.moved_or_copied();
942	m_data.m_value.object->emplace(
943	std::move(((element.m_data.m_value.array)[`0`].m_data.m_value.string)),
944	std::move((*element.m_data.m_value.array)[`1`]));
945	}
946	}
947	else
948	{
949	// the initializer list describes an array -> create array
950	m_data.m_type = value_t::array;
951	m_data.m_value.array = create<array_t>(init.begin(), init.end());
952	}
953
954	set_parents();
955	assert_invariant();
956	}
957
958	/// @brief explicitly create a binary array (without subtype)
959	/// @sa https://json.nlohmann.me/api/basic_json/binary/
960	JSON_HEDLEY_WARN_UNUSED_RESULT
961	static basic_json binary(const typename binary_t::container_type& init)
962	{
963	auto res = basic_json();
964	res.m_data.m_type = value_t::binary;
965	res.m_data.m_value = init;
966	return res;
967	}
968
969	/// @brief explicitly create a binary array (with subtype)
970	/// @sa https://json.nlohmann.me/api/basic_json/binary/
971	JSON_HEDLEY_WARN_UNUSED_RESULT
972	static basic_json binary(const typename binary_t::container_type& init, typename binary_t::subtype_type subtype)
973	{
974	auto res = basic_json();
975	res.m_data.m_type = value_t::binary;
976	res.m_data.m_value = binary_t(init, subtype);
977	return res;
978	}
979
980	/// @brief explicitly create a binary array
981	/// @sa https://json.nlohmann.me/api/basic_json/binary/
982	JSON_HEDLEY_WARN_UNUSED_RESULT
983	static basic_json binary(typename binary_t::container_type&& init)
984	{
985	auto res = basic_json();
986	res.m_data.m_type = value_t::binary;
987	res.m_data.m_value = std::move(init);
988	return res;
989	}
990
991	/// @brief explicitly create a binary array (with subtype)
992	/// @sa https://json.nlohmann.me/api/basic_json/binary/
993	JSON_HEDLEY_WARN_UNUSED_RESULT
994	static basic_json binary(typename binary_t::container_type&& init, typename binary_t::subtype_type subtype)
995	{
996	auto res = basic_json();
997	res.m_data.m_type = value_t::binary;
998	res.m_data.m_value = binary_t(std::move(init), subtype);
999	return res;
1000	}
1001
1002	/// @brief explicitly create an array from an initializer list
1003	/// @sa https://json.nlohmann.me/api/basic_json/array/
1004	JSON_HEDLEY_WARN_UNUSED_RESULT
1005	static basic_json array(initializer_list_t init = {})
1006	{
1007	return basic_json(init, false, value_t::array);
1008	}
1009
1010	/// @brief explicitly create an object from an initializer list
1011	/// @sa https://json.nlohmann.me/api/basic_json/object/
1012	JSON_HEDLEY_WARN_UNUSED_RESULT
1013	static basic_json object(initializer_list_t init = {})
1014	{
1015	return basic_json(init, false, value_t::object);
1016	}
1017
1018	/// @brief construct an array with count copies of given value
1019	/// @sa https://json.nlohmann.me/api/basic_json/basic_json/
1020	basic_json(size_type cnt, const basic_json& val):
1021	m_data{cnt, val}
1022	{
1023	set_parents();
1024	assert_invariant();
1025	}
1026
1027	/// @brief construct a JSON container given an iterator range
1028	/// @sa https://json.nlohmann.me/api/basic_json/basic_json/
1029	template < class InputIT, typename std::enable_if <
1030	std::is_same<InputIT, typename basic_json_t::iterator>::value \|\|
1031	std::is_same<InputIT, typename basic_json_t::const_iterator>::value, int >::type = `0` >
1032	basic_json(InputIT first, InputIT last)
1033	{
1034	JSON_ASSERT(first.m_object != nullptr);
1035	JSON_ASSERT(last.m_object != nullptr);
1036
1037	// make sure iterator fits the current value
1038	if (JSON_HEDLEY_UNLIKELY(first.m_object != last.m_object))
1039	{
1040	JSON_THROW(invalid_iterator::create(`201`, "iterators are not compatible", nullptr));
1041	}
1042
1043	// copy type from first iterator
1044	m_data.m_type = first.m_object->m_data.m_type;
1045
1046	// check if iterator range is complete for primitive values
1047	switch (m_data.m_type)
1048	{
1049	case value_t::boolean:
1050	case value_t::number_float:
1051	case value_t::number_integer:
1052	case value_t::number_unsigned:
1053	case value_t::string:
1054	{
1055	if (JSON_HEDLEY_UNLIKELY(!first.m_it.primitive_iterator.is_begin()
1056	\|\| !last.m_it.primitive_iterator.is_end()))
1057	{
1058	JSON_THROW(invalid_iterator::create(`204`, "iterators out of range", first.m_object));
1059	}
1060	break;
1061	}
1062
1063	case value_t::null:
1064	case value_t::object:
1065	case value_t::array:
1066	case value_t::binary:
1067	case value_t::discarded:
1068	default:
1069	break;
1070	}
1071
1072	switch (m_data.m_type)
1073	{
1074	case value_t::number_integer:
1075	{
1076	m_data.m_value.number_integer = first.m_object->m_data.m_value.number_integer;
1077	break;
1078	}
1079
1080	case value_t::number_unsigned:
1081	{
1082	m_data.m_value.number_unsigned = first.m_object->m_data.m_value.number_unsigned;
1083	break;
1084	}
1085
1086	case value_t::number_float:
1087	{
1088	m_data.m_value.number_float = first.m_object->m_data.m_value.number_float;
1089	break;
1090	}
1091
1092	case value_t::boolean:
1093	{
1094	m_data.m_value.boolean = first.m_object->m_data.m_value.boolean;
1095	break;
1096	}
1097
1098	case value_t::string:
1099	{
1100	m_data.m_value = *first.m_object->m_data.m_value.string;
1101	break;
1102	}
1103
1104	case value_t::object:
1105	{
1106	m_data.m_value.object = create<object_t>(first.m_it.object_iterator,
1107	last.m_it.object_iterator);
1108	break;
1109	}
1110
1111	case value_t::array:
1112	{
1113	m_data.m_value.array = create<array_t>(first.m_it.array_iterator,
1114	last.m_it.array_iterator);
1115	break;
1116	}
1117
1118	case value_t::binary:
1119	{
1120	m_data.m_value = *first.m_object->m_data.m_value.binary;
1121	break;
1122	}
1123
1124	case value_t::null:
1125	case value_t::discarded:
1126	default:
1127	JSON_THROW(invalid_iterator::create(`206`, detail::concat("cannot construct with iterators from ", first.m_object->type_name()), first.m_object));
1128	}
1129
1130	set_parents();
1131	assert_invariant();
1132	}
1133
1134	///////////////////////////////////////
1135	// other constructors and destructor //
1136	///////////////////////////////////////
1137
1138	template<typename JsonRef,
1139	detail::enable_if_t<detail::conjunction<detail::is_json_ref<JsonRef>,
1140	std::is_same<typename JsonRef::value_type, basic_json>>::value, int> = `0` >
1141	basic_json(const JsonRef& ref) : basic_json(ref.moved_or_copied()) {}
1142
1143	/// @brief copy constructor
1144	/// @sa https://json.nlohmann.me/api/basic_json/basic_json/
1145	basic_json(const basic_json& other)
1146	: json_base_class_t(other)
1147	{
1148	m_data.m_type = other.m_data.m_type;
1149	// check of passed value is valid
1150	other.assert_invariant();
1151
1152	switch (m_data.m_type)
1153	{
1154	case value_t::object:
1155	{
1156	m_data.m_value = *other.m_data.m_value.object;
1157	break;
1158	}
1159
1160	case value_t::array:
1161	{
1162	m_data.m_value = *other.m_data.m_value.array;
1163	break;
1164	}
1165
1166	case value_t::string:
1167	{
1168	m_data.m_value = *other.m_data.m_value.string;
1169	break;
1170	}
1171
1172	case value_t::boolean:
1173	{
1174	m_data.m_value = other.m_data.m_value.boolean;
1175	break;
1176	}
1177
1178	case value_t::number_integer:
1179	{
1180	m_data.m_value = other.m_data.m_value.number_integer;
1181	break;
1182	}
1183
1184	case value_t::number_unsigned:
1185	{
1186	m_data.m_value = other.m_data.m_value.number_unsigned;
1187	break;
1188	}
1189
1190	case value_t::number_float:
1191	{
1192	m_data.m_value = other.m_data.m_value.number_float;
1193	break;
1194	}
1195
1196	case value_t::binary:
1197	{
1198	m_data.m_value = *other.m_data.m_value.binary;
1199	break;
1200	}
1201
1202	case value_t::null:
1203	case value_t::discarded:
1204	default:
1205	break;
1206	}
1207
1208	set_parents();
1209	assert_invariant();
1210	}
1211
1212	/// @brief move constructor
1213	/// @sa https://json.nlohmann.me/api/basic_json/basic_json/
1214	basic_json(basic_json&& other) noexcept
1215	: json_base_class_t(std::forward<json_base_class_t>(other)),
1216	m_data(std::move(other.m_data))
1217	{
1218	// check that passed value is valid
1219	other.assert_invariant(false);
1220
1221	// invalidate payload
1222	other.m_data.m_type = value_t::null;
1223	other.m_data.m_value = {};
1224
1225	set_parents();
1226	assert_invariant();
1227	}
1228
1229	/// @brief copy assignment
1230	/// @sa https://json.nlohmann.me/api/basic_json/operator=/
1231	basic_json& operator=(basic_json other) noexcept (
1232	std::is_nothrow_move_constructible<value_t>::value&&
1233	std::is_nothrow_move_assignable<value_t>::value&&
1234	std::is_nothrow_move_constructible<json_value>::value&&
1235	std::is_nothrow_move_assignable<json_value>::value&&
1236	std::is_nothrow_move_assignable<json_base_class_t>::value
1237	)
1238	{
1239	// check that passed value is valid
1240	other.assert_invariant();
1241
1242	using std::swap;
1243	swap(m_data.m_type, other.m_data.m_type);
1244	swap(m_data.m_value, other.m_data.m_value);
1245	json_base_class_t::operator=(std::move(other));
1246
1247	set_parents();
1248	assert_invariant();
1249	return *this;
1250	}
1251
1252	/// @brief destructor
1253	/// @sa https://json.nlohmann.me/api/basic_json/~basic_json/
1254	~basic_json() noexcept
1255	{
1256	assert_invariant(check_parents: false);
1257	}
1258
1259	/// @}
1260
1261	public:
1262	///////////////////////
1263	// object inspection //
1264	///////////////////////
1265
1266	/// @name object inspection
1267	/// Functions to inspect the type of a JSON value.
1268	/// @{
1269
1270	/// @brief serialization
1271	/// @sa https://json.nlohmann.me/api/basic_json/dump/
1272	string_t dump(const int indent = -`1`,
1273	const char indent_char = `' '`,
1274	const bool ensure_ascii = false,
1275	const error_handler_t error_handler = error_handler_t::strict) const
1276	{
1277	string_t result;
1278	serializer s(detail::output_adapter<char, string_t>(result), indent_char, error_handler);
1279
1280	if (indent >= `0`)
1281	{
1282	s.dump(*this, true, ensure_ascii, static_cast<unsigned int>(indent));
1283	}
1284	else
1285	{
1286	s.dump(*this, false, ensure_ascii, `0`);
1287	}
1288
1289	return result;
1290	}
1291
1292	/// @brief return the type of the JSON value (explicit)
1293	/// @sa https://json.nlohmann.me/api/basic_json/type/
1294	constexpr value_t type() const noexcept
1295	{
1296	return m_data.m_type;
1297	}
1298
1299	/// @brief return whether type is primitive
1300	/// @sa https://json.nlohmann.me/api/basic_json/is_primitive/
1301	constexpr bool is_primitive() const noexcept
1302	{
1303	return is_null() \|\| is_string() \|\| is_boolean() \|\| is_number() \|\| is_binary();
1304	}
1305
1306	/// @brief return whether type is structured
1307	/// @sa https://json.nlohmann.me/api/basic_json/is_structured/
1308	constexpr bool is_structured() const noexcept
1309	{
1310	return is_array() \|\| is_object();
1311	}
1312
1313	/// @brief return whether value is null
1314	/// @sa https://json.nlohmann.me/api/basic_json/is_null/
1315	constexpr bool is_null() const noexcept
1316	{
1317	return m_data.m_type == value_t::null;
1318	}
1319
1320	/// @brief return whether value is a boolean
1321	/// @sa https://json.nlohmann.me/api/basic_json/is_boolean/
1322	constexpr bool is_boolean() const noexcept
1323	{
1324	return m_data.m_type == value_t::boolean;
1325	}
1326
1327	/// @brief return whether value is a number
1328	/// @sa https://json.nlohmann.me/api/basic_json/is_number/
1329	constexpr bool is_number() const noexcept
1330	{
1331	return is_number_integer() \|\| is_number_float();
1332	}
1333
1334	/// @brief return whether value is an integer number
1335	/// @sa https://json.nlohmann.me/api/basic_json/is_number_integer/
1336	constexpr bool is_number_integer() const noexcept
1337	{
1338	return m_data.m_type == value_t::number_integer \|\| m_data.m_type == value_t::number_unsigned;
1339	}
1340
1341	/// @brief return whether value is an unsigned integer number
1342	/// @sa https://json.nlohmann.me/api/basic_json/is_number_unsigned/
1343	constexpr bool is_number_unsigned() const noexcept
1344	{
1345	return m_data.m_type == value_t::number_unsigned;
1346	}
1347
1348	/// @brief return whether value is a floating-point number
1349	/// @sa https://json.nlohmann.me/api/basic_json/is_number_float/
1350	constexpr bool is_number_float() const noexcept
1351	{
1352	return m_data.m_type == value_t::number_float;
1353	}
1354
1355	/// @brief return whether value is an object
1356	/// @sa https://json.nlohmann.me/api/basic_json/is_object/
1357	constexpr bool is_object() const noexcept
1358	{
1359	return m_data.m_type == value_t::object;
1360	}
1361
1362	/// @brief return whether value is an array
1363	/// @sa https://json.nlohmann.me/api/basic_json/is_array/
1364	constexpr bool is_array() const noexcept
1365	{
1366	return m_data.m_type == value_t::array;
1367	}
1368
1369	/// @brief return whether value is a string
1370	/// @sa https://json.nlohmann.me/api/basic_json/is_string/
1371	constexpr bool is_string() const noexcept
1372	{
1373	return m_data.m_type == value_t::string;
1374	}
1375
1376	/// @brief return whether value is a binary array
1377	/// @sa https://json.nlohmann.me/api/basic_json/is_binary/
1378	constexpr bool is_binary() const noexcept
1379	{
1380	return m_data.m_type == value_t::binary;
1381	}
1382
1383	/// @brief return whether value is discarded
1384	/// @sa https://json.nlohmann.me/api/basic_json/is_discarded/
1385	constexpr bool is_discarded() const noexcept
1386	{
1387	return m_data.m_type == value_t::discarded;
1388	}
1389
1390	/// @brief return the type of the JSON value (implicit)
1391	/// @sa https://json.nlohmann.me/api/basic_json/operator_value_t/
1392	constexpr operator value_t() const noexcept
1393	{
1394	return m_data.m_type;
1395	}
1396
1397	/// @}
1398
1399	private:
1400	//////////////////
1401	// value access //
1402	//////////////////
1403
1404	/// get a boolean (explicit)
1405	boolean_t get_impl(boolean_t* /unused/) const
1406	{
1407	if (JSON_HEDLEY_LIKELY(is_boolean()))
1408	{
1409	return m_data.m_value.boolean;
1410	}
1411
1412	JSON_THROW(type_error::create(`302`, detail::concat("type must be boolean, but is ", type_name()), this));
1413	}
1414
1415	/// get a pointer to the value (object)
1416	object_t* get_impl_ptr(object_t* /unused/) noexcept
1417	{
1418	return is_object() ? m_data.m_value.object : nullptr;
1419	}
1420
1421	/// get a pointer to the value (object)
1422	constexpr const object_t* get_impl_ptr(const object_t* /unused/) const noexcept
1423	{
1424	return is_object() ? m_data.m_value.object : nullptr;
1425	}
1426
1427	/// get a pointer to the value (array)
1428	array_t* get_impl_ptr(array_t* /unused/) noexcept
1429	{
1430	return is_array() ? m_data.m_value.array : nullptr;
1431	}
1432
1433	/// get a pointer to the value (array)
1434	constexpr const array_t* get_impl_ptr(const array_t* /unused/) const noexcept
1435	{
1436	return is_array() ? m_data.m_value.array : nullptr;
1437	}
1438
1439	/// get a pointer to the value (string)
1440	string_t* get_impl_ptr(string_t* /unused/) noexcept
1441	{
1442	return is_string() ? m_data.m_value.string : nullptr;
1443	}
1444
1445	/// get a pointer to the value (string)
1446	constexpr const string_t* get_impl_ptr(const string_t* /unused/) const noexcept
1447	{
1448	return is_string() ? m_data.m_value.string : nullptr;
1449	}
1450
1451	/// get a pointer to the value (boolean)
1452	boolean_t* get_impl_ptr(boolean_t* /unused/) noexcept
1453	{
1454	return is_boolean() ? &m_data.m_value.boolean : nullptr;
1455	}
1456
1457	/// get a pointer to the value (boolean)
1458	constexpr const boolean_t* get_impl_ptr(const boolean_t* /unused/) const noexcept
1459	{
1460	return is_boolean() ? &m_data.m_value.boolean : nullptr;
1461	}
1462
1463	/// get a pointer to the value (integer number)
1464	number_integer_t* get_impl_ptr(number_integer_t* /unused/) noexcept
1465	{
1466	return is_number_integer() ? &m_data.m_value.number_integer : nullptr;
1467	}
1468
1469	/// get a pointer to the value (integer number)
1470	constexpr const number_integer_t* get_impl_ptr(const number_integer_t* /unused/) const noexcept
1471	{
1472	return is_number_integer() ? &m_data.m_value.number_integer : nullptr;
1473	}
1474
1475	/// get a pointer to the value (unsigned number)
1476	number_unsigned_t* get_impl_ptr(number_unsigned_t* /unused/) noexcept
1477	{
1478	return is_number_unsigned() ? &m_data.m_value.number_unsigned : nullptr;
1479	}
1480
1481	/// get a pointer to the value (unsigned number)
1482	constexpr const number_unsigned_t* get_impl_ptr(const number_unsigned_t* /unused/) const noexcept
1483	{
1484	return is_number_unsigned() ? &m_data.m_value.number_unsigned : nullptr;
1485	}
1486
1487	/// get a pointer to the value (floating-point number)
1488	number_float_t* get_impl_ptr(number_float_t* /unused/) noexcept
1489	{
1490	return is_number_float() ? &m_data.m_value.number_float : nullptr;
1491	}
1492
1493	/// get a pointer to the value (floating-point number)
1494	constexpr const number_float_t* get_impl_ptr(const number_float_t* /unused/) const noexcept
1495	{
1496	return is_number_float() ? &m_data.m_value.number_float : nullptr;
1497	}
1498
1499	/// get a pointer to the value (binary)
1500	binary_t* get_impl_ptr(binary_t* /unused/) noexcept
1501	{
1502	return is_binary() ? m_data.m_value.binary : nullptr;
1503	}
1504
1505	/// get a pointer to the value (binary)
1506	constexpr const binary_t* get_impl_ptr(const binary_t* /unused/) const noexcept
1507	{
1508	return is_binary() ? m_data.m_value.binary : nullptr;
1509	}
1510
1511	/!*
1512	@brief helper function to implement get_ref()
1513
1514	This function helps to implement get_ref() without code duplication for
1515	const and non-const overloads
1516
1517	@tparam ThisType will be deduced as `basic_json` or `const basic_json`
1518
1519	@throw type_error.303 if ReferenceType does not match underlying value
1520	type of the current JSON
1521	*/
1522	template<typename ReferenceType, typename ThisType>
1523	static ReferenceType get_ref_impl(ThisType& obj)
1524	{
1525	// delegate the call to get_ptr<>()
1526	auto* ptr = obj.template get_ptr<typename std::add_pointer<ReferenceType>::type>();
1527
1528	if (JSON_HEDLEY_LIKELY(ptr != nullptr))
1529	{
1530	return *ptr;
1531	}
1532
1533	JSON_THROW(type_error::create(`303`, detail::concat("incompatible ReferenceType for get_ref, actual type is ", obj.type_name()), &obj));
1534	}
1535
1536	public:
1537	/// @name value access
1538	/// Direct access to the stored value of a JSON value.
1539	/// @{
1540
1541	/// @brief get a pointer value (implicit)
1542	/// @sa https://json.nlohmann.me/api/basic_json/get_ptr/
1543	template<typename PointerType, typename std::enable_if<
1544	std::is_pointer<PointerType>::value, int>::type = `0`>
1545	auto get_ptr() noexcept -> decltype(std::declval<basic_json_t&>().get_impl_ptr(std::declval<PointerType>()))
1546	{
1547	// delegate the call to get_impl_ptr<>()
1548	return get_impl_ptr(static_cast<PointerType>(nullptr));
1549	}
1550
1551	/// @brief get a pointer value (implicit)
1552	/// @sa https://json.nlohmann.me/api/basic_json/get_ptr/
1553	template < typename PointerType, typename std::enable_if <
1554	std::is_pointer<PointerType>::value&&
1555	std::is_const<typename std::remove_pointer<PointerType>::type>::value, int >::type = `0` >
1556	constexpr auto get_ptr() const noexcept -> decltype(std::declval<const basic_json_t&>().get_impl_ptr(std::declval<PointerType>()))
1557	{
1558	// delegate the call to get_impl_ptr<>() const
1559	return get_impl_ptr(static_cast<PointerType>(nullptr));
1560	}
1561
1562	private:
1563	/!*
1564	@brief get a value (explicit)
1565
1566	Explicit type conversion between the JSON value and a compatible value
1567	which is [CopyConstructible](https://en.cppreference.com/w/cpp/named_req/CopyConstructible)
1568	and [DefaultConstructible](https://en.cppreference.com/w/cpp/named_req/DefaultConstructible).
1569	The value is converted by calling the @ref json_serializer<ValueType>
1570	`from_json()` method.
1571
1572	The function is equivalent to executing
1573	@code {.cpp}
1574	ValueType ret;
1575	JSONSerializer<ValueType>::from_json(this, ret);*
1576	return ret;
1577	@endcode
1578
1579	This overloads is chosen if:
1580	- @a ValueType is not @ref basic_json,
1581	- @ref json_serializer<ValueType> has a `from_json()` method of the form
1582	`void from_json(const basic_json&, ValueType&)`, and
1583	- @ref json_serializer<ValueType> does not have a `from_json()` method of
1584	the form `ValueType from_json(const basic_json&)`
1585
1586	@tparam ValueType the returned value type
1587
1588	@return copy of the JSON value, converted to @a ValueType
1589
1590	@throw what @ref json_serializer<ValueType> `from_json()` method throws
1591
1592	@liveexample{The example below shows several conversions from JSON values
1593	to other types. There a few things to note: (1) Floating-point numbers can
1594	be converted to integers\, (2) A JSON array can be converted to a standard
1595	`std::vector<short>`\, (3) A JSON object can be converted to C++
1596	associative containers such as `std::unordered_map<std::string\,
1597	json>`.,get__ValueType_const}
1598
1599	@since version 2.1.0
1600	*/
1601	template < typename ValueType,
1602	detail::enable_if_t <
1603	detail::is_default_constructible<ValueType>::value&&
1604	detail::has_from_json<basic_json_t, ValueType>::value,
1605	int > = `0` >
1606	ValueType get_impl(detail::priority_tag<`0`> /unused/) const noexcept(noexcept(
1607	JSONSerializer<ValueType>::from_json(std::declval<const basic_json_t&>(), std::declval<ValueType&>())))
1608	{
1609	auto ret = ValueType();
1610	JSONSerializer<ValueType>::from_json(*this, ret);
1611	return ret;
1612	}
1613
1614	/!*
1615	@brief get a value (explicit); special case
1616
1617	Explicit type conversion between the JSON value and a compatible value
1618	which is not* [CopyConstructible](https://en.cppreference.com/w/cpp/named_req/CopyConstructible)*
1619	and not* [DefaultConstructible](https://en.cppreference.com/w/cpp/named_req/DefaultConstructible).*
1620	The value is converted by calling the @ref json_serializer<ValueType>
1621	`from_json()` method.
1622
1623	The function is equivalent to executing
1624	@code {.cpp}
1625	return JSONSerializer<ValueType>::from_json(this);*
1626	@endcode
1627
1628	This overloads is chosen if:
1629	- @a ValueType is not @ref basic_json and
1630	- @ref json_serializer<ValueType> has a `from_json()` method of the form
1631	`ValueType from_json(const basic_json&)`
1632
1633	@note If @ref json_serializer<ValueType> has both overloads of
1634	`from_json()`, this one is chosen.
1635
1636	@tparam ValueType the returned value type
1637
1638	@return copy of the JSON value, converted to @a ValueType
1639
1640	@throw what @ref json_serializer<ValueType> `from_json()` method throws
1641
1642	@since version 2.1.0
1643	*/
1644	template < typename ValueType,
1645	detail::enable_if_t <
1646	detail::has_non_default_from_json<basic_json_t, ValueType>::value,
1647	int > = `0` >
1648	ValueType get_impl(detail::priority_tag<`1`> /unused/) const noexcept(noexcept(
1649	JSONSerializer<ValueType>::from_json(std::declval<const basic_json_t&>())))
1650	{
1651	return JSONSerializer<ValueType>::from_json(*this);
1652	}
1653
1654	/!*
1655	@brief get special-case overload
1656
1657	This overloads converts the current @ref basic_json in a different
1658	@ref basic_json type
1659
1660	@tparam BasicJsonType == @ref basic_json
1661
1662	@return a copy of this, converted into @a BasicJsonType*
1663
1664	@complexity Depending on the implementation of the called `from_json()`
1665	method.
1666
1667	@since version 3.2.0
1668	*/
1669	template < typename BasicJsonType,
1670	detail::enable_if_t <
1671	detail::is_basic_json<BasicJsonType>::value,
1672	int > = `0` >
1673	BasicJsonType get_impl(detail::priority_tag<`2`> /unused/) const
1674	{
1675	return *this;
1676	}
1677
1678	/!*
1679	@brief get special-case overload
1680
1681	This overloads avoids a lot of template boilerplate, it can be seen as the
1682	identity method
1683
1684	@tparam BasicJsonType == @ref basic_json
1685
1686	@return a copy of this*
1687
1688	@complexity Constant.
1689
1690	@since version 2.1.0
1691	*/
1692	template<typename BasicJsonType,
1693	detail::enable_if_t<
1694	std::is_same<BasicJsonType, basic_json_t>::value,
1695	int> = `0`>
1696	basic_json get_impl(detail::priority_tag<`3`> /unused/) const
1697	{
1698	return *this;
1699	}
1700
1701	/!*
1702	@brief get a pointer value (explicit)
1703	@copydoc get()
1704	*/
1705	template<typename PointerType,
1706	detail::enable_if_t<
1707	std::is_pointer<PointerType>::value,
1708	int> = `0`>
1709	constexpr auto get_impl(detail::priority_tag<`4`> /unused/) const noexcept
1710	-> decltype(std::declval<const basic_json_t&>().template get_ptr<PointerType>())
1711	{
1712	// delegate the call to get_ptr
1713	return get_ptr<PointerType>();
1714	}
1715
1716	public:
1717	/!*
1718	@brief get a (pointer) value (explicit)
1719
1720	Performs explicit type conversion between the JSON value and a compatible value if required.
1721
1722	- If the requested type is a pointer to the internally stored JSON value that pointer is returned.
1723	No copies are made.
1724
1725	- If the requested type is the current @ref basic_json, or a different @ref basic_json convertible
1726	from the current @ref basic_json.
1727
1728	- Otherwise the value is converted by calling the @ref json_serializer<ValueType> `from_json()`
1729	method.
1730
1731	@tparam ValueTypeCV the provided value type
1732	@tparam ValueType the returned value type
1733
1734	@return copy of the JSON value, converted to @tparam ValueType if necessary
1735
1736	@throw what @ref json_serializer<ValueType> `from_json()` method throws if conversion is required
1737
1738	@since version 2.1.0
1739	*/
1740	template < typename ValueTypeCV, typename ValueType = detail::uncvref_t<ValueTypeCV>>
1741	#if defined(JSON_HAS_CPP_14)
1742	constexpr
1743	#endif
1744	auto get() const noexcept(
1745	noexcept(std::declval<const basic_json_t&>().template get_impl<ValueType>(detail::priority_tag<`4`> {})))
1746	-> decltype(std::declval<const basic_json_t&>().template get_impl<ValueType>(detail::priority_tag<`4`> {}))
1747	{
1748	// we cannot static_assert on ValueTypeCV being non-const, because
1749	// there is support for get<const basic_json_t>(), which is why we
1750	// still need the uncvref
1751	static_assert(!std::is_reference<ValueTypeCV>::value,
1752	"get() cannot be used with reference types, you might want to use get_ref()");
1753	return get_impl<ValueType>(detail::priority_tag<`4`> {});
1754	}
1755
1756	/!*
1757	@brief get a pointer value (explicit)
1758
1759	Explicit pointer access to the internally stored JSON value. No copies are
1760	made.
1761
1762	@warning The pointer becomes invalid if the underlying JSON object
1763	changes.
1764
1765	@tparam PointerType pointer type; must be a pointer to @ref array_t, @ref
1766	object_t, @ref string_t, @ref boolean_t, @ref number_integer_t,
1767	@ref number_unsigned_t, or @ref number_float_t.
1768
1769	@return pointer to the internally stored JSON value if the requested
1770	pointer type @a PointerType fits to the JSON value; `nullptr` otherwise
1771
1772	@complexity Constant.
1773
1774	@liveexample{The example below shows how pointers to internal values of a
1775	JSON value can be requested. Note that no type conversions are made and a
1776	`nullptr` is returned if the value and the requested pointer type does not
1777	match.,get__PointerType}
1778
1779	@sa see @ref get_ptr() for explicit pointer-member access
1780
1781	@since version 1.0.0
1782	*/
1783	template<typename PointerType, typename std::enable_if<
1784	std::is_pointer<PointerType>::value, int>::type = `0`>
1785	auto get() noexcept -> decltype(std::declval<basic_json_t&>().template get_ptr<PointerType>())
1786	{
1787	// delegate the call to get_ptr
1788	return get_ptr<PointerType>();
1789	}
1790
1791	/// @brief get a value (explicit)
1792	/// @sa https://json.nlohmann.me/api/basic_json/get_to/
1793	template < typename ValueType,
1794	detail::enable_if_t <
1795	!detail::is_basic_json<ValueType>::value&&
1796	detail::has_from_json<basic_json_t, ValueType>::value,
1797	int > = `0` >
1798	ValueType & get_to(ValueType& v) const noexcept(noexcept(
1799	JSONSerializer<ValueType>::from_json(std::declval<const basic_json_t&>(), v)))
1800	{
1801	JSONSerializer<ValueType>::from_json(*this, v);
1802	return v;
1803	}
1804
1805	// specialization to allow calling get_to with a basic_json value
1806	// see https://github.com/nlohmann/json/issues/2175
1807	template<typename ValueType,
1808	detail::enable_if_t <
1809	detail::is_basic_json<ValueType>::value,
1810	int> = `0`>
1811	ValueType & get_to(ValueType& v) const
1812	{
1813	v = *this;
1814	return v;
1815	}
1816
1817	template <
1818	typename T, std::size_t N,
1819	typename Array = T (&)[N], // NOLINT(cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays)
1820	detail::enable_if_t <
1821	detail::has_from_json<basic_json_t, Array>::value, int > = `0` >
1822	Array get_to(T (&v)[N]) const // NOLINT(cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays)
1823	noexcept(noexcept(JSONSerializer<Array>::from_json(
1824	std::declval<const basic_json_t&>(), v)))
1825	{
1826	JSONSerializer<Array>::from_json(*this, v);
1827	return v;
1828	}
1829
1830	/// @brief get a reference value (implicit)
1831	/// @sa https://json.nlohmann.me/api/basic_json/get_ref/
1832	template<typename ReferenceType, typename std::enable_if<
1833	std::is_reference<ReferenceType>::value, int>::type = `0`>
1834	ReferenceType get_ref()
1835	{
1836	// delegate call to get_ref_impl
1837	return get_ref_impl<ReferenceType>(*this);
1838	}
1839
1840	/// @brief get a reference value (implicit)
1841	/// @sa https://json.nlohmann.me/api/basic_json/get_ref/
1842	template < typename ReferenceType, typename std::enable_if <
1843	std::is_reference<ReferenceType>::value&&
1844	std::is_const<typename std::remove_reference<ReferenceType>::type>::value, int >::type = `0` >
1845	ReferenceType get_ref() const
1846	{
1847	// delegate call to get_ref_impl
1848	return get_ref_impl<ReferenceType>(*this);
1849	}
1850
1851	/!*
1852	@brief get a value (implicit)
1853
1854	Implicit type conversion between the JSON value and a compatible value.
1855	The call is realized by calling @ref get() const.
1856
1857	@tparam ValueType non-pointer type compatible to the JSON value, for
1858	instance `int` for JSON integer numbers, `bool` for JSON booleans, or
1859	`std::vector` types for JSON arrays. The character type of @ref string_t
1860	as well as an initializer list of this type is excluded to avoid
1861	ambiguities as these types implicitly convert to `std::string`.
1862
1863	@return copy of the JSON value, converted to type @a ValueType
1864
1865	@throw type_error.302 in case passed type @a ValueType is incompatible
1866	to the JSON value type (e.g., the JSON value is of type boolean, but a
1867	string is requested); see example below
1868
1869	@complexity Linear in the size of the JSON value.
1870
1871	@liveexample{The example below shows several conversions from JSON values
1872	to other types. There a few things to note: (1) Floating-point numbers can
1873	be converted to integers\, (2) A JSON array can be converted to a standard
1874	`std::vector<short>`\, (3) A JSON object can be converted to C++
1875	associative containers such as `std::unordered_map<std::string\,
1876	json>`.,operator__ValueType}
1877
1878	@since version 1.0.0
1879	*/
1880	template < typename ValueType, typename std::enable_if <
1881	detail::conjunction <
1882	detail::negation<std::is_pointer<ValueType>>,
1883	detail::negation<std::is_same<ValueType, std::nullptr_t>>,
1884	detail::negation<std::is_same<ValueType, detail::json_ref<basic_json>>>,
1885	detail::negation<std::is_same<ValueType, typename string_t::value_type>>,
1886	detail::negation<detail::is_basic_json<ValueType>>,
1887	detail::negation<std::is_same<ValueType, std::initializer_list<typename string_t::value_type>>>,
1888	#if defined(JSON_HAS_CPP_17) && (defined(__GNUC__) \|\| (defined(_MSC_VER) && _MSC_VER >= 1910 && _MSC_VER <= 1914))
1889	detail::negation<std::is_same<ValueType, std::string_view>>,
1890	#endif
1891	#if defined(JSON_HAS_CPP_17) && JSON_HAS_STATIC_RTTI
1892	detail::negation<std::is_same<ValueType, std::any>>,
1893	#endif
1894	detail::is_detected_lazy<detail::get_template_function, const basic_json_t&, ValueType>
1895	>::value, int >::type = `0` >
1896	JSON_EXPLICIT operator ValueType() const
1897	{
1898	// delegate the call to get<>() const
1899	return get<ValueType>();
1900	}
1901
1902	/// @brief get a binary value
1903	/// @sa https://json.nlohmann.me/api/basic_json/get_binary/
1904	binary_t& get_binary()
1905	{
1906	if (!is_binary())
1907	{
1908	JSON_THROW(type_error::create(`302`, detail::concat("type must be binary, but is ", type_name()), this));
1909	}
1910
1911	return get_ptr<binary_t>();
1912	}
1913
1914	/// @brief get a binary value
1915	/// @sa https://json.nlohmann.me/api/basic_json/get_binary/
1916	const binary_t& get_binary() const
1917	{
1918	if (!is_binary())
1919	{
1920	JSON_THROW(type_error::create(`302`, detail::concat("type must be binary, but is ", type_name()), this));
1921	}
1922
1923	return get_ptr<const* binary_t*>();
1924	}
1925
1926	/// @}
1927
1928	////////////////////
1929	// element access //
1930	////////////////////
1931
1932	/// @name element access
1933	/// Access to the JSON value.
1934	/// @{
1935
1936	/// @brief access specified array element with bounds checking
1937	/// @sa https://json.nlohmann.me/api/basic_json/at/
1938	reference at(size_type idx)
1939	{
1940	// at only works for arrays
1941	if (JSON_HEDLEY_LIKELY(is_array()))
1942	{
1943	JSON_TRY
1944	{
1945	return set_parent(j&: m_data.m_value.array->at(idx));
1946	}
1947	JSON_CATCH (std::out_of_range&)
1948	{
1949	// create better exception explanation
1950	JSON_THROW(out_of_range::create(`401`, detail::concat("array index ", std::to_string(idx), " is out of range"), this));
1951	}
1952	}
1953	else
1954	{
1955	JSON_THROW(type_error::create(`304`, detail::concat("cannot use at() with ", type_name()), this));
1956	}
1957	}
1958
1959	/// @brief access specified array element with bounds checking
1960	/// @sa https://json.nlohmann.me/api/basic_json/at/
1961	const_reference at(size_type idx) const
1962	{
1963	// at only works for arrays
1964	if (JSON_HEDLEY_LIKELY(is_array()))
1965	{
1966	JSON_TRY
1967	{
1968	return m_data.m_value.array->at(idx);
1969	}
1970	JSON_CATCH (std::out_of_range&)
1971	{
1972	// create better exception explanation
1973	JSON_THROW(out_of_range::create(`401`, detail::concat("array index ", std::to_string(idx), " is out of range"), this));
1974	}
1975	}
1976	else
1977	{
1978	JSON_THROW(type_error::create(`304`, detail::concat("cannot use at() with ", type_name()), this));
1979	}
1980	}
1981
1982	/// @brief access specified object element with bounds checking
1983	/// @sa https://json.nlohmann.me/api/basic_json/at/
1984	reference at(const typename object_t::key_type& key)
1985	{
1986	// at only works for objects
1987	if (JSON_HEDLEY_UNLIKELY(!is_object()))
1988	{
1989	JSON_THROW(type_error::create(`304`, detail::concat("cannot use at() with ", type_name()), this));
1990	}
1991
1992	auto it = m_data.m_value.object->find(key);
1993	if (it == m_data.m_value.object->end())
1994	{
1995	JSON_THROW(out_of_range::create(`403`, detail::concat("key '", key, "' not found"), this));
1996	}
1997	return set_parent(j&: it->second);
1998	}
1999
2000	/// @brief access specified object element with bounds checking
2001	/// @sa https://json.nlohmann.me/api/basic_json/at/
2002	template<class KeyType, detail::enable_if_t<
2003	detail::is_usable_as_basic_json_key_type<basic_json_t, KeyType>::value, int> = `0`>
2004	reference at(KeyType && key)
2005	{
2006	// at only works for objects
2007	if (JSON_HEDLEY_UNLIKELY(!is_object()))
2008	{
2009	JSON_THROW(type_error::create(`304`, detail::concat("cannot use at() with ", type_name()), this));
2010	}
2011
2012	auto it = m_data.m_value.object->find(std::forward<KeyType>(key));
2013	if (it == m_data.m_value.object->end())
2014	{
2015	JSON_THROW(out_of_range::create(`403`, detail::concat("key '", string_t(std::forward<KeyType>(key)), "' not found"), this));
2016	}
2017	return set_parent(j&: it->second);
2018	}
2019
2020	/// @brief access specified object element with bounds checking
2021	/// @sa https://json.nlohmann.me/api/basic_json/at/
2022	const_reference at(const typename object_t::key_type& key) const
2023	{
2024	// at only works for objects
2025	if (JSON_HEDLEY_UNLIKELY(!is_object()))
2026	{
2027	JSON_THROW(type_error::create(`304`, detail::concat("cannot use at() with ", type_name()), this));
2028	}
2029
2030	auto it = m_data.m_value.object->find(key);
2031	if (it == m_data.m_value.object->end())
2032	{
2033	JSON_THROW(out_of_range::create(`403`, detail::concat("key '", key, "' not found"), this));
2034	}
2035	return it->second;
2036	}
2037
2038	/// @brief access specified object element with bounds checking
2039	/// @sa https://json.nlohmann.me/api/basic_json/at/
2040	template<class KeyType, detail::enable_if_t<
2041	detail::is_usable_as_basic_json_key_type<basic_json_t, KeyType>::value, int> = `0`>
2042	const_reference at(KeyType && key) const
2043	{
2044	// at only works for objects
2045	if (JSON_HEDLEY_UNLIKELY(!is_object()))
2046	{
2047	JSON_THROW(type_error::create(`304`, detail::concat("cannot use at() with ", type_name()), this));
2048	}
2049
2050	auto it = m_data.m_value.object->find(std::forward<KeyType>(key));
2051	if (it == m_data.m_value.object->end())
2052	{
2053	JSON_THROW(out_of_range::create(`403`, detail::concat("key '", string_t(std::forward<KeyType>(key)), "' not found"), this));
2054	}
2055	return it->second;
2056	}
2057
2058	/// @brief access specified array element
2059	/// @sa https://json.nlohmann.me/api/basic_json/operator%5B%5D/
2060	reference operator[](size_type idx)
2061	{
2062	// implicitly convert null value to an empty array
2063	if (is_null())
2064	{
2065	m_data.m_type = value_t::array;
2066	m_data.m_value.array = create<array_t>();
2067	assert_invariant();
2068	}
2069
2070	// operator[] only works for arrays
2071	if (JSON_HEDLEY_LIKELY(is_array()))
2072	{
2073	// fill up array with null values if given idx is outside range
2074	if (idx >= m_data.m_value.array->size())
2075	{
2076	#if JSON_DIAGNOSTICS
2077	// remember array size & capacity before resizing
2078	const auto old_size = m_data.m_value.array->size();
2079	const auto old_capacity = m_data.m_value.array->capacity();
2080	#endif
2081	m_data.m_value.array->resize(idx + `1`);
2082
2083	#if JSON_DIAGNOSTICS
2084	if (JSON_HEDLEY_UNLIKELY(m_data.m_value.array->capacity() != old_capacity))
2085	{
2086	// capacity has changed: update all parents
2087	set_parents();
2088	}
2089	else
2090	{
2091	// set parent for values added above
2092	set_parents(begin() + static_cast<typename iterator::difference_type>(old_size), static_cast<typename iterator::difference_type>(idx + `1` - old_size));
2093	}
2094	#endif
2095	assert_invariant();
2096	}
2097
2098	return m_data.m_value.array->operator[](idx);
2099	}
2100
2101	JSON_THROW(type_error::create(`305`, detail::concat("cannot use operator[] with a numeric argument with ", type_name()), this));
2102	}
2103
2104	/// @brief access specified array element
2105	/// @sa https://json.nlohmann.me/api/basic_json/operator%5B%5D/
2106	const_reference operator[](size_type idx) const
2107	{
2108	// const operator[] only works for arrays
2109	if (JSON_HEDLEY_LIKELY(is_array()))
2110	{
2111	return m_data.m_value.array->operator[](idx);
2112	}
2113
2114	JSON_THROW(type_error::create(`305`, detail::concat("cannot use operator[] with a numeric argument with ", type_name()), this));
2115	}
2116
2117	/// @brief access specified object element
2118	/// @sa https://json.nlohmann.me/api/basic_json/operator%5B%5D/
2119	reference operator[](typename object_t::key_type key)
2120	{
2121	// implicitly convert null value to an empty object
2122	if (is_null())
2123	{
2124	m_data.m_type = value_t::object;
2125	m_data.m_value.object = create<object_t>();
2126	assert_invariant();
2127	}
2128
2129	// operator[] only works for objects
2130	if (JSON_HEDLEY_LIKELY(is_object()))
2131	{
2132	auto result = m_data.m_value.object->emplace(std::move(key), nullptr);
2133	return set_parent(j&: result.first->second);
2134	}
2135
2136	JSON_THROW(type_error::create(`305`, detail::concat("cannot use operator[] with a string argument with ", type_name()), this));
2137	}
2138
2139	/// @brief access specified object element
2140	/// @sa https://json.nlohmann.me/api/basic_json/operator%5B%5D/
2141	const_reference operator[](const typename object_t::key_type& key) const
2142	{
2143	// const operator[] only works for objects
2144	if (JSON_HEDLEY_LIKELY(is_object()))
2145	{
2146	auto it = m_data.m_value.object->find(key);
2147	JSON_ASSERT(it != m_data.m_value.object->end());
2148	return it->second;
2149	}
2150
2151	JSON_THROW(type_error::create(`305`, detail::concat("cannot use operator[] with a string argument with ", type_name()), this));
2152	}
2153
2154	// these two functions resolve a (const) char ambiguity affecting Clang and MSVC*
2155	// (they seemingly cannot be constrained to resolve the ambiguity)
2156	template<typename T>
2157	reference operator[](T* key)
2158	{
2159	return operator[](typename object_t::key_type(key));
2160	}
2161
2162	template<typename T>
2163	const_reference operator[](T* key) const
2164	{
2165	return operator[](typename object_t::key_type(key));
2166	}
2167
2168	/// @brief access specified object element
2169	/// @sa https://json.nlohmann.me/api/basic_json/operator%5B%5D/
2170	template<class KeyType, detail::enable_if_t<
2171	detail::is_usable_as_basic_json_key_type<basic_json_t, KeyType>::value, int > = `0` >
2172	reference operator[](KeyType && key)
2173	{
2174	// implicitly convert null value to an empty object
2175	if (is_null())
2176	{
2177	m_data.m_type = value_t::object;
2178	m_data.m_value.object = create<object_t>();
2179	assert_invariant();
2180	}
2181
2182	// operator[] only works for objects
2183	if (JSON_HEDLEY_LIKELY(is_object()))
2184	{
2185	auto result = m_data.m_value.object->emplace(std::forward<KeyType>(key), nullptr);
2186	return set_parent(j&: result.first->second);
2187	}
2188
2189	JSON_THROW(type_error::create(`305`, detail::concat("cannot use operator[] with a string argument with ", type_name()), this));
2190	}
2191
2192	/// @brief access specified object element
2193	/// @sa https://json.nlohmann.me/api/basic_json/operator%5B%5D/
2194	template<class KeyType, detail::enable_if_t<
2195	detail::is_usable_as_basic_json_key_type<basic_json_t, KeyType>::value, int > = `0` >
2196	const_reference operator[](KeyType && key) const
2197	{
2198	// const operator[] only works for objects
2199	if (JSON_HEDLEY_LIKELY(is_object()))
2200	{
2201	auto it = m_data.m_value.object->find(std::forward<KeyType>(key));
2202	JSON_ASSERT(it != m_data.m_value.object->end());
2203	return it->second;
2204	}
2205
2206	JSON_THROW(type_error::create(`305`, detail::concat("cannot use operator[] with a string argument with ", type_name()), this));
2207	}
2208
2209	private:
2210	template<typename KeyType>
2211	using is_comparable_with_object_key = detail::is_comparable <
2212	object_comparator_t, const typename object_t::key_type&, KeyType >;
2213
2214	template<typename ValueType>
2215	using value_return_type = std::conditional <
2216	detail::is_c_string_uncvref<ValueType>::value,
2217	string_t, typename std::decay<ValueType>::type >;
2218
2219	public:
2220	/// @brief access specified object element with default value
2221	/// @sa https://json.nlohmann.me/api/basic_json/value/
2222	template < class ValueType, detail::enable_if_t <
2223	!detail::is_transparent<object_comparator_t>::value
2224	&& detail::is_getable<basic_json_t, ValueType>::value
2225	&& !std::is_same<value_t, detail::uncvref_t<ValueType>>::value, int > = `0` >
2226	ValueType value(const typename object_t::key_type& key, const ValueType& default_value) const
2227	{
2228	// value only works for objects
2229	if (JSON_HEDLEY_LIKELY(is_object()))
2230	{
2231	// if key is found, return value and given default value otherwise
2232	const auto it = find(key);
2233	if (it != end())
2234	{
2235	return it->template get<ValueType>();
2236	}
2237
2238	return default_value;
2239	}
2240
2241	JSON_THROW(type_error::create(`306`, detail::concat("cannot use value() with ", type_name()), this));
2242	}
2243
2244	/// @brief access specified object element with default value
2245	/// @sa https://json.nlohmann.me/api/basic_json/value/
2246	template < class ValueType, class ReturnType = typename value_return_type<ValueType>::type,
2247	detail::enable_if_t <
2248	!detail::is_transparent<object_comparator_t>::value
2249	&& detail::is_getable<basic_json_t, ReturnType>::value
2250	&& !std::is_same<value_t, detail::uncvref_t<ValueType>>::value, int > = `0` >
2251	ReturnType value(const typename object_t::key_type& key, ValueType && default_value) const
2252	{
2253	// value only works for objects
2254	if (JSON_HEDLEY_LIKELY(is_object()))
2255	{
2256	// if key is found, return value and given default value otherwise
2257	const auto it = find(key);
2258	if (it != end())
2259	{
2260	return it->template get<ReturnType>();
2261	}
2262
2263	return std::forward<ValueType>(default_value);
2264	}
2265
2266	JSON_THROW(type_error::create(`306`, detail::concat("cannot use value() with ", type_name()), this));
2267	}
2268
2269	/// @brief access specified object element with default value
2270	/// @sa https://json.nlohmann.me/api/basic_json/value/
2271	template < class ValueType, class KeyType, detail::enable_if_t <
2272	detail::is_transparent<object_comparator_t>::value
2273	&& !detail::is_json_pointer<KeyType>::value
2274	&& is_comparable_with_object_key<KeyType>::value
2275	&& detail::is_getable<basic_json_t, ValueType>::value
2276	&& !std::is_same<value_t, detail::uncvref_t<ValueType>>::value, int > = `0` >
2277	ValueType value(KeyType && key, const ValueType& default_value) const
2278	{
2279	// value only works for objects
2280	if (JSON_HEDLEY_LIKELY(is_object()))
2281	{
2282	// if key is found, return value and given default value otherwise
2283	const auto it = find(std::forward<KeyType>(key));
2284	if (it != end())
2285	{
2286	return it->template get<ValueType>();
2287	}
2288
2289	return default_value;
2290	}
2291
2292	JSON_THROW(type_error::create(`306`, detail::concat("cannot use value() with ", type_name()), this));
2293	}
2294
2295	/// @brief access specified object element via JSON Pointer with default value
2296	/// @sa https://json.nlohmann.me/api/basic_json/value/
2297	template < class ValueType, class KeyType, class ReturnType = typename value_return_type<ValueType>::type,
2298	detail::enable_if_t <
2299	detail::is_transparent<object_comparator_t>::value
2300	&& !detail::is_json_pointer<KeyType>::value
2301	&& is_comparable_with_object_key<KeyType>::value
2302	&& detail::is_getable<basic_json_t, ReturnType>::value
2303	&& !std::is_same<value_t, detail::uncvref_t<ValueType>>::value, int > = `0` >
2304	ReturnType value(KeyType && key, ValueType && default_value) const
2305	{
2306	// value only works for objects
2307	if (JSON_HEDLEY_LIKELY(is_object()))
2308	{
2309	// if key is found, return value and given default value otherwise
2310	const auto it = find(std::forward<KeyType>(key));
2311	if (it != end())
2312	{
2313	return it->template get<ReturnType>();
2314	}
2315
2316	return std::forward<ValueType>(default_value);
2317	}
2318
2319	JSON_THROW(type_error::create(`306`, detail::concat("cannot use value() with ", type_name()), this));
2320	}
2321
2322	/// @brief access specified object element via JSON Pointer with default value
2323	/// @sa https://json.nlohmann.me/api/basic_json/value/
2324	template < class ValueType, detail::enable_if_t <
2325	detail::is_getable<basic_json_t, ValueType>::value
2326	&& !std::is_same<value_t, detail::uncvref_t<ValueType>>::value, int > = `0` >
2327	ValueType value(const json_pointer& ptr, const ValueType& default_value) const
2328	{
2329	// value only works for objects
2330	if (JSON_HEDLEY_LIKELY(is_object()))
2331	{
2332	// if pointer resolves a value, return it or use default value
2333	JSON_TRY
2334	{
2335	return ptr.get_checked(this).template get<ValueType>();
2336	}
2337	JSON_INTERNAL_CATCH (out_of_range&)
2338	{
2339	return default_value;
2340	}
2341	}
2342
2343	JSON_THROW(type_error::create(`306`, detail::concat("cannot use value() with ", type_name()), this));
2344	}
2345
2346	/// @brief access specified object element via JSON Pointer with default value
2347	/// @sa https://json.nlohmann.me/api/basic_json/value/
2348	template < class ValueType, class ReturnType = typename value_return_type<ValueType>::type,
2349	detail::enable_if_t <
2350	detail::is_getable<basic_json_t, ReturnType>::value
2351	&& !std::is_same<value_t, detail::uncvref_t<ValueType>>::value, int > = `0` >
2352	ReturnType value(const json_pointer& ptr, ValueType && default_value) const
2353	{
2354	// value only works for objects
2355	if (JSON_HEDLEY_LIKELY(is_object()))
2356	{
2357	// if pointer resolves a value, return it or use default value
2358	JSON_TRY
2359	{
2360	return ptr.get_checked(this).template get<ReturnType>();
2361	}
2362	JSON_INTERNAL_CATCH (out_of_range&)
2363	{
2364	return std::forward<ValueType>(default_value);
2365	}
2366	}
2367
2368	JSON_THROW(type_error::create(`306`, detail::concat("cannot use value() with ", type_name()), this));
2369	}
2370
2371	template < class ValueType, class BasicJsonType, detail::enable_if_t <
2372	detail::is_basic_json<BasicJsonType>::value
2373	&& detail::is_getable<basic_json_t, ValueType>::value
2374	&& !std::is_same<value_t, detail::uncvref_t<ValueType>>::value, int > = `0` >
2375	JSON_HEDLEY_DEPRECATED_FOR(`3.11.0`, basic_json::json_pointer or nlohmann::json_pointer<basic_json::string_t>) // NOLINT(readability/alt_tokens)
2376	ValueType value(const ::nlohmann::json_pointer<BasicJsonType>& ptr, const ValueType& default_value) const
2377	{
2378	return value(ptr.convert(), default_value);
2379	}
2380
2381	template < class ValueType, class BasicJsonType, class ReturnType = typename value_return_type<ValueType>::type,
2382	detail::enable_if_t <
2383	detail::is_basic_json<BasicJsonType>::value
2384	&& detail::is_getable<basic_json_t, ReturnType>::value
2385	&& !std::is_same<value_t, detail::uncvref_t<ValueType>>::value, int > = `0` >
2386	JSON_HEDLEY_DEPRECATED_FOR(`3.11.0`, basic_json::json_pointer or nlohmann::json_pointer<basic_json::string_t>) // NOLINT(readability/alt_tokens)
2387	ReturnType value(const ::nlohmann::json_pointer<BasicJsonType>& ptr, ValueType && default_value) const
2388	{
2389	return value(ptr.convert(), std::forward<ValueType>(default_value));
2390	}
2391
2392	/// @brief access the first element
2393	/// @sa https://json.nlohmann.me/api/basic_json/front/
2394	reference front()
2395	{
2396	return *begin();
2397	}
2398
2399	/// @brief access the first element
2400	/// @sa https://json.nlohmann.me/api/basic_json/front/
2401	const_reference front() const
2402	{
2403	return *cbegin();
2404	}
2405
2406	/// @brief access the last element
2407	/// @sa https://json.nlohmann.me/api/basic_json/back/
2408	reference back()
2409	{
2410	auto tmp = end();
2411	--tmp;
2412	return *tmp;
2413	}
2414
2415	/// @brief access the last element
2416	/// @sa https://json.nlohmann.me/api/basic_json/back/
2417	const_reference back() const
2418	{
2419	auto tmp = cend();
2420	--tmp;
2421	return *tmp;
2422	}
2423
2424	/// @brief remove element given an iterator
2425	/// @sa https://json.nlohmann.me/api/basic_json/erase/
2426	template < class IteratorType, detail::enable_if_t <
2427	std::is_same<IteratorType, typename basic_json_t::iterator>::value \|\|
2428	std::is_same<IteratorType, typename basic_json_t::const_iterator>::value, int > = `0` >
2429	IteratorType erase(IteratorType pos)
2430	{
2431	// make sure iterator fits the current value
2432	if (JSON_HEDLEY_UNLIKELY(this != pos.m_object))
2433	{
2434	JSON_THROW(invalid_iterator::create(`202`, "iterator does not fit current value", this));
2435	}
2436
2437	IteratorType result = end();
2438
2439	switch (m_data.m_type)
2440	{
2441	case value_t::boolean:
2442	case value_t::number_float:
2443	case value_t::number_integer:
2444	case value_t::number_unsigned:
2445	case value_t::string:
2446	case value_t::binary:
2447	{
2448	if (JSON_HEDLEY_UNLIKELY(!pos.m_it.primitive_iterator.is_begin()))
2449	{
2450	JSON_THROW(invalid_iterator::create(`205`, "iterator out of range", this));
2451	}
2452
2453	if (is_string())
2454	{
2455	AllocatorType<string_t> alloc;
2456	std::allocator_traits<decltype(alloc)>::destroy(alloc, m_data.m_value.string);
2457	std::allocator_traits<decltype(alloc)>::deallocate(alloc, m_data.m_value.string, `1`);
2458	m_data.m_value.string = nullptr;
2459	}
2460	else if (is_binary())
2461	{
2462	AllocatorType<binary_t> alloc;
2463	std::allocator_traits<decltype(alloc)>::destroy(alloc, m_data.m_value.binary);
2464	std::allocator_traits<decltype(alloc)>::deallocate(alloc, m_data.m_value.binary, `1`);
2465	m_data.m_value.binary = nullptr;
2466	}
2467
2468	m_data.m_type = value_t::null;
2469	assert_invariant();
2470	break;
2471	}
2472
2473	case value_t::object:
2474	{
2475	result.m_it.object_iterator = m_data.m_value.object->erase(pos.m_it.object_iterator);
2476	break;
2477	}
2478
2479	case value_t::array:
2480	{
2481	result.m_it.array_iterator = m_data.m_value.array->erase(pos.m_it.array_iterator);
2482	break;
2483	}
2484
2485	case value_t::null:
2486	case value_t::discarded:
2487	default:
2488	JSON_THROW(type_error::create(`307`, detail::concat("cannot use erase() with ", type_name()), this));
2489	}
2490
2491	return result;
2492	}
2493
2494	/// @brief remove elements given an iterator range
2495	/// @sa https://json.nlohmann.me/api/basic_json/erase/
2496	template < class IteratorType, detail::enable_if_t <
2497	std::is_same<IteratorType, typename basic_json_t::iterator>::value \|\|
2498	std::is_same<IteratorType, typename basic_json_t::const_iterator>::value, int > = `0` >
2499	IteratorType erase(IteratorType first, IteratorType last)
2500	{
2501	// make sure iterator fits the current value
2502	if (JSON_HEDLEY_UNLIKELY(this != first.m_object \|\| this != last.m_object))
2503	{
2504	JSON_THROW(invalid_iterator::create(`203`, "iterators do not fit current value", this));
2505	}
2506
2507	IteratorType result = end();
2508
2509	switch (m_data.m_type)
2510	{
2511	case value_t::boolean:
2512	case value_t::number_float:
2513	case value_t::number_integer:
2514	case value_t::number_unsigned:
2515	case value_t::string:
2516	case value_t::binary:
2517	{
2518	if (JSON_HEDLEY_LIKELY(!first.m_it.primitive_iterator.is_begin()
2519	\|\| !last.m_it.primitive_iterator.is_end()))
2520	{
2521	JSON_THROW(invalid_iterator::create(`204`, "iterators out of range", this));
2522	}
2523
2524	if (is_string())
2525	{
2526	AllocatorType<string_t> alloc;
2527	std::allocator_traits<decltype(alloc)>::destroy(alloc, m_data.m_value.string);
2528	std::allocator_traits<decltype(alloc)>::deallocate(alloc, m_data.m_value.string, `1`);
2529	m_data.m_value.string = nullptr;
2530	}
2531	else if (is_binary())
2532	{
2533	AllocatorType<binary_t> alloc;
2534	std::allocator_traits<decltype(alloc)>::destroy(alloc, m_data.m_value.binary);
2535	std::allocator_traits<decltype(alloc)>::deallocate(alloc, m_data.m_value.binary, `1`);
2536	m_data.m_value.binary = nullptr;
2537	}
2538
2539	m_data.m_type = value_t::null;
2540	assert_invariant();
2541	break;
2542	}
2543
2544	case value_t::object:
2545	{
2546	result.m_it.object_iterator = m_data.m_value.object->erase(first.m_it.object_iterator,
2547	last.m_it.object_iterator);
2548	break;
2549	}
2550
2551	case value_t::array:
2552	{
2553	result.m_it.array_iterator = m_data.m_value.array->erase(first.m_it.array_iterator,
2554	last.m_it.array_iterator);
2555	break;
2556	}
2557
2558	case value_t::null:
2559	case value_t::discarded:
2560	default:
2561	JSON_THROW(type_error::create(`307`, detail::concat("cannot use erase() with ", type_name()), this));
2562	}
2563
2564	return result;
2565	}
2566
2567	private:
2568	template < typename KeyType, detail::enable_if_t <
2569	detail::has_erase_with_key_type<basic_json_t, KeyType>::value, int > = `0` >
2570	size_type erase_internal(KeyType && key)
2571	{
2572	// this erase only works for objects
2573	if (JSON_HEDLEY_UNLIKELY(!is_object()))
2574	{
2575	JSON_THROW(type_error::create(`307`, detail::concat("cannot use erase() with ", type_name()), this));
2576	}
2577
2578	return m_data.m_value.object->erase(std::forward<KeyType>(key));
2579	}
2580
2581	template < typename KeyType, detail::enable_if_t <
2582	!detail::has_erase_with_key_type<basic_json_t, KeyType>::value, int > = `0` >
2583	size_type erase_internal(KeyType && key)
2584	{
2585	// this erase only works for objects
2586	if (JSON_HEDLEY_UNLIKELY(!is_object()))
2587	{
2588	JSON_THROW(type_error::create(`307`, detail::concat("cannot use erase() with ", type_name()), this));
2589	}
2590
2591	const auto it = m_data.m_value.object->find(std::forward<KeyType>(key));
2592	if (it != m_data.m_value.object->end())
2593	{
2594	m_data.m_value.object->erase(it);
2595	return `1`;
2596	}
2597	return `0`;
2598	}
2599
2600	public:
2601
2602	/// @brief remove element from a JSON object given a key
2603	/// @sa https://json.nlohmann.me/api/basic_json/erase/
2604	size_type erase(const typename object_t::key_type& key)
2605	{
2606	// the indirection via erase_internal() is added to avoid making this
2607	// function a template and thus de-rank it during overload resolution
2608	return erase_internal(key);
2609	}
2610
2611	/// @brief remove element from a JSON object given a key
2612	/// @sa https://json.nlohmann.me/api/basic_json/erase/
2613	template<class KeyType, detail::enable_if_t<
2614	detail::is_usable_as_basic_json_key_type<basic_json_t, KeyType>::value, int> = `0`>
2615	size_type erase(KeyType && key)
2616	{
2617	return erase_internal(std::forward<KeyType>(key));
2618	}
2619
2620	/// @brief remove element from a JSON array given an index
2621	/// @sa https://json.nlohmann.me/api/basic_json/erase/
2622	void erase(const size_type idx)
2623	{
2624	// this erase only works for arrays
2625	if (JSON_HEDLEY_LIKELY(is_array()))
2626	{
2627	if (JSON_HEDLEY_UNLIKELY(idx >= size()))
2628	{
2629	JSON_THROW(out_of_range::create(`401`, detail::concat("array index ", std::to_string(idx), " is out of range"), this));
2630	}
2631
2632	m_data.m_value.array->erase(m_data.m_value.array->begin() + static_cast<difference_type>(idx));
2633	}
2634	else
2635	{
2636	JSON_THROW(type_error::create(`307`, detail::concat("cannot use erase() with ", type_name()), this));
2637	}
2638	}
2639
2640	/// @}
2641
2642	////////////
2643	// lookup //
2644	////////////
2645
2646	/// @name lookup
2647	/// @{
2648
2649	/// @brief find an element in a JSON object
2650	/// @sa https://json.nlohmann.me/api/basic_json/find/
2651	iterator find(const typename object_t::key_type& key)
2652	{
2653	auto result = end();
2654
2655	if (is_object())
2656	{
2657	result.m_it.object_iterator = m_data.m_value.object->find(key);
2658	}
2659
2660	return result;
2661	}
2662
2663	/// @brief find an element in a JSON object
2664	/// @sa https://json.nlohmann.me/api/basic_json/find/
2665	const_iterator find(const typename object_t::key_type& key) const
2666	{
2667	auto result = cend();
2668
2669	if (is_object())
2670	{
2671	result.m_it.object_iterator = m_data.m_value.object->find(key);
2672	}
2673
2674	return result;
2675	}
2676
2677	/// @brief find an element in a JSON object
2678	/// @sa https://json.nlohmann.me/api/basic_json/find/
2679	template<class KeyType, detail::enable_if_t<
2680	detail::is_usable_as_basic_json_key_type<basic_json_t, KeyType>::value, int> = `0`>
2681	iterator find(KeyType && key)
2682	{
2683	auto result = end();
2684
2685	if (is_object())
2686	{
2687	result.m_it.object_iterator = m_data.m_value.object->find(std::forward<KeyType>(key));
2688	}
2689
2690	return result;
2691	}
2692
2693	/// @brief find an element in a JSON object
2694	/// @sa https://json.nlohmann.me/api/basic_json/find/
2695	template<class KeyType, detail::enable_if_t<
2696	detail::is_usable_as_basic_json_key_type<basic_json_t, KeyType>::value, int> = `0`>
2697	const_iterator find(KeyType && key) const
2698	{
2699	auto result = cend();
2700
2701	if (is_object())
2702	{
2703	result.m_it.object_iterator = m_data.m_value.object->find(std::forward<KeyType>(key));
2704	}
2705
2706	return result;
2707	}
2708
2709	/// @brief returns the number of occurrences of a key in a JSON object
2710	/// @sa https://json.nlohmann.me/api/basic_json/count/
2711	size_type count(const typename object_t::key_type& key) const
2712	{
2713	// return 0 for all nonobject types
2714	return is_object() ? m_data.m_value.object->count(key) : `0`;
2715	}
2716
2717	/// @brief returns the number of occurrences of a key in a JSON object
2718	/// @sa https://json.nlohmann.me/api/basic_json/count/
2719	template<class KeyType, detail::enable_if_t<
2720	detail::is_usable_as_basic_json_key_type<basic_json_t, KeyType>::value, int> = `0`>
2721	size_type count(KeyType && key) const
2722	{
2723	// return 0 for all nonobject types
2724	return is_object() ? m_data.m_value.object->count(std::forward<KeyType>(key)) : `0`;
2725	}
2726
2727	/// @brief check the existence of an element in a JSON object
2728	/// @sa https://json.nlohmann.me/api/basic_json/contains/
2729	bool contains(const typename object_t::key_type& key) const
2730	{
2731	return is_object() && m_data.m_value.object->find(key) != m_data.m_value.object->end();
2732	}
2733
2734	/// @brief check the existence of an element in a JSON object
2735	/// @sa https://json.nlohmann.me/api/basic_json/contains/
2736	template<class KeyType, detail::enable_if_t<
2737	detail::is_usable_as_basic_json_key_type<basic_json_t, KeyType>::value, int> = `0`>
2738	bool contains(KeyType && key) const
2739	{
2740	return is_object() && m_data.m_value.object->find(std::forward<KeyType>(key)) != m_data.m_value.object->end();
2741	}
2742
2743	/// @brief check the existence of an element in a JSON object given a JSON pointer
2744	/// @sa https://json.nlohmann.me/api/basic_json/contains/
2745	bool contains(const json_pointer& ptr) const
2746	{
2747	return ptr.contains(this);
2748	}
2749
2750	template<typename BasicJsonType, detail::enable_if_t<detail::is_basic_json<BasicJsonType>::value, int> = `0`>
2751	JSON_HEDLEY_DEPRECATED_FOR(`3.11.0`, basic_json::json_pointer or nlohmann::json_pointer<basic_json::string_t>) // NOLINT(readability/alt_tokens)
2752	bool contains(const typename ::nlohmann::json_pointer<BasicJsonType>& ptr) const
2753	{
2754	return ptr.contains(this);
2755	}
2756
2757	/// @}
2758
2759	///////////////
2760	// iterators //
2761	///////////////
2762
2763	/// @name iterators
2764	/// @{
2765
2766	/// @brief returns an iterator to the first element
2767	/// @sa https://json.nlohmann.me/api/basic_json/begin/
2768	iterator begin() noexcept
2769	{
2770	iterator result(this);
2771	result.set_begin();
2772	return result;
2773	}
2774
2775	/// @brief returns an iterator to the first element
2776	/// @sa https://json.nlohmann.me/api/basic_json/begin/
2777	const_iterator begin() const noexcept
2778	{
2779	return cbegin();
2780	}
2781
2782	/// @brief returns a const iterator to the first element
2783	/// @sa https://json.nlohmann.me/api/basic_json/cbegin/
2784	const_iterator cbegin() const noexcept
2785	{
2786	const_iterator result(this);
2787	result.set_begin();
2788	return result;
2789	}
2790
2791	/// @brief returns an iterator to one past the last element
2792	/// @sa https://json.nlohmann.me/api/basic_json/end/
2793	iterator end() noexcept
2794	{
2795	iterator result(this);
2796	result.set_end();
2797	return result;
2798	}
2799
2800	/// @brief returns an iterator to one past the last element
2801	/// @sa https://json.nlohmann.me/api/basic_json/end/
2802	const_iterator end() const noexcept
2803	{
2804	return cend();
2805	}
2806
2807	/// @brief returns an iterator to one past the last element
2808	/// @sa https://json.nlohmann.me/api/basic_json/cend/
2809	const_iterator cend() const noexcept
2810	{
2811	const_iterator result(this);
2812	result.set_end();
2813	return result;
2814	}
2815
2816	/// @brief returns an iterator to the reverse-beginning
2817	/// @sa https://json.nlohmann.me/api/basic_json/rbegin/
2818	reverse_iterator rbegin() noexcept
2819	{
2820	return reverse_iterator(end());
2821	}
2822
2823	/// @brief returns an iterator to the reverse-beginning
2824	/// @sa https://json.nlohmann.me/api/basic_json/rbegin/
2825	const_reverse_iterator rbegin() const noexcept
2826	{
2827	return crbegin();
2828	}
2829
2830	/// @brief returns an iterator to the reverse-end
2831	/// @sa https://json.nlohmann.me/api/basic_json/rend/
2832	reverse_iterator rend() noexcept
2833	{
2834	return reverse_iterator(begin());
2835	}
2836
2837	/// @brief returns an iterator to the reverse-end
2838	/// @sa https://json.nlohmann.me/api/basic_json/rend/
2839	const_reverse_iterator rend() const noexcept
2840	{
2841	return crend();
2842	}
2843
2844	/// @brief returns a const reverse iterator to the last element
2845	/// @sa https://json.nlohmann.me/api/basic_json/crbegin/
2846	const_reverse_iterator crbegin() const noexcept
2847	{
2848	return const_reverse_iterator(cend());
2849	}
2850
2851	/// @brief returns a const reverse iterator to one before the first
2852	/// @sa https://json.nlohmann.me/api/basic_json/crend/
2853	const_reverse_iterator crend() const noexcept
2854	{
2855	return const_reverse_iterator(cbegin());
2856	}
2857
2858	public:
2859	/// @brief wrapper to access iterator member functions in range-based for
2860	/// @sa https://json.nlohmann.me/api/basic_json/items/
2861	/// @deprecated This function is deprecated since 3.1.0 and will be removed in
2862	/// version 4.0.0 of the library. Please use @ref items() instead;
2863	/// that is, replace `json::iterator_wrapper(j)` with `j.items()`.
2864	JSON_HEDLEY_DEPRECATED_FOR(`3.1.0`, items())
2865	static iteration_proxy<iterator> iterator_wrapper(reference ref) noexcept
2866	{
2867	return ref.items();
2868	}
2869
2870	/// @brief wrapper to access iterator member functions in range-based for
2871	/// @sa https://json.nlohmann.me/api/basic_json/items/
2872	/// @deprecated This function is deprecated since 3.1.0 and will be removed in
2873	/// version 4.0.0 of the library. Please use @ref items() instead;
2874	/// that is, replace `json::iterator_wrapper(j)` with `j.items()`.
2875	JSON_HEDLEY_DEPRECATED_FOR(`3.1.0`, items())
2876	static iteration_proxy<const_iterator> iterator_wrapper(const_reference ref) noexcept
2877	{
2878	return ref.items();
2879	}
2880
2881	/// @brief helper to access iterator member functions in range-based for
2882	/// @sa https://json.nlohmann.me/api/basic_json/items/
2883	iteration_proxy<iterator> items() noexcept
2884	{
2885	return iteration_proxy<iterator>(*this);
2886	}
2887
2888	/// @brief helper to access iterator member functions in range-based for
2889	/// @sa https://json.nlohmann.me/api/basic_json/items/
2890	iteration_proxy<const_iterator> items() const noexcept
2891	{
2892	return iteration_proxy<const_iterator>(*this);
2893	}
2894
2895	/// @}
2896
2897	//////////////
2898	// capacity //
2899	//////////////
2900
2901	/// @name capacity
2902	/// @{
2903
2904	/// @brief checks whether the container is empty.
2905	/// @sa https://json.nlohmann.me/api/basic_json/empty/
2906	bool empty() const noexcept
2907	{
2908	switch (m_data.m_type)
2909	{
2910	case value_t::null:
2911	{
2912	// null values are empty
2913	return true;
2914	}
2915
2916	case value_t::array:
2917	{
2918	// delegate call to array_t::empty()
2919	return m_data.m_value.array->empty();
2920	}
2921
2922	case value_t::object:
2923	{
2924	// delegate call to object_t::empty()
2925	return m_data.m_value.object->empty();
2926	}
2927
2928	case value_t::string:
2929	case value_t::boolean:
2930	case value_t::number_integer:
2931	case value_t::number_unsigned:
2932	case value_t::number_float:
2933	case value_t::binary:
2934	case value_t::discarded:
2935	default:
2936	{
2937	// all other types are nonempty
2938	return false;
2939	}
2940	}
2941	}
2942
2943	/// @brief returns the number of elements
2944	/// @sa https://json.nlohmann.me/api/basic_json/size/
2945	size_type size() const noexcept
2946	{
2947	switch (m_data.m_type)
2948	{
2949	case value_t::null:
2950	{
2951	// null values are empty
2952	return `0`;
2953	}
2954
2955	case value_t::array:
2956	{
2957	// delegate call to array_t::size()
2958	return m_data.m_value.array->size();
2959	}
2960
2961	case value_t::object:
2962	{
2963	// delegate call to object_t::size()
2964	return m_data.m_value.object->size();
2965	}
2966
2967	case value_t::string:
2968	case value_t::boolean:
2969	case value_t::number_integer:
2970	case value_t::number_unsigned:
2971	case value_t::number_float:
2972	case value_t::binary:
2973	case value_t::discarded:
2974	default:
2975	{
2976	// all other types have size 1
2977	return `1`;
2978	}
2979	}
2980	}
2981
2982	/// @brief returns the maximum possible number of elements
2983	/// @sa https://json.nlohmann.me/api/basic_json/max_size/
2984	size_type max_size() const noexcept
2985	{
2986	switch (m_data.m_type)
2987	{
2988	case value_t::array:
2989	{
2990	// delegate call to array_t::max_size()
2991	return m_data.m_value.array->max_size();
2992	}
2993
2994	case value_t::object:
2995	{
2996	// delegate call to object_t::max_size()
2997	return m_data.m_value.object->max_size();
2998	}
2999
3000	case value_t::null:
3001	case value_t::string:
3002	case value_t::boolean:
3003	case value_t::number_integer:
3004	case value_t::number_unsigned:
3005	case value_t::number_float:
3006	case value_t::binary:
3007	case value_t::discarded:
3008	default:
3009	{
3010	// all other types have max_size() == size()
3011	return size();
3012	}
3013	}
3014	}
3015
3016	/// @}
3017
3018	///////////////
3019	// modifiers //
3020	///////////////
3021
3022	/// @name modifiers
3023	/// @{
3024
3025	/// @brief clears the contents
3026	/// @sa https://json.nlohmann.me/api/basic_json/clear/
3027	void clear() noexcept
3028	{
3029	switch (m_data.m_type)
3030	{
3031	case value_t::number_integer:
3032	{
3033	m_data.m_value.number_integer = `0`;
3034	break;
3035	}
3036
3037	case value_t::number_unsigned:
3038	{
3039	m_data.m_value.number_unsigned = `0`;
3040	break;
3041	}
3042
3043	case value_t::number_float:
3044	{
3045	m_data.m_value.number_float = `0.0`;
3046	break;
3047	}
3048
3049	case value_t::boolean:
3050	{
3051	m_data.m_value.boolean = false;
3052	break;
3053	}
3054
3055	case value_t::string:
3056	{
3057	m_data.m_value.string->clear();
3058	break;
3059	}
3060
3061	case value_t::binary:
3062	{
3063	m_data.m_value.binary->clear();
3064	break;
3065	}
3066
3067	case value_t::array:
3068	{
3069	m_data.m_value.array->clear();
3070	break;
3071	}
3072
3073	case value_t::object:
3074	{
3075	m_data.m_value.object->clear();
3076	break;
3077	}
3078
3079	case value_t::null:
3080	case value_t::discarded:
3081	default:
3082	break;
3083	}
3084	}
3085
3086	/// @brief add an object to an array
3087	/// @sa https://json.nlohmann.me/api/basic_json/push_back/
3088	void push_back(basic_json&& val)
3089	{
3090	// push_back only works for null objects or arrays
3091	if (JSON_HEDLEY_UNLIKELY(!(is_null() \|\| is_array())))
3092	{
3093	JSON_THROW(type_error::create(`308`, detail::concat("cannot use push_back() with ", type_name()), this));
3094	}
3095
3096	// transform null object into an array
3097	if (is_null())
3098	{
3099	m_data.m_type = value_t::array;
3100	m_data.m_value = value_t::array;
3101	assert_invariant();
3102	}
3103
3104	// add element to array (move semantics)
3105	const auto old_capacity = m_data.m_value.array->capacity();
3106	m_data.m_value.array->push_back(std::move(val));
3107	set_parent(j&: m_data.m_value.array->back(), old_capacity);
3108	// if val is moved from, basic_json move constructor marks it null, so we do not call the destructor
3109	}
3110
3111	/// @brief add an object to an array
3112	/// @sa https://json.nlohmann.me/api/basic_json/operator+=/
3113	reference operator+=(basic_json&& val)
3114	{
3115	push_back(std::move(val));
3116	return *this;
3117	}
3118
3119	/// @brief add an object to an array
3120	/// @sa https://json.nlohmann.me/api/basic_json/push_back/
3121	void push_back(const basic_json& val)
3122	{
3123	// push_back only works for null objects or arrays
3124	if (JSON_HEDLEY_UNLIKELY(!(is_null() \|\| is_array())))
3125	{
3126	JSON_THROW(type_error::create(`308`, detail::concat("cannot use push_back() with ", type_name()), this));
3127	}
3128
3129	// transform null object into an array
3130	if (is_null())
3131	{
3132	m_data.m_type = value_t::array;
3133	m_data.m_value = value_t::array;
3134	assert_invariant();
3135	}
3136
3137	// add element to array
3138	const auto old_capacity = m_data.m_value.array->capacity();
3139	m_data.m_value.array->push_back(val);
3140	set_parent(j&: m_data.m_value.array->back(), old_capacity);
3141	}
3142
3143	/// @brief add an object to an array
3144	/// @sa https://json.nlohmann.me/api/basic_json/operator+=/
3145	reference operator+=(const basic_json& val)
3146	{
3147	push_back(val);
3148	return *this;
3149	}
3150
3151	/// @brief add an object to an object
3152	/// @sa https://json.nlohmann.me/api/basic_json/push_back/
3153	void push_back(const typename object_t::value_type& val)
3154	{
3155	// push_back only works for null objects or objects
3156	if (JSON_HEDLEY_UNLIKELY(!(is_null() \|\| is_object())))
3157	{
3158	JSON_THROW(type_error::create(`308`, detail::concat("cannot use push_back() with ", type_name()), this));
3159	}
3160
3161	// transform null object into an object
3162	if (is_null())
3163	{
3164	m_data.m_type = value_t::object;
3165	m_data.m_value = value_t::object;
3166	assert_invariant();
3167	}
3168
3169	// add element to object
3170	auto res = m_data.m_value.object->insert(val);
3171	set_parent(j&: res.first->second);
3172	}
3173
3174	/// @brief add an object to an object
3175	/// @sa https://json.nlohmann.me/api/basic_json/operator+=/
3176	reference operator+=(const typename object_t::value_type& val)
3177	{
3178	push_back(val);
3179	return *this;
3180	}
3181
3182	/// @brief add an object to an object
3183	/// @sa https://json.nlohmann.me/api/basic_json/push_back/
3184	void push_back(initializer_list_t init)
3185	{
3186	if (is_object() && init.size() == `2` && (*init.begin())->is_string())
3187	{
3188	basic_json&& key = init.begin()->moved_or_copied();
3189	push_back(typename object_t::value_type(
3190	std::move(key.get_ref<string_t&>()), (init.begin() + `1`)->moved_or_copied()));
3191	}
3192	else
3193	{
3194	push_back(basic_json(init));
3195	}
3196	}
3197
3198	/// @brief add an object to an object
3199	/// @sa https://json.nlohmann.me/api/basic_json/operator+=/
3200	reference operator+=(initializer_list_t init)
3201	{
3202	push_back(init);
3203	return *this;
3204	}
3205
3206	/// @brief add an object to an array
3207	/// @sa https://json.nlohmann.me/api/basic_json/emplace_back/
3208	template<class... Args>
3209	reference emplace_back(Args&& ... args)
3210	{
3211	// emplace_back only works for null objects or arrays
3212	if (JSON_HEDLEY_UNLIKELY(!(is_null() \|\| is_array())))
3213	{
3214	JSON_THROW(type_error::create(`311`, detail::concat("cannot use emplace_back() with ", type_name()), this));
3215	}
3216
3217	// transform null object into an array
3218	if (is_null())
3219	{
3220	m_data.m_type = value_t::array;
3221	m_data.m_value = value_t::array;
3222	assert_invariant();
3223	}
3224
3225	// add element to array (perfect forwarding)
3226	const auto old_capacity = m_data.m_value.array->capacity();
3227	m_data.m_value.array->emplace_back(std::forward<Args>(args)...);
3228	return set_parent(j&: m_data.m_value.array->back(), old_capacity);
3229	}
3230
3231	/// @brief add an object to an object if key does not exist
3232	/// @sa https://json.nlohmann.me/api/basic_json/emplace/
3233	template<class... Args>
3234	std::pair<iterator, bool> emplace(Args&& ... args)
3235	{
3236	// emplace only works for null objects or arrays
3237	if (JSON_HEDLEY_UNLIKELY(!(is_null() \|\| is_object())))
3238	{
3239	JSON_THROW(type_error::create(`311`, detail::concat("cannot use emplace() with ", type_name()), this));
3240	}
3241
3242	// transform null object into an object
3243	if (is_null())
3244	{
3245	m_data.m_type = value_t::object;
3246	m_data.m_value = value_t::object;
3247	assert_invariant();
3248	}
3249
3250	// add element to array (perfect forwarding)
3251	auto res = m_data.m_value.object->emplace(std::forward<Args>(args)...);
3252	set_parent(j&: res.first->second);
3253
3254	// create result iterator and set iterator to the result of emplace
3255	auto it = begin();
3256	it.m_it.object_iterator = res.first;
3257
3258	// return pair of iterator and boolean
3259	return {it, res.second};
3260	}
3261
3262	/// Helper for insertion of an iterator
3263	/// @note: This uses std::distance to support GCC 4.8,
3264	/// see https://github.com/nlohmann/json/pull/1257
3265	template<typename... Args>
3266	iterator insert_iterator(const_iterator pos, Args&& ... args)
3267	{
3268	iterator result(this);
3269	JSON_ASSERT(m_data.m_value.array != nullptr);
3270
3271	auto insert_pos = std::distance(m_data.m_value.array->begin(), pos.m_it.array_iterator);
3272	m_data.m_value.array->insert(pos.m_it.array_iterator, std::forward<Args>(args)...);
3273	result.m_it.array_iterator = m_data.m_value.array->begin() + insert_pos;
3274
3275	// This could have been written as:
3276	// result.m_it.array_iterator = m_data.m_value.array->insert(pos.m_it.array_iterator, cnt, val);
3277	// but the return value of insert is missing in GCC 4.8, so it is written this way instead.
3278
3279	set_parents();
3280	return result;
3281	}
3282
3283	/// @brief inserts element into array
3284	/// @sa https://json.nlohmann.me/api/basic_json/insert/
3285	iterator insert(const_iterator pos, const basic_json& val)
3286	{
3287	// insert only works for arrays
3288	if (JSON_HEDLEY_LIKELY(is_array()))
3289	{
3290	// check if iterator pos fits to this JSON value
3291	if (JSON_HEDLEY_UNLIKELY(pos.m_object != this))
3292	{
3293	JSON_THROW(invalid_iterator::create(`202`, "iterator does not fit current value", this));
3294	}
3295
3296	// insert to array and return iterator
3297	return insert_iterator(pos, val);
3298	}
3299
3300	JSON_THROW(type_error::create(`309`, detail::concat("cannot use insert() with ", type_name()), this));
3301	}
3302
3303	/// @brief inserts element into array
3304	/// @sa https://json.nlohmann.me/api/basic_json/insert/
3305	iterator insert(const_iterator pos, basic_json&& val)
3306	{
3307	return insert(pos, val);
3308	}
3309
3310	/// @brief inserts copies of element into array
3311	/// @sa https://json.nlohmann.me/api/basic_json/insert/
3312	iterator insert(const_iterator pos, size_type cnt, const basic_json& val)
3313	{
3314	// insert only works for arrays
3315	if (JSON_HEDLEY_LIKELY(is_array()))
3316	{
3317	// check if iterator pos fits to this JSON value
3318	if (JSON_HEDLEY_UNLIKELY(pos.m_object != this))
3319	{
3320	JSON_THROW(invalid_iterator::create(`202`, "iterator does not fit current value", this));
3321	}
3322
3323	// insert to array and return iterator
3324	return insert_iterator(pos, cnt, val);
3325	}
3326
3327	JSON_THROW(type_error::create(`309`, detail::concat("cannot use insert() with ", type_name()), this));
3328	}
3329
3330	/// @brief inserts range of elements into array
3331	/// @sa https://json.nlohmann.me/api/basic_json/insert/
3332	iterator insert(const_iterator pos, const_iterator first, const_iterator last)
3333	{
3334	// insert only works for arrays
3335	if (JSON_HEDLEY_UNLIKELY(!is_array()))
3336	{
3337	JSON_THROW(type_error::create(`309`, detail::concat("cannot use insert() with ", type_name()), this));
3338	}
3339
3340	// check if iterator pos fits to this JSON value
3341	if (JSON_HEDLEY_UNLIKELY(pos.m_object != this))
3342	{
3343	JSON_THROW(invalid_iterator::create(`202`, "iterator does not fit current value", this));
3344	}
3345
3346	// check if range iterators belong to the same JSON object
3347	if (JSON_HEDLEY_UNLIKELY(first.m_object != last.m_object))
3348	{
3349	JSON_THROW(invalid_iterator::create(`210`, "iterators do not fit", this));
3350	}
3351
3352	if (JSON_HEDLEY_UNLIKELY(first.m_object == this))
3353	{
3354	JSON_THROW(invalid_iterator::create(`211`, "passed iterators may not belong to container", this));
3355	}
3356
3357	// insert to array and return iterator
3358	return insert_iterator(pos, first.m_it.array_iterator, last.m_it.array_iterator);
3359	}
3360
3361	/// @brief inserts elements from initializer list into array
3362	/// @sa https://json.nlohmann.me/api/basic_json/insert/
3363	iterator insert(const_iterator pos, initializer_list_t ilist)
3364	{
3365	// insert only works for arrays
3366	if (JSON_HEDLEY_UNLIKELY(!is_array()))
3367	{
3368	JSON_THROW(type_error::create(`309`, detail::concat("cannot use insert() with ", type_name()), this));
3369	}
3370
3371	// check if iterator pos fits to this JSON value
3372	if (JSON_HEDLEY_UNLIKELY(pos.m_object != this))
3373	{
3374	JSON_THROW(invalid_iterator::create(`202`, "iterator does not fit current value", this));
3375	}
3376
3377	// insert to array and return iterator
3378	return insert_iterator(pos, ilist.begin(), ilist.end());
3379	}
3380
3381	/// @brief inserts range of elements into object
3382	/// @sa https://json.nlohmann.me/api/basic_json/insert/
3383	void insert(const_iterator first, const_iterator last)
3384	{
3385	// insert only works for objects
3386	if (JSON_HEDLEY_UNLIKELY(!is_object()))
3387	{
3388	JSON_THROW(type_error::create(`309`, detail::concat("cannot use insert() with ", type_name()), this));
3389	}
3390
3391	// check if range iterators belong to the same JSON object
3392	if (JSON_HEDLEY_UNLIKELY(first.m_object != last.m_object))
3393	{
3394	JSON_THROW(invalid_iterator::create(`210`, "iterators do not fit", this));
3395	}
3396
3397	// passed iterators must belong to objects
3398	if (JSON_HEDLEY_UNLIKELY(!first.m_object->is_object()))
3399	{
3400	JSON_THROW(invalid_iterator::create(`202`, "iterators first and last must point to objects", this));
3401	}
3402
3403	m_data.m_value.object->insert(first.m_it.object_iterator, last.m_it.object_iterator);
3404	}
3405
3406	/// @brief updates a JSON object from another object, overwriting existing keys
3407	/// @sa https://json.nlohmann.me/api/basic_json/update/
3408	void update(const_reference j, bool merge_objects = false)
3409	{
3410	update(j.begin(), j.end(), merge_objects);
3411	}
3412
3413	/// @brief updates a JSON object from another object, overwriting existing keys
3414	/// @sa https://json.nlohmann.me/api/basic_json/update/
3415	void update(const_iterator first, const_iterator last, bool merge_objects = false)
3416	{
3417	// implicitly convert null value to an empty object
3418	if (is_null())
3419	{
3420	m_data.m_type = value_t::object;
3421	m_data.m_value.object = create<object_t>();
3422	assert_invariant();
3423	}
3424
3425	if (JSON_HEDLEY_UNLIKELY(!is_object()))
3426	{
3427	JSON_THROW(type_error::create(`312`, detail::concat("cannot use update() with ", type_name()), this));
3428	}
3429
3430	// check if range iterators belong to the same JSON object
3431	if (JSON_HEDLEY_UNLIKELY(first.m_object != last.m_object))
3432	{
3433	JSON_THROW(invalid_iterator::create(`210`, "iterators do not fit", this));
3434	}
3435
3436	// passed iterators must belong to objects
3437	if (JSON_HEDLEY_UNLIKELY(!first.m_object->is_object()))
3438	{
3439	JSON_THROW(type_error::create(`312`, detail::concat("cannot use update() with ", first.m_object->type_name()), first.m_object));
3440	}
3441
3442	for (auto it = first; it != last; ++it)
3443	{
3444	if (merge_objects && it.value().is_object())
3445	{
3446	auto it2 = m_data.m_value.object->find(it.key());
3447	if (it2 != m_data.m_value.object->end())
3448	{
3449	it2->second.update(it.value(), true);
3450	continue;
3451	}
3452	}
3453	m_data.m_value.object->operator[](it.key()) = it.value();
3454	#if JSON_DIAGNOSTICS
3455	m_data.m_value.object->operator[](it.key()).m_parent = this;
3456	#endif
3457	}
3458	}
3459
3460	/// @brief exchanges the values
3461	/// @sa https://json.nlohmann.me/api/basic_json/swap/
3462	void swap(reference other) noexcept (
3463	std::is_nothrow_move_constructible<value_t>::value&&
3464	std::is_nothrow_move_assignable<value_t>::value&&
3465	std::is_nothrow_move_constructible<json_value>::value&& // NOLINT(cppcoreguidelines-noexcept-swap,performance-noexcept-swap)
3466	std::is_nothrow_move_assignable<json_value>::value
3467	)
3468	{
3469	std::swap(m_data.m_type, other.m_data.m_type);
3470	std::swap(m_data.m_value, other.m_data.m_value);
3471
3472	set_parents();
3473	other.set_parents();
3474	assert_invariant();
3475	}
3476
3477	/// @brief exchanges the values
3478	/// @sa https://json.nlohmann.me/api/basic_json/swap/
3479	friend void swap(reference left, reference right) noexcept (
3480	std::is_nothrow_move_constructible<value_t>::value&&
3481	std::is_nothrow_move_assignable<value_t>::value&&
3482	std::is_nothrow_move_constructible<json_value>::value&& // NOLINT(cppcoreguidelines-noexcept-swap,performance-noexcept-swap)
3483	std::is_nothrow_move_assignable<json_value>::value
3484	)
3485	{
3486	left.swap(right);
3487	}
3488
3489	/// @brief exchanges the values
3490	/// @sa https://json.nlohmann.me/api/basic_json/swap/
3491	void swap(array_t& other) // NOLINT(bugprone-exception-escape,cppcoreguidelines-noexcept-swap,performance-noexcept-swap)
3492	{
3493	// swap only works for arrays
3494	if (JSON_HEDLEY_LIKELY(is_array()))
3495	{
3496	using std::swap;
3497	swap(*(m_data.m_value.array), other);
3498	}
3499	else
3500	{
3501	JSON_THROW(type_error::create(`310`, detail::concat("cannot use swap(array_t&) with ", type_name()), this));
3502	}
3503	}
3504
3505	/// @brief exchanges the values
3506	/// @sa https://json.nlohmann.me/api/basic_json/swap/
3507	void swap(object_t& other) // NOLINT(bugprone-exception-escape,cppcoreguidelines-noexcept-swap,performance-noexcept-swap)
3508	{
3509	// swap only works for objects
3510	if (JSON_HEDLEY_LIKELY(is_object()))
3511	{
3512	using std::swap;
3513	swap(*(m_data.m_value.object), other);
3514	}
3515	else
3516	{
3517	JSON_THROW(type_error::create(`310`, detail::concat("cannot use swap(object_t&) with ", type_name()), this));
3518	}
3519	}
3520
3521	/// @brief exchanges the values
3522	/// @sa https://json.nlohmann.me/api/basic_json/swap/
3523	void swap(string_t& other) // NOLINT(bugprone-exception-escape,cppcoreguidelines-noexcept-swap,performance-noexcept-swap)
3524	{
3525	// swap only works for strings
3526	if (JSON_HEDLEY_LIKELY(is_string()))
3527	{
3528	using std::swap;
3529	swap(*(m_data.m_value.string), other);
3530	}
3531	else
3532	{
3533	JSON_THROW(type_error::create(`310`, detail::concat("cannot use swap(string_t&) with ", type_name()), this));
3534	}
3535	}
3536
3537	/// @brief exchanges the values
3538	/// @sa https://json.nlohmann.me/api/basic_json/swap/
3539	void swap(binary_t& other) // NOLINT(bugprone-exception-escape,cppcoreguidelines-noexcept-swap,performance-noexcept-swap)
3540	{
3541	// swap only works for strings
3542	if (JSON_HEDLEY_LIKELY(is_binary()))
3543	{
3544	using std::swap;
3545	swap(*(m_data.m_value.binary), other);
3546	}
3547	else
3548	{
3549	JSON_THROW(type_error::create(`310`, detail::concat("cannot use swap(binary_t&) with ", type_name()), this));
3550	}
3551	}
3552
3553	/// @brief exchanges the values
3554	/// @sa https://json.nlohmann.me/api/basic_json/swap/
3555	void swap(typename binary_t::container_type& other) // NOLINT(bugprone-exception-escape)
3556	{
3557	// swap only works for strings
3558	if (JSON_HEDLEY_LIKELY(is_binary()))
3559	{
3560	using std::swap;
3561	swap(*(m_data.m_value.binary), other);
3562	}
3563	else
3564	{
3565	JSON_THROW(type_error::create(`310`, detail::concat("cannot use swap(binary_t::container_type&) with ", type_name()), this));
3566	}
3567	}
3568
3569	/// @}
3570
3571	//////////////////////////////////////////
3572	// lexicographical comparison operators //
3573	//////////////////////////////////////////
3574
3575	/// @name lexicographical comparison operators
3576	/// @{
3577
3578	// note parentheses around operands are necessary; see
3579	// https://github.com/nlohmann/json/issues/1530
3580	#define JSON_IMPLEMENT_OPERATOR(op, null_result, unordered_result, default_result) \
3581	const auto lhs_type = lhs.type(); \
3582	const auto rhs_type = rhs.type(); \
3583	\
3584	if (lhs_type == rhs_type) /* NOLINT(readability/braces) */ \
3585	{ \
3586	switch (lhs_type) \
3587	{ \
3588	case value_t::array: \
3589	return (lhs.m_data.m_value.array) op (rhs.m_data.m_value.array); \
3590	\
3591	case value_t::object: \
3592	return (lhs.m_data.m_value.object) op (rhs.m_data.m_value.object); \
3593	\
3594	case value_t::null: \
3595	return (null_result); \
3596	\
3597	case value_t::string: \
3598	return (lhs.m_data.m_value.string) op (rhs.m_data.m_value.string); \
3599	\
3600	case value_t::boolean: \
3601	return (lhs.m_data.m_value.boolean) op (rhs.m_data.m_value.boolean); \
3602	\
3603	case value_t::number_integer: \
3604	return (lhs.m_data.m_value.number_integer) op (rhs.m_data.m_value.number_integer); \
3605	\
3606	case value_t::number_unsigned: \
3607	return (lhs.m_data.m_value.number_unsigned) op (rhs.m_data.m_value.number_unsigned); \
3608	\
3609	case value_t::number_float: \
3610	return (lhs.m_data.m_value.number_float) op (rhs.m_data.m_value.number_float); \
3611	\
3612	case value_t::binary: \
3613	return (lhs.m_data.m_value.binary) op (rhs.m_data.m_value.binary); \
3614	\
3615	case value_t::discarded: \
3616	default: \
3617	return (unordered_result); \
3618	} \
3619	} \
3620	else if (lhs_type == value_t::number_integer && rhs_type == value_t::number_float) \
3621	{ \
3622	return static_cast<number_float_t>(lhs.m_data.m_value.number_integer) op rhs.m_data.m_value.number_float; \
3623	} \
3624	else if (lhs_type == value_t::number_float && rhs_type == value_t::number_integer) \
3625	{ \
3626	return lhs.m_data.m_value.number_float op static_cast<number_float_t>(rhs.m_data.m_value.number_integer); \
3627	} \
3628	else if (lhs_type == value_t::number_unsigned && rhs_type == value_t::number_float) \
3629	{ \
3630	return static_cast<number_float_t>(lhs.m_data.m_value.number_unsigned) op rhs.m_data.m_value.number_float; \
3631	} \
3632	else if (lhs_type == value_t::number_float && rhs_type == value_t::number_unsigned) \
3633	{ \
3634	return lhs.m_data.m_value.number_float op static_cast<number_float_t>(rhs.m_data.m_value.number_unsigned); \
3635	} \
3636	else if (lhs_type == value_t::number_unsigned && rhs_type == value_t::number_integer) \
3637	{ \
3638	return static_cast<number_integer_t>(lhs.m_data.m_value.number_unsigned) op rhs.m_data.m_value.number_integer; \
3639	} \
3640	else if (lhs_type == value_t::number_integer && rhs_type == value_t::number_unsigned) \
3641	{ \
3642	return lhs.m_data.m_value.number_integer op static_cast<number_integer_t>(rhs.m_data.m_value.number_unsigned); \
3643	} \
3644	else if(compares_unordered(lhs, rhs))\
3645	{\
3646	return (unordered_result);\
3647	}\
3648	\
3649	return (default_result);
3650
3651	JSON_PRIVATE_UNLESS_TESTED:
3652	// returns true if:
3653	// - any operand is NaN and the other operand is of number type
3654	// - any operand is discarded
3655	// in legacy mode, discarded values are considered ordered if
3656	// an operation is computed as an odd number of inverses of others
3657	static bool compares_unordered(const_reference lhs, const_reference rhs, bool inverse = false) noexcept
3658	{
3659	if ((lhs.is_number_float() && std::isnan(lhs.m_data.m_value.number_float) && rhs.is_number())
3660	\|\| (rhs.is_number_float() && std::isnan(rhs.m_data.m_value.number_float) && lhs.is_number()))
3661	{
3662	return true;
3663	}
3664	#if JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON
3665	return (lhs.is_discarded() \|\| rhs.is_discarded()) && !inverse;
3666	#else
3667	static_cast<void>(inverse);
3668	return lhs.is_discarded() \|\| rhs.is_discarded();
3669	#endif
3670	}
3671
3672	private:
3673	bool compares_unordered(const_reference rhs, bool inverse = false) const noexcept
3674	{
3675	return compares_unordered(*this, rhs, inverse);
3676	}
3677
3678	public:
3679	#if JSON_HAS_THREE_WAY_COMPARISON
3680	/// @brief comparison: equal
3681	/// @sa https://json.nlohmann.me/api/basic_json/operator_eq/
3682	bool operator==(const_reference rhs) const noexcept
3683	{
3684	#ifdef __GNUC__
3685	#pragma GCC diagnostic push
3686	#pragma GCC diagnostic ignored "-Wfloat-equal"
3687	#endif
3688	const_reference lhs = *this;
3689	JSON_IMPLEMENT_OPERATOR( ==, true, false, false)
3690	#ifdef __GNUC__
3691	#pragma GCC diagnostic pop
3692	#endif
3693	}
3694
3695	/// @brief comparison: equal
3696	/// @sa https://json.nlohmann.me/api/basic_json/operator_eq/
3697	template<typename ScalarType>
3698	requires std::is_scalar_v<ScalarType>
3699	bool operator==(ScalarType rhs) const noexcept
3700	{
3701	return *this == basic_json(rhs);
3702	}
3703
3704	/// @brief comparison: not equal
3705	/// @sa https://json.nlohmann.me/api/basic_json/operator_ne/
3706	bool operator!=(const_reference rhs) const noexcept
3707	{
3708	if (compares_unordered(rhs, true))
3709	{
3710	return false;
3711	}
3712	return !operator==(rhs);
3713	}
3714
3715	/// @brief comparison: 3-way
3716	/// @sa https://json.nlohmann.me/api/basic_json/operator_spaceship/
3717	std::partial_ordering operator<=>(const_reference rhs) const noexcept // NOPAD
3718	{
3719	const_reference lhs = *this;
3720	// default_result is used if we cannot compare values. In that case,
3721	// we compare types.
3722	JSON_IMPLEMENT_OPERATOR(<=>, // NOPAD
3723	std::partial_ordering::equivalent,
3724	std::partial_ordering::unordered,
3725	lhs_type <=> rhs_type) // NOPAD
3726	}
3727
3728	/// @brief comparison: 3-way
3729	/// @sa https://json.nlohmann.me/api/basic_json/operator_spaceship/
3730	template<typename ScalarType>
3731	requires std::is_scalar_v<ScalarType>
3732	std::partial_ordering operator<=>(ScalarType rhs) const noexcept // NOPAD
3733	{
3734	return *this <=> basic_json(rhs); // NOPAD
3735	}
3736
3737	#if JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON
3738	// all operators that are computed as an odd number of inverses of others
3739	// need to be overloaded to emulate the legacy comparison behavior
3740
3741	/// @brief comparison: less than or equal
3742	/// @sa https://json.nlohmann.me/api/basic_json/operator_le/
3743	JSON_HEDLEY_DEPRECATED_FOR(`3.11.0`, undef JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON)
3744	bool operator<=(const_reference rhs) const noexcept
3745	{
3746	if (compares_unordered(rhs, true))
3747	{
3748	return false;
3749	}
3750	return !(rhs < *this);
3751	}
3752
3753	/// @brief comparison: less than or equal
3754	/// @sa https://json.nlohmann.me/api/basic_json/operator_le/
3755	template<typename ScalarType>
3756	requires std::is_scalar_v<ScalarType>
3757	bool operator<=(ScalarType rhs) const noexcept
3758	{
3759	return *this <= basic_json(rhs);
3760	}
3761
3762	/// @brief comparison: greater than or equal
3763	/// @sa https://json.nlohmann.me/api/basic_json/operator_ge/
3764	JSON_HEDLEY_DEPRECATED_FOR(`3.11.0`, undef JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON)
3765	bool operator>=(const_reference rhs) const noexcept
3766	{
3767	if (compares_unordered(rhs, true))
3768	{
3769	return false;
3770	}
3771	return !(*this < rhs);
3772	}
3773
3774	/// @brief comparison: greater than or equal
3775	/// @sa https://json.nlohmann.me/api/basic_json/operator_ge/
3776	template<typename ScalarType>
3777	requires std::is_scalar_v<ScalarType>
3778	bool operator>=(ScalarType rhs) const noexcept
3779	{
3780	return *this >= basic_json(rhs);
3781	}
3782	#endif
3783	#else
3784	/// @brief comparison: equal
3785	/// @sa https://json.nlohmann.me/api/basic_json/operator_eq/
3786	friend bool operator==(const_reference lhs, const_reference rhs) noexcept
3787	{
3788	#ifdef __GNUC__
3789	#pragma GCC diagnostic push
3790	#pragma GCC diagnostic ignored "-Wfloat-equal"
3791	#endif
3792	JSON_IMPLEMENT_OPERATOR( ==, true, false, false)
3793	#ifdef __GNUC__
3794	#pragma GCC diagnostic pop
3795	#endif
3796	}
3797
3798	/// @brief comparison: equal
3799	/// @sa https://json.nlohmann.me/api/basic_json/operator_eq/
3800	template<typename ScalarType, typename std::enable_if<
3801	std::is_scalar<ScalarType>::value, int>::type = `0`>
3802	friend bool operator==(const_reference lhs, ScalarType rhs) noexcept
3803	{
3804	return lhs == basic_json(rhs);
3805	}
3806
3807	/// @brief comparison: equal
3808	/// @sa https://json.nlohmann.me/api/basic_json/operator_eq/
3809	template<typename ScalarType, typename std::enable_if<
3810	std::is_scalar<ScalarType>::value, int>::type = `0`>
3811	friend bool operator==(ScalarType lhs, const_reference rhs) noexcept
3812	{
3813	return basic_json(lhs) == rhs;
3814	}
3815
3816	/// @brief comparison: not equal
3817	/// @sa https://json.nlohmann.me/api/basic_json/operator_ne/
3818	friend bool operator!=(const_reference lhs, const_reference rhs) noexcept
3819	{
3820	if (compares_unordered(lhs, rhs, true))
3821	{
3822	return false;
3823	}
3824	return !(lhs == rhs);
3825	}
3826
3827	/// @brief comparison: not equal
3828	/// @sa https://json.nlohmann.me/api/basic_json/operator_ne/
3829	template<typename ScalarType, typename std::enable_if<
3830	std::is_scalar<ScalarType>::value, int>::type = `0`>
3831	friend bool operator!=(const_reference lhs, ScalarType rhs) noexcept
3832	{
3833	return lhs != basic_json(rhs);
3834	}
3835
3836	/// @brief comparison: not equal
3837	/// @sa https://json.nlohmann.me/api/basic_json/operator_ne/
3838	template<typename ScalarType, typename std::enable_if<
3839	std::is_scalar<ScalarType>::value, int>::type = `0`>
3840	friend bool operator!=(ScalarType lhs, const_reference rhs) noexcept
3841	{
3842	return basic_json(lhs) != rhs;
3843	}
3844
3845	/// @brief comparison: less than
3846	/// @sa https://json.nlohmann.me/api/basic_json/operator_lt/
3847	friend bool operator<(const_reference lhs, const_reference rhs) noexcept
3848	{
3849	// default_result is used if we cannot compare values. In that case,
3850	// we compare types. Note we have to call the operator explicitly,
3851	// because MSVC has problems otherwise.
3852	JSON_IMPLEMENT_OPERATOR( <, false, false, operator<(lhs_type, rhs_type))
3853	}
3854
3855	/// @brief comparison: less than
3856	/// @sa https://json.nlohmann.me/api/basic_json/operator_lt/
3857	template<typename ScalarType, typename std::enable_if<
3858	std::is_scalar<ScalarType>::value, int>::type = `0`>
3859	friend bool operator<(const_reference lhs, ScalarType rhs) noexcept
3860	{
3861	return lhs < basic_json(rhs);
3862	}
3863
3864	/// @brief comparison: less than
3865	/// @sa https://json.nlohmann.me/api/basic_json/operator_lt/
3866	template<typename ScalarType, typename std::enable_if<
3867	std::is_scalar<ScalarType>::value, int>::type = `0`>
3868	friend bool operator<(ScalarType lhs, const_reference rhs) noexcept
3869	{
3870	return basic_json(lhs) < rhs;
3871	}
3872
3873	/// @brief comparison: less than or equal
3874	/// @sa https://json.nlohmann.me/api/basic_json/operator_le/
3875	friend bool operator<=(const_reference lhs, const_reference rhs) noexcept
3876	{
3877	if (compares_unordered(lhs, rhs, true))
3878	{
3879	return false;
3880	}
3881	return !(rhs < lhs);
3882	}
3883
3884	/// @brief comparison: less than or equal
3885	/// @sa https://json.nlohmann.me/api/basic_json/operator_le/
3886	template<typename ScalarType, typename std::enable_if<
3887	std::is_scalar<ScalarType>::value, int>::type = `0`>
3888	friend bool operator<=(const_reference lhs, ScalarType rhs) noexcept
3889	{
3890	return lhs <= basic_json(rhs);
3891	}
3892
3893	/// @brief comparison: less than or equal
3894	/// @sa https://json.nlohmann.me/api/basic_json/operator_le/
3895	template<typename ScalarType, typename std::enable_if<
3896	std::is_scalar<ScalarType>::value, int>::type = `0`>
3897	friend bool operator<=(ScalarType lhs, const_reference rhs) noexcept
3898	{
3899	return basic_json(lhs) <= rhs;
3900	}
3901
3902	/// @brief comparison: greater than
3903	/// @sa https://json.nlohmann.me/api/basic_json/operator_gt/
3904	friend bool operator>(const_reference lhs, const_reference rhs) noexcept
3905	{
3906	// double inverse
3907	if (compares_unordered(lhs, rhs))
3908	{
3909	return false;
3910	}
3911	return !(lhs <= rhs);
3912	}
3913
3914	/// @brief comparison: greater than
3915	/// @sa https://json.nlohmann.me/api/basic_json/operator_gt/
3916	template<typename ScalarType, typename std::enable_if<
3917	std::is_scalar<ScalarType>::value, int>::type = `0`>
3918	friend bool operator>(const_reference lhs, ScalarType rhs) noexcept
3919	{
3920	return lhs > basic_json(rhs);
3921	}
3922
3923	/// @brief comparison: greater than
3924	/// @sa https://json.nlohmann.me/api/basic_json/operator_gt/
3925	template<typename ScalarType, typename std::enable_if<
3926	std::is_scalar<ScalarType>::value, int>::type = `0`>
3927	friend bool operator>(ScalarType lhs, const_reference rhs) noexcept
3928	{
3929	return basic_json(lhs) > rhs;
3930	}
3931
3932	/// @brief comparison: greater than or equal
3933	/// @sa https://json.nlohmann.me/api/basic_json/operator_ge/
3934	friend bool operator>=(const_reference lhs, const_reference rhs) noexcept
3935	{
3936	if (compares_unordered(lhs, rhs, true))
3937	{
3938	return false;
3939	}
3940	return !(lhs < rhs);
3941	}
3942
3943	/// @brief comparison: greater than or equal
3944	/// @sa https://json.nlohmann.me/api/basic_json/operator_ge/
3945	template<typename ScalarType, typename std::enable_if<
3946	std::is_scalar<ScalarType>::value, int>::type = `0`>
3947	friend bool operator>=(const_reference lhs, ScalarType rhs) noexcept
3948	{
3949	return lhs >= basic_json(rhs);
3950	}
3951
3952	/// @brief comparison: greater than or equal
3953	/// @sa https://json.nlohmann.me/api/basic_json/operator_ge/
3954	template<typename ScalarType, typename std::enable_if<
3955	std::is_scalar<ScalarType>::value, int>::type = `0`>
3956	friend bool operator>=(ScalarType lhs, const_reference rhs) noexcept
3957	{
3958	return basic_json(lhs) >= rhs;
3959	}
3960	#endif
3961
3962	#undef JSON_IMPLEMENT_OPERATOR
3963
3964	/// @}
3965
3966	///////////////////
3967	// serialization //
3968	///////////////////
3969
3970	/// @name serialization
3971	/// @{
3972	#ifndef JSON_NO_IO
3973	/// @brief serialize to stream
3974	/// @sa https://json.nlohmann.me/api/basic_json/operator_ltlt/
3975	friend std::ostream& operator<<(std::ostream& o, const basic_json& j)
3976	{
3977	// read width member and use it as indentation parameter if nonzero
3978	const bool pretty_print = o.width() > `0`;
3979	const auto indentation = pretty_print ? o.width() : `0`;
3980
3981	// reset width to 0 for subsequent calls to this stream
3982	o.width(wide: `0`);
3983
3984	// do the actual serialization
3985	serializer s(detail::output_adapter<char>(o), o.fill());
3986	s.dump(j, pretty_print, false, static_cast<unsigned int>(indentation));
3987	return o;
3988	}
3989
3990	/// @brief serialize to stream
3991	/// @sa https://json.nlohmann.me/api/basic_json/operator_ltlt/
3992	/// @deprecated This function is deprecated since 3.0.0 and will be removed in
3993	/// version 4.0.0 of the library. Please use
3994	/// operator<<(std::ostream&, const basic_json&) instead; that is,
3995	/// replace calls like `j >> o;` with `o << j;`.
3996	JSON_HEDLEY_DEPRECATED_FOR(`3.0.0`, operator<<(std::ostream&, const basic_json&))
3997	friend std::ostream& operator>>(const basic_json& j, std::ostream& o)
3998	{
3999	return o << j;
4000	}
4001	#endif // JSON_NO_IO
4002	/// @}
4003
4004	/////////////////////
4005	// deserialization //
4006	/////////////////////
4007
4008	/// @name deserialization
4009	/// @{
4010
4011	/// @brief deserialize from a compatible input
4012	/// @sa https://json.nlohmann.me/api/basic_json/parse/
4013	template<typename InputType>
4014	JSON_HEDLEY_WARN_UNUSED_RESULT
4015	static basic_json parse(InputType&& i,
4016	const parser_callback_t cb = nullptr,
4017	const bool allow_exceptions = true,
4018	const bool ignore_comments = false)
4019	{
4020	basic_json result;
4021	parser(detail::input_adapter(std::forward<InputType>(i)), cb, allow_exceptions, ignore_comments).parse(true, result);
4022	return result;
4023	}
4024
4025	/// @brief deserialize from a pair of character iterators
4026	/// @sa https://json.nlohmann.me/api/basic_json/parse/
4027	template<typename IteratorType>
4028	JSON_HEDLEY_WARN_UNUSED_RESULT
4029	static basic_json parse(IteratorType first,
4030	IteratorType last,
4031	const parser_callback_t cb = nullptr,
4032	const bool allow_exceptions = true,
4033	const bool ignore_comments = false)
4034	{
4035	basic_json result;
4036	parser(detail::input_adapter(std::move(first), std::move(last)), cb, allow_exceptions, ignore_comments).parse(true, result);
4037	return result;
4038	}
4039
4040	JSON_HEDLEY_WARN_UNUSED_RESULT
4041	JSON_HEDLEY_DEPRECATED_FOR(`3.8.0`, parse(ptr, ptr + len))
4042	static basic_json parse(detail::span_input_adapter&& i,
4043	const parser_callback_t cb = nullptr,
4044	const bool allow_exceptions = true,
4045	const bool ignore_comments = false)
4046	{
4047	basic_json result;
4048	parser(i.get(), cb, allow_exceptions, ignore_comments).parse(true, result);
4049	return result;
4050	}
4051
4052	/// @brief check if the input is valid JSON
4053	/// @sa https://json.nlohmann.me/api/basic_json/accept/
4054	template<typename InputType>
4055	static bool accept(InputType&& i,
4056	const bool ignore_comments = false)
4057	{
4058	return parser(detail::input_adapter(std::forward<InputType>(i)), nullptr, false, ignore_comments).accept(true);
4059	}
4060
4061	/// @brief check if the input is valid JSON
4062	/// @sa https://json.nlohmann.me/api/basic_json/accept/
4063	template<typename IteratorType>
4064	static bool accept(IteratorType first, IteratorType last,
4065	const bool ignore_comments = false)
4066	{
4067	return parser(detail::input_adapter(std::move(first), std::move(last)), nullptr, false, ignore_comments).accept(true);
4068	}
4069
4070	JSON_HEDLEY_WARN_UNUSED_RESULT
4071	JSON_HEDLEY_DEPRECATED_FOR(`3.8.0`, accept(ptr, ptr + len))
4072	static bool accept(detail::span_input_adapter&& i,
4073	const bool ignore_comments = false)
4074	{
4075	return parser(i.get(), nullptr, false, ignore_comments).accept(true);
4076	}
4077
4078	/// @brief generate SAX events
4079	/// @sa https://json.nlohmann.me/api/basic_json/sax_parse/
4080	template <typename InputType, typename SAX>
4081	JSON_HEDLEY_NON_NULL(`2`)
4082	static bool sax_parse(InputType&& i, SAX* sax,
4083	input_format_t format = input_format_t::json,
4084	const bool strict = true,
4085	const bool ignore_comments = false)
4086	{
4087	auto ia = detail::input_adapter(std::forward<InputType>(i));
4088	return format == input_format_t::json
4089	? parser(std::move(ia), nullptr, true, ignore_comments).sax_parse(sax, strict)
4090	: detail::binary_reader<basic_json, decltype(ia), SAX>(std::move(ia), format).sax_parse(format, sax, strict);
4091	}
4092
4093	/// @brief generate SAX events
4094	/// @sa https://json.nlohmann.me/api/basic_json/sax_parse/
4095	template<class IteratorType, class SAX>
4096	JSON_HEDLEY_NON_NULL(`3`)
4097	static bool sax_parse(IteratorType first, IteratorType last, SAX* sax,
4098	input_format_t format = input_format_t::json,
4099	const bool strict = true,
4100	const bool ignore_comments = false)
4101	{
4102	auto ia = detail::input_adapter(std::move(first), std::move(last));
4103	return format == input_format_t::json
4104	? parser(std::move(ia), nullptr, true, ignore_comments).sax_parse(sax, strict)
4105	: detail::binary_reader<basic_json, decltype(ia), SAX>(std::move(ia), format).sax_parse(format, sax, strict);
4106	}
4107
4108	/// @brief generate SAX events
4109	/// @sa https://json.nlohmann.me/api/basic_json/sax_parse/
4110	/// @deprecated This function is deprecated since 3.8.0 and will be removed in
4111	/// version 4.0.0 of the library. Please use
4112	/// sax_parse(ptr, ptr + len) instead.
4113	template <typename SAX>
4114	JSON_HEDLEY_DEPRECATED_FOR(`3.8.0`, sax_parse(ptr, ptr + len, ...))
4115	JSON_HEDLEY_NON_NULL(`2`)
4116	static bool sax_parse(detail::span_input_adapter&& i, SAX* sax,
4117	input_format_t format = input_format_t::json,
4118	const bool strict = true,
4119	const bool ignore_comments = false)
4120	{
4121	auto ia = i.get();
4122	return format == input_format_t::json
4123	// NOLINTNEXTLINE(hicpp-move-const-arg,performance-move-const-arg)
4124	? parser(std::move(ia), nullptr, true, ignore_comments).sax_parse(sax, strict)
4125	// NOLINTNEXTLINE(hicpp-move-const-arg,performance-move-const-arg)
4126	: detail::binary_reader<basic_json, decltype(ia), SAX>(std::move(ia), format).sax_parse(format, sax, strict);
4127	}
4128	#ifndef JSON_NO_IO
4129	/// @brief deserialize from stream
4130	/// @sa https://json.nlohmann.me/api/basic_json/operator_gtgt/
4131	/// @deprecated This stream operator is deprecated since 3.0.0 and will be removed in
4132	/// version 4.0.0 of the library. Please use
4133	/// operator>>(std::istream&, basic_json&) instead; that is,
4134	/// replace calls like `j << i;` with `i >> j;`.
4135	JSON_HEDLEY_DEPRECATED_FOR(`3.0.0`, operator>>(std::istream&, basic_json&))
4136	friend std::istream& operator<<(basic_json& j, std::istream& i)
4137	{
4138	return operator>>(i, j);
4139	}
4140
4141	/// @brief deserialize from stream
4142	/// @sa https://json.nlohmann.me/api/basic_json/operator_gtgt/
4143	friend std::istream& operator>>(std::istream& i, basic_json& j)
4144	{
4145	parser(detail::input_adapter(stream&: i)).parse(false, j);
4146	return i;
4147	}
4148	#endif // JSON_NO_IO
4149	/// @}
4150
4151	///////////////////////////
4152	// convenience functions //
4153	///////////////////////////
4154
4155	/// @brief return the type as string
4156	/// @sa https://json.nlohmann.me/api/basic_json/type_name/
4157	JSON_HEDLEY_RETURNS_NON_NULL
4158	const char* type_name() const noexcept
4159	{
4160	switch (m_data.m_type)
4161	{
4162	case value_t::null:
4163	return "null";
4164	case value_t::object:
4165	return "object";
4166	case value_t::array:
4167	return "array";
4168	case value_t::string:
4169	return "string";
4170	case value_t::boolean:
4171	return "boolean";
4172	case value_t::binary:
4173	return "binary";
4174	case value_t::discarded:
4175	return "discarded";
4176	case value_t::number_integer:
4177	case value_t::number_unsigned:
4178	case value_t::number_float:
4179	default:
4180	return "number";
4181	}
4182	}
4183
4184	JSON_PRIVATE_UNLESS_TESTED:
4185	//////////////////////
4186	// member variables //
4187	//////////////////////
4188
4189	struct data
4190	{
4191	/// the type of the current element
4192	value_t m_type = value_t::null;
4193
4194	/// the value of the current element
4195	json_value m_value = {};
4196
4197	data(const value_t v)
4198	: m_type(v), m_value(v)
4199	{
4200	}
4201
4202	data(size_type cnt, const basic_json& val)
4203	: m_type(value_t::array)
4204	{
4205	m_value.array = create<array_t>(cnt, val);
4206	}
4207
4208	data() noexcept = default;
4209	data(data&&) noexcept = default;
4210	data(const data&) noexcept = delete;
4211	data& operator=(data&&) noexcept = delete;
4212	data& operator=(const data&) noexcept = delete;
4213
4214	~data() noexcept
4215	{
4216	m_value.destroy(m_type);
4217	}
4218	};
4219
4220	data m_data = {};
4221
4222	#if JSON_DIAGNOSTICS
4223	/// a pointer to a parent value (for debugging purposes)
4224	basic_json* m_parent = nullptr;
4225	#endif
4226
4227	//////////////////////////////////////////
4228	// binary serialization/deserialization //
4229	//////////////////////////////////////////
4230
4231	/// @name binary serialization/deserialization support
4232	/// @{
4233
4234	public:
4235	/// @brief create a CBOR serialization of a given JSON value
4236	/// @sa https://json.nlohmann.me/api/basic_json/to_cbor/
4237	static std::vector<std::uint8_t> to_cbor(const basic_json& j)
4238	{
4239	std::vector<std::uint8_t> result;
4240	to_cbor(j, result);
4241	return result;
4242	}
4243
4244	/// @brief create a CBOR serialization of a given JSON value
4245	/// @sa https://json.nlohmann.me/api/basic_json/to_cbor/
4246	static void to_cbor(const basic_json& j, detail::output_adapter<std::uint8_t> o)
4247	{
4248	binary_writer<std::uint8_t>(o).write_cbor(j);
4249	}
4250
4251	/// @brief create a CBOR serialization of a given JSON value
4252	/// @sa https://json.nlohmann.me/api/basic_json/to_cbor/
4253	static void to_cbor(const basic_json& j, detail::output_adapter<char> o)
4254	{
4255	binary_writer<char>(o).write_cbor(j);
4256	}
4257
4258	/// @brief create a MessagePack serialization of a given JSON value
4259	/// @sa https://json.nlohmann.me/api/basic_json/to_msgpack/
4260	static std::vector<std::uint8_t> to_msgpack(const basic_json& j)
4261	{
4262	std::vector<std::uint8_t> result;
4263	to_msgpack(j, result);
4264	return result;
4265	}
4266
4267	/// @brief create a MessagePack serialization of a given JSON value
4268	/// @sa https://json.nlohmann.me/api/basic_json/to_msgpack/
4269	static void to_msgpack(const basic_json& j, detail::output_adapter<std::uint8_t> o)
4270	{
4271	binary_writer<std::uint8_t>(o).write_msgpack(j);
4272	}
4273
4274	/// @brief create a MessagePack serialization of a given JSON value
4275	/// @sa https://json.nlohmann.me/api/basic_json/to_msgpack/
4276	static void to_msgpack(const basic_json& j, detail::output_adapter<char> o)
4277	{
4278	binary_writer<char>(o).write_msgpack(j);
4279	}
4280
4281	/// @brief create a UBJSON serialization of a given JSON value
4282	/// @sa https://json.nlohmann.me/api/basic_json/to_ubjson/
4283	static std::vector<std::uint8_t> to_ubjson(const basic_json& j,
4284	const bool use_size = false,
4285	const bool use_type = false)
4286	{
4287	std::vector<std::uint8_t> result;
4288	to_ubjson(j, result, use_size, use_type);
4289	return result;
4290	}
4291
4292	/// @brief create a UBJSON serialization of a given JSON value
4293	/// @sa https://json.nlohmann.me/api/basic_json/to_ubjson/
4294	static void to_ubjson(const basic_json& j, detail::output_adapter<std::uint8_t> o,
4295	const bool use_size = false, const bool use_type = false)
4296	{
4297	binary_writer<std::uint8_t>(o).write_ubjson(j, use_size, use_type);
4298	}
4299
4300	/// @brief create a UBJSON serialization of a given JSON value
4301	/// @sa https://json.nlohmann.me/api/basic_json/to_ubjson/
4302	static void to_ubjson(const basic_json& j, detail::output_adapter<char> o,
4303	const bool use_size = false, const bool use_type = false)
4304	{
4305	binary_writer<char>(o).write_ubjson(j, use_size, use_type);
4306	}
4307
4308	/// @brief create a BJData serialization of a given JSON value
4309	/// @sa https://json.nlohmann.me/api/basic_json/to_bjdata/
4310	static std::vector<std::uint8_t> to_bjdata(const basic_json& j,
4311	const bool use_size = false,
4312	const bool use_type = false)
4313	{
4314	std::vector<std::uint8_t> result;
4315	to_bjdata(j, result, use_size, use_type);
4316	return result;
4317	}
4318
4319	/// @brief create a BJData serialization of a given JSON value
4320	/// @sa https://json.nlohmann.me/api/basic_json/to_bjdata/
4321	static void to_bjdata(const basic_json& j, detail::output_adapter<std::uint8_t> o,
4322	const bool use_size = false, const bool use_type = false)
4323	{
4324	binary_writer<std::uint8_t>(o).write_ubjson(j, use_size, use_type, true, true);
4325	}
4326
4327	/// @brief create a BJData serialization of a given JSON value
4328	/// @sa https://json.nlohmann.me/api/basic_json/to_bjdata/
4329	static void to_bjdata(const basic_json& j, detail::output_adapter<char> o,
4330	const bool use_size = false, const bool use_type = false)
4331	{
4332	binary_writer<char>(o).write_ubjson(j, use_size, use_type, true, true);
4333	}
4334
4335	/// @brief create a BSON serialization of a given JSON value
4336	/// @sa https://json.nlohmann.me/api/basic_json/to_bson/
4337	static std::vector<std::uint8_t> to_bson(const basic_json& j)
4338	{
4339	std::vector<std::uint8_t> result;
4340	to_bson(j, result);
4341	return result;
4342	}
4343
4344	/// @brief create a BSON serialization of a given JSON value
4345	/// @sa https://json.nlohmann.me/api/basic_json/to_bson/
4346	static void to_bson(const basic_json& j, detail::output_adapter<std::uint8_t> o)
4347	{
4348	binary_writer<std::uint8_t>(o).write_bson(j);
4349	}
4350
4351	/// @brief create a BSON serialization of a given JSON value
4352	/// @sa https://json.nlohmann.me/api/basic_json/to_bson/
4353	static void to_bson(const basic_json& j, detail::output_adapter<char> o)
4354	{
4355	binary_writer<char>(o).write_bson(j);
4356	}
4357
4358	/// @brief create a JSON value from an input in CBOR format
4359	/// @sa https://json.nlohmann.me/api/basic_json/from_cbor/
4360	template<typename InputType>
4361	JSON_HEDLEY_WARN_UNUSED_RESULT
4362	static basic_json from_cbor(InputType&& i,
4363	const bool strict = true,
4364	const bool allow_exceptions = true,
4365	const cbor_tag_handler_t tag_handler = cbor_tag_handler_t::error)
4366	{
4367	basic_json result;
4368	detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
4369	auto ia = detail::input_adapter(std::forward<InputType>(i));
4370	const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::cbor).sax_parse(input_format_t::cbor, &sdp, strict, tag_handler);
4371	return res ? result : basic_json(value_t::discarded);
4372	}
4373
4374	/// @brief create a JSON value from an input in CBOR format
4375	/// @sa https://json.nlohmann.me/api/basic_json/from_cbor/
4376	template<typename IteratorType>
4377	JSON_HEDLEY_WARN_UNUSED_RESULT
4378	static basic_json from_cbor(IteratorType first, IteratorType last,
4379	const bool strict = true,
4380	const bool allow_exceptions = true,
4381	const cbor_tag_handler_t tag_handler = cbor_tag_handler_t::error)
4382	{
4383	basic_json result;
4384	detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
4385	auto ia = detail::input_adapter(std::move(first), std::move(last));
4386	const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::cbor).sax_parse(input_format_t::cbor, &sdp, strict, tag_handler);
4387	return res ? result : basic_json(value_t::discarded);
4388	}
4389
4390	template<typename T>
4391	JSON_HEDLEY_WARN_UNUSED_RESULT
4392	JSON_HEDLEY_DEPRECATED_FOR(`3.8.0`, from_cbor(ptr, ptr + len))
4393	static basic_json from_cbor(const T* ptr, std::size_t len,
4394	const bool strict = true,
4395	const bool allow_exceptions = true,
4396	const cbor_tag_handler_t tag_handler = cbor_tag_handler_t::error)
4397	{
4398	return from_cbor(ptr, ptr + len, strict, allow_exceptions, tag_handler);
4399	}
4400
4401	JSON_HEDLEY_WARN_UNUSED_RESULT
4402	JSON_HEDLEY_DEPRECATED_FOR(`3.8.0`, from_cbor(ptr, ptr + len))
4403	static basic_json from_cbor(detail::span_input_adapter&& i,
4404	const bool strict = true,
4405	const bool allow_exceptions = true,
4406	const cbor_tag_handler_t tag_handler = cbor_tag_handler_t::error)
4407	{
4408	basic_json result;
4409	detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
4410	auto ia = i.get();
4411	// NOLINTNEXTLINE(hicpp-move-const-arg,performance-move-const-arg)
4412	const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::cbor).sax_parse(input_format_t::cbor, &sdp, strict, tag_handler);
4413	return res ? result : basic_json(value_t::discarded);
4414	}
4415
4416	/// @brief create a JSON value from an input in MessagePack format
4417	/// @sa https://json.nlohmann.me/api/basic_json/from_msgpack/
4418	template<typename InputType>
4419	JSON_HEDLEY_WARN_UNUSED_RESULT
4420	static basic_json from_msgpack(InputType&& i,
4421	const bool strict = true,
4422	const bool allow_exceptions = true)
4423	{
4424	basic_json result;
4425	detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
4426	auto ia = detail::input_adapter(std::forward<InputType>(i));
4427	const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::msgpack).sax_parse(input_format_t::msgpack, &sdp, strict);
4428	return res ? result : basic_json(value_t::discarded);
4429	}
4430
4431	/// @brief create a JSON value from an input in MessagePack format
4432	/// @sa https://json.nlohmann.me/api/basic_json/from_msgpack/
4433	template<typename IteratorType>
4434	JSON_HEDLEY_WARN_UNUSED_RESULT
4435	static basic_json from_msgpack(IteratorType first, IteratorType last,
4436	const bool strict = true,
4437	const bool allow_exceptions = true)
4438	{
4439	basic_json result;
4440	detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
4441	auto ia = detail::input_adapter(std::move(first), std::move(last));
4442	const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::msgpack).sax_parse(input_format_t::msgpack, &sdp, strict);
4443	return res ? result : basic_json(value_t::discarded);
4444	}
4445
4446	template<typename T>
4447	JSON_HEDLEY_WARN_UNUSED_RESULT
4448	JSON_HEDLEY_DEPRECATED_FOR(`3.8.0`, from_msgpack(ptr, ptr + len))
4449	static basic_json from_msgpack(const T* ptr, std::size_t len,
4450	const bool strict = true,
4451	const bool allow_exceptions = true)
4452	{
4453	return from_msgpack(ptr, ptr + len, strict, allow_exceptions);
4454	}
4455
4456	JSON_HEDLEY_WARN_UNUSED_RESULT
4457	JSON_HEDLEY_DEPRECATED_FOR(`3.8.0`, from_msgpack(ptr, ptr + len))
4458	static basic_json from_msgpack(detail::span_input_adapter&& i,
4459	const bool strict = true,
4460	const bool allow_exceptions = true)
4461	{
4462	basic_json result;
4463	detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
4464	auto ia = i.get();
4465	// NOLINTNEXTLINE(hicpp-move-const-arg,performance-move-const-arg)
4466	const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::msgpack).sax_parse(input_format_t::msgpack, &sdp, strict);
4467	return res ? result : basic_json(value_t::discarded);
4468	}
4469
4470	/// @brief create a JSON value from an input in UBJSON format
4471	/// @sa https://json.nlohmann.me/api/basic_json/from_ubjson/
4472	template<typename InputType>
4473	JSON_HEDLEY_WARN_UNUSED_RESULT
4474	static basic_json from_ubjson(InputType&& i,
4475	const bool strict = true,
4476	const bool allow_exceptions = true)
4477	{
4478	basic_json result;
4479	detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
4480	auto ia = detail::input_adapter(std::forward<InputType>(i));
4481	const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::ubjson).sax_parse(input_format_t::ubjson, &sdp, strict);
4482	return res ? result : basic_json(value_t::discarded);
4483	}
4484
4485	/// @brief create a JSON value from an input in UBJSON format
4486	/// @sa https://json.nlohmann.me/api/basic_json/from_ubjson/
4487	template<typename IteratorType>
4488	JSON_HEDLEY_WARN_UNUSED_RESULT
4489	static basic_json from_ubjson(IteratorType first, IteratorType last,
4490	const bool strict = true,
4491	const bool allow_exceptions = true)
4492	{
4493	basic_json result;
4494	detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
4495	auto ia = detail::input_adapter(std::move(first), std::move(last));
4496	const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::ubjson).sax_parse(input_format_t::ubjson, &sdp, strict);
4497	return res ? result : basic_json(value_t::discarded);
4498	}
4499
4500	template<typename T>
4501	JSON_HEDLEY_WARN_UNUSED_RESULT
4502	JSON_HEDLEY_DEPRECATED_FOR(`3.8.0`, from_ubjson(ptr, ptr + len))
4503	static basic_json from_ubjson(const T* ptr, std::size_t len,
4504	const bool strict = true,
4505	const bool allow_exceptions = true)
4506	{
4507	return from_ubjson(ptr, ptr + len, strict, allow_exceptions);
4508	}
4509
4510	JSON_HEDLEY_WARN_UNUSED_RESULT
4511	JSON_HEDLEY_DEPRECATED_FOR(`3.8.0`, from_ubjson(ptr, ptr + len))
4512	static basic_json from_ubjson(detail::span_input_adapter&& i,
4513	const bool strict = true,
4514	const bool allow_exceptions = true)
4515	{
4516	basic_json result;
4517	detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
4518	auto ia = i.get();
4519	// NOLINTNEXTLINE(hicpp-move-const-arg,performance-move-const-arg)
4520	const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::ubjson).sax_parse(input_format_t::ubjson, &sdp, strict);
4521	return res ? result : basic_json(value_t::discarded);
4522	}
4523
4524	/// @brief create a JSON value from an input in BJData format
4525	/// @sa https://json.nlohmann.me/api/basic_json/from_bjdata/
4526	template<typename InputType>
4527	JSON_HEDLEY_WARN_UNUSED_RESULT
4528	static basic_json from_bjdata(InputType&& i,
4529	const bool strict = true,
4530	const bool allow_exceptions = true)
4531	{
4532	basic_json result;
4533	detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
4534	auto ia = detail::input_adapter(std::forward<InputType>(i));
4535	const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::bjdata).sax_parse(input_format_t::bjdata, &sdp, strict);
4536	return res ? result : basic_json(value_t::discarded);
4537	}
4538
4539	/// @brief create a JSON value from an input in BJData format
4540	/// @sa https://json.nlohmann.me/api/basic_json/from_bjdata/
4541	template<typename IteratorType>
4542	JSON_HEDLEY_WARN_UNUSED_RESULT
4543	static basic_json from_bjdata(IteratorType first, IteratorType last,
4544	const bool strict = true,
4545	const bool allow_exceptions = true)
4546	{
4547	basic_json result;
4548	detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
4549	auto ia = detail::input_adapter(std::move(first), std::move(last));
4550	const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::bjdata).sax_parse(input_format_t::bjdata, &sdp, strict);
4551	return res ? result : basic_json(value_t::discarded);
4552	}
4553
4554	/// @brief create a JSON value from an input in BSON format
4555	/// @sa https://json.nlohmann.me/api/basic_json/from_bson/
4556	template<typename InputType>
4557	JSON_HEDLEY_WARN_UNUSED_RESULT
4558	static basic_json from_bson(InputType&& i,
4559	const bool strict = true,
4560	const bool allow_exceptions = true)
4561	{
4562	basic_json result;
4563	detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
4564	auto ia = detail::input_adapter(std::forward<InputType>(i));
4565	const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::bson).sax_parse(input_format_t::bson, &sdp, strict);
4566	return res ? result : basic_json(value_t::discarded);
4567	}
4568
4569	/// @brief create a JSON value from an input in BSON format
4570	/// @sa https://json.nlohmann.me/api/basic_json/from_bson/
4571	template<typename IteratorType>
4572	JSON_HEDLEY_WARN_UNUSED_RESULT
4573	static basic_json from_bson(IteratorType first, IteratorType last,
4574	const bool strict = true,
4575	const bool allow_exceptions = true)
4576	{
4577	basic_json result;
4578	detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
4579	auto ia = detail::input_adapter(std::move(first), std::move(last));
4580	const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::bson).sax_parse(input_format_t::bson, &sdp, strict);
4581	return res ? result : basic_json(value_t::discarded);
4582	}
4583
4584	template<typename T>
4585	JSON_HEDLEY_WARN_UNUSED_RESULT
4586	JSON_HEDLEY_DEPRECATED_FOR(`3.8.0`, from_bson(ptr, ptr + len))
4587	static basic_json from_bson(const T* ptr, std::size_t len,
4588	const bool strict = true,
4589	const bool allow_exceptions = true)
4590	{
4591	return from_bson(ptr, ptr + len, strict, allow_exceptions);
4592	}
4593
4594	JSON_HEDLEY_WARN_UNUSED_RESULT
4595	JSON_HEDLEY_DEPRECATED_FOR(`3.8.0`, from_bson(ptr, ptr + len))
4596	static basic_json from_bson(detail::span_input_adapter&& i,
4597	const bool strict = true,
4598	const bool allow_exceptions = true)
4599	{
4600	basic_json result;
4601	detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
4602	auto ia = i.get();
4603	// NOLINTNEXTLINE(hicpp-move-const-arg,performance-move-const-arg)
4604	const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::bson).sax_parse(input_format_t::bson, &sdp, strict);
4605	return res ? result : basic_json(value_t::discarded);
4606	}
4607	/// @}
4608
4609	//////////////////////////
4610	// JSON Pointer support //
4611	//////////////////////////
4612
4613	/// @name JSON Pointer functions
4614	/// @{
4615
4616	/// @brief access specified element via JSON Pointer
4617	/// @sa https://json.nlohmann.me/api/basic_json/operator%5B%5D/
4618	reference operator[](const json_pointer& ptr)
4619	{
4620	return ptr.get_unchecked(this);
4621	}
4622
4623	template<typename BasicJsonType, detail::enable_if_t<detail::is_basic_json<BasicJsonType>::value, int> = `0`>
4624	JSON_HEDLEY_DEPRECATED_FOR(`3.11.0`, basic_json::json_pointer or nlohmann::json_pointer<basic_json::string_t>) // NOLINT(readability/alt_tokens)
4625	reference operator[](const ::nlohmann::json_pointer<BasicJsonType>& ptr)
4626	{
4627	return ptr.get_unchecked(this);
4628	}
4629
4630	/// @brief access specified element via JSON Pointer
4631	/// @sa https://json.nlohmann.me/api/basic_json/operator%5B%5D/
4632	const_reference operator[](const json_pointer& ptr) const
4633	{
4634	return ptr.get_unchecked(this);
4635	}
4636
4637	template<typename BasicJsonType, detail::enable_if_t<detail::is_basic_json<BasicJsonType>::value, int> = `0`>
4638	JSON_HEDLEY_DEPRECATED_FOR(`3.11.0`, basic_json::json_pointer or nlohmann::json_pointer<basic_json::string_t>) // NOLINT(readability/alt_tokens)
4639	const_reference operator[](const ::nlohmann::json_pointer<BasicJsonType>& ptr) const
4640	{
4641	return ptr.get_unchecked(this);
4642	}
4643
4644	/// @brief access specified element via JSON Pointer
4645	/// @sa https://json.nlohmann.me/api/basic_json/at/
4646	reference at(const json_pointer& ptr)
4647	{
4648	return ptr.get_checked(this);
4649	}
4650
4651	template<typename BasicJsonType, detail::enable_if_t<detail::is_basic_json<BasicJsonType>::value, int> = `0`>
4652	JSON_HEDLEY_DEPRECATED_FOR(`3.11.0`, basic_json::json_pointer or nlohmann::json_pointer<basic_json::string_t>) // NOLINT(readability/alt_tokens)
4653	reference at(const ::nlohmann::json_pointer<BasicJsonType>& ptr)
4654	{
4655	return ptr.get_checked(this);
4656	}
4657
4658	/// @brief access specified element via JSON Pointer
4659	/// @sa https://json.nlohmann.me/api/basic_json/at/
4660	const_reference at(const json_pointer& ptr) const
4661	{
4662	return ptr.get_checked(this);
4663	}
4664
4665	template<typename BasicJsonType, detail::enable_if_t<detail::is_basic_json<BasicJsonType>::value, int> = `0`>
4666	JSON_HEDLEY_DEPRECATED_FOR(`3.11.0`, basic_json::json_pointer or nlohmann::json_pointer<basic_json::string_t>) // NOLINT(readability/alt_tokens)
4667	const_reference at(const ::nlohmann::json_pointer<BasicJsonType>& ptr) const
4668	{
4669	return ptr.get_checked(this);
4670	}
4671
4672	/// @brief return flattened JSON value
4673	/// @sa https://json.nlohmann.me/api/basic_json/flatten/
4674	basic_json flatten() const
4675	{
4676	basic_json result(value_t::object);
4677	json_pointer::flatten("", *this, result);
4678	return result;
4679	}
4680
4681	/// @brief unflatten a previously flattened JSON value
4682	/// @sa https://json.nlohmann.me/api/basic_json/unflatten/
4683	basic_json unflatten() const
4684	{
4685	return json_pointer::unflatten(*this);
4686	}
4687
4688	/// @}
4689
4690	//////////////////////////
4691	// JSON Patch functions //
4692	//////////////////////////
4693
4694	/// @name JSON Patch functions
4695	/// @{
4696
4697	/// @brief applies a JSON patch in-place without copying the object
4698	/// @sa https://json.nlohmann.me/api/basic_json/patch/
4699	void patch_inplace(const basic_json& json_patch)
4700	{
4701	basic_json& result = *this;
4702	// the valid JSON Patch operations
4703	enum class patch_operations {add, remove, replace, move, copy, test, invalid};
4704
4705	const auto get_op = [](const std::string & op)
4706	{
4707	if (op == "add")
4708	{
4709	return patch_operations::add;
4710	}
4711	if (op == "remove")
4712	{
4713	return patch_operations::remove;
4714	}
4715	if (op == "replace")
4716	{
4717	return patch_operations::replace;
4718	}
4719	if (op == "move")
4720	{
4721	return patch_operations::move;
4722	}
4723	if (op == "copy")
4724	{
4725	return patch_operations::copy;
4726	}
4727	if (op == "test")
4728	{
4729	return patch_operations::test;
4730	}
4731
4732	return patch_operations::invalid;
4733	};
4734
4735	// wrapper for "add" operation; add value at ptr
4736	const auto operation_add = [&result](json_pointer & ptr, basic_json val)
4737	{
4738	// adding to the root of the target document means replacing it
4739	if (ptr.empty())
4740	{
4741	result = val;
4742	return;
4743	}
4744
4745	// make sure the top element of the pointer exists
4746	json_pointer const top_pointer = ptr.top();
4747	if (top_pointer != ptr)
4748	{
4749	result.at(top_pointer);
4750	}
4751
4752	// get reference to parent of JSON pointer ptr
4753	const auto last_path = ptr.back();
4754	ptr.pop_back();
4755	// parent must exist when performing patch add per RFC6902 specs
4756	basic_json& parent = result.at(ptr);
4757
4758	switch (parent.m_data.m_type)
4759	{
4760	case value_t::null:
4761	case value_t::object:
4762	{
4763	// use operator[] to add value
4764	parent[last_path] = val;
4765	break;
4766	}
4767
4768	case value_t::array:
4769	{
4770	if (last_path == "-")
4771	{
4772	// special case: append to back
4773	parent.push_back(val);
4774	}
4775	else
4776	{
4777	const auto idx = json_pointer::template array_index<basic_json_t>(last_path);
4778	if (JSON_HEDLEY_UNLIKELY(idx > parent.size()))
4779	{
4780	// avoid undefined behavior
4781	JSON_THROW(out_of_range::create(`401`, detail::concat("array index ", std::to_string(idx), " is out of range"), &parent));
4782	}
4783
4784	// default case: insert add offset
4785	parent.insert(parent.begin() + static_cast<difference_type>(idx), val);
4786	}
4787	break;
4788	}
4789
4790	// if there exists a parent it cannot be primitive
4791	case value_t::string: // LCOV_EXCL_LINE
4792	case value_t::boolean: // LCOV_EXCL_LINE
4793	case value_t::number_integer: // LCOV_EXCL_LINE
4794	case value_t::number_unsigned: // LCOV_EXCL_LINE
4795	case value_t::number_float: // LCOV_EXCL_LINE
4796	case value_t::binary: // LCOV_EXCL_LINE
4797	case value_t::discarded: // LCOV_EXCL_LINE
4798	default: // LCOV_EXCL_LINE
4799	JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert) LCOV_EXCL_LINE
4800	}
4801	};
4802
4803	// wrapper for "remove" operation; remove value at ptr
4804	const auto operation_remove = [this, & result](json_pointer & ptr)
4805	{
4806	// get reference to parent of JSON pointer ptr
4807	const auto last_path = ptr.back();
4808	ptr.pop_back();
4809	basic_json& parent = result.at(ptr);
4810
4811	// remove child
4812	if (parent.is_object())
4813	{
4814	// perform range check
4815	auto it = parent.find(last_path);
4816	if (JSON_HEDLEY_LIKELY(it != parent.end()))
4817	{
4818	parent.erase(it);
4819	}
4820	else
4821	{
4822	JSON_THROW(out_of_range::create(`403`, detail::concat("key '", last_path, "' not found"), this));
4823	}
4824	}
4825	else if (parent.is_array())
4826	{
4827	// note erase performs range check
4828	parent.erase(json_pointer::template array_index<basic_json_t>(last_path));
4829	}
4830	};
4831
4832	// type check: top level value must be an array
4833	if (JSON_HEDLEY_UNLIKELY(!json_patch.is_array()))
4834	{
4835	JSON_THROW(parse_error::create(`104`, `0`, "JSON patch must be an array of objects", &json_patch));
4836	}
4837
4838	// iterate and apply the operations
4839	for (const auto& val : json_patch)
4840	{
4841	// wrapper to get a value for an operation
4842	const auto get_value = [&val](const std::string & op,
4843	const std::string & member,
4844	bool string_type) -> basic_json &
4845	{
4846	// find value
4847	auto it = val.m_data.m_value.object->find(member);
4848
4849	// context-sensitive error message
4850	const auto error_msg = (op == "op") ? "operation" : detail::concat(args: "operation '", args: op, args: `'\''`);
4851
4852	// check if desired value is present
4853	if (JSON_HEDLEY_UNLIKELY(it == val.m_data.m_value.object->end()))
4854	{
4855	// NOLINTNEXTLINE(performance-inefficient-string-concatenation)
4856	JSON_THROW(parse_error::create(`105`, `0`, detail::concat(error_msg, " must have member '", member, "'"), &val));
4857	}
4858
4859	// check if result is of type string
4860	if (JSON_HEDLEY_UNLIKELY(string_type && !it->second.is_string()))
4861	{
4862	// NOLINTNEXTLINE(performance-inefficient-string-concatenation)
4863	JSON_THROW(parse_error::create(`105`, `0`, detail::concat(error_msg, " must have string member '", member, "'"), &val));
4864	}
4865
4866	// no error: return value
4867	return it->second;
4868	};
4869
4870	// type check: every element of the array must be an object
4871	if (JSON_HEDLEY_UNLIKELY(!val.is_object()))
4872	{
4873	JSON_THROW(parse_error::create(`104`, `0`, "JSON patch must be an array of objects", &val));
4874	}
4875
4876	// collect mandatory members
4877	const auto op = get_value("op", "op", true).template get<std::string>();
4878	const auto path = get_value(op, "path", true).template get<std::string>();
4879	json_pointer ptr(path);
4880
4881	switch (get_op(op))
4882	{
4883	case patch_operations::add:
4884	{
4885	operation_add(ptr, get_value("add", "value", false));
4886	break;
4887	}
4888
4889	case patch_operations::remove:
4890	{
4891	operation_remove(ptr);
4892	break;
4893	}
4894
4895	case patch_operations::replace:
4896	{
4897	// the "path" location must exist - use at()
4898	result.at(ptr) = get_value("replace", "value", false);
4899	break;
4900	}
4901
4902	case patch_operations::move:
4903	{
4904	const auto from_path = get_value("move", "from", true).template get<std::string>();
4905	json_pointer from_ptr(from_path);
4906
4907	// the "from" location must exist - use at()
4908	basic_json const v = result.at(from_ptr);
4909
4910	// The move operation is functionally identical to a
4911	// "remove" operation on the "from" location, followed
4912	// immediately by an "add" operation at the target
4913	// location with the value that was just removed.
4914	operation_remove(from_ptr);
4915	operation_add(ptr, v);
4916	break;
4917	}
4918
4919	case patch_operations::copy:
4920	{
4921	const auto from_path = get_value("copy", "from", true).template get<std::string>();
4922	const json_pointer from_ptr(from_path);
4923
4924	// the "from" location must exist - use at()
4925	basic_json const v = result.at(from_ptr);
4926
4927	// The copy is functionally identical to an "add"
4928	// operation at the target location using the value
4929	// specified in the "from" member.
4930	operation_add(ptr, v);
4931	break;
4932	}
4933
4934	case patch_operations::test:
4935	{
4936	bool success = false;
4937	JSON_TRY
4938	{
4939	// check if "value" matches the one at "path"
4940	// the "path" location must exist - use at()
4941	success = (result.at(ptr) == get_value("test", "value", false));
4942	}
4943	JSON_INTERNAL_CATCH (out_of_range&)
4944	{
4945	// ignore out of range errors: success remains false
4946	}
4947
4948	// throw an exception if test fails
4949	if (JSON_HEDLEY_UNLIKELY(!success))
4950	{
4951	JSON_THROW(other_error::create(`501`, detail::concat("unsuccessful: ", val.dump()), &val));
4952	}
4953
4954	break;
4955	}
4956
4957	case patch_operations::invalid:
4958	default:
4959	{
4960	// op must be "add", "remove", "replace", "move", "copy", or
4961	// "test"
4962	JSON_THROW(parse_error::create(`105`, `0`, detail::concat("operation value '", op, "' is invalid"), &val));
4963	}
4964	}
4965	}
4966	}
4967
4968	/// @brief applies a JSON patch to a copy of the current object
4969	/// @sa https://json.nlohmann.me/api/basic_json/patch/
4970	basic_json patch(const basic_json& json_patch) const
4971	{
4972	basic_json result = *this;
4973	result.patch_inplace(json_patch);
4974	return result;
4975	}
4976
4977	/// @brief creates a diff as a JSON patch
4978	/// @sa https://json.nlohmann.me/api/basic_json/diff/
4979	JSON_HEDLEY_WARN_UNUSED_RESULT
4980	static basic_json diff(const basic_json& source, const basic_json& target,
4981	const std::string& path = "")
4982	{
4983	// the patch
4984	basic_json result(value_t::array);
4985
4986	// if the values are the same, return empty patch
4987	if (source == target)
4988	{
4989	return result;
4990	}
4991
4992	if (source.type() != target.type())
4993	{
4994	// different types: replace value
4995	result.push_back(
4996	{
4997	{"op", "replace"}, {"path", path}, {"value", target}
4998	});
4999	return result;
5000	}
5001
5002	switch (source.type())
5003	{
5004	case value_t::array:
5005	{
5006	// first pass: traverse common elements
5007	std::size_t i = `0`;
5008	while (i < source.size() && i < target.size())
5009	{
5010	// recursive call to compare array values at index i
5011	auto temp_diff = diff(source: source[i], target: target[i], path: detail::concat(args: path, args: `'/'`, args: std::to_string(val: i)));
5012	result.insert(result.end(), temp_diff.begin(), temp_diff.end());
5013	++i;
5014	}
5015
5016	// We now reached the end of at least one array
5017	// in a second pass, traverse the remaining elements
5018
5019	// remove my remaining elements
5020	const auto end_index = static_cast<difference_type>(result.size());
5021	while (i < source.size())
5022	{
5023	// add operations in reverse order to avoid invalid
5024	// indices
5025	result.insert(result.begin() + end_index, object(
5026	init: {
5027	{"op", "remove"},
5028	{"path", detail::concat(args: path, args: `'/'`, args: std::to_string(val: i))}
5029	}));
5030	++i;
5031	}
5032
5033	// add other remaining elements
5034	while (i < target.size())
5035	{
5036	result.push_back(
5037	{
5038	{"op", "add"},
5039	{"path", detail::concat(args: path, args: "/-")},
5040	{"value", target[i]}
5041	});
5042	++i;
5043	}
5044
5045	break;
5046	}
5047
5048	case value_t::object:
5049	{
5050	// first pass: traverse this object's elements
5051	for (auto it = source.cbegin(); it != source.cend(); ++it)
5052	{
5053	// escape the key name to be used in a JSON patch
5054	const auto path_key = detail::concat(path, `'/'`, detail::escape(it.key()));
5055
5056	if (target.find(it.key()) != target.end())
5057	{
5058	// recursive call to compare object values at key it
5059	auto temp_diff = diff(source: it.value(), target: target[it.key()], path: path_key);
5060	result.insert(result.end(), temp_diff.begin(), temp_diff.end());
5061	}
5062	else
5063	{
5064	// found a key that is not in o -> remove it
5065	result.push_back(object(
5066	init: {
5067	{"op", "remove"}, {"path", path_key}
5068	}));
5069	}
5070	}
5071
5072	// second pass: traverse other object's elements
5073	for (auto it = target.cbegin(); it != target.cend(); ++it)
5074	{
5075	if (source.find(it.key()) == source.end())
5076	{
5077	// found a key that is not in this -> add it
5078	const auto path_key = detail::concat(path, `'/'`, detail::escape(it.key()));
5079	result.push_back(
5080	{
5081	{"op", "add"}, {"path", path_key},
5082	{"value", it.value()}
5083	});
5084	}
5085	}
5086
5087	break;
5088	}
5089
5090	case value_t::null:
5091	case value_t::string:
5092	case value_t::boolean:
5093	case value_t::number_integer:
5094	case value_t::number_unsigned:
5095	case value_t::number_float:
5096	case value_t::binary:
5097	case value_t::discarded:
5098	default:
5099	{
5100	// both primitive type: replace value
5101	result.push_back(
5102	{
5103	{"op", "replace"}, {"path", path}, {"value", target}
5104	});
5105	break;
5106	}
5107	}
5108
5109	return result;
5110	}
5111	/// @}
5112
5113	////////////////////////////////
5114	// JSON Merge Patch functions //
5115	////////////////////////////////
5116
5117	/// @name JSON Merge Patch functions
5118	/// @{
5119
5120	/// @brief applies a JSON Merge Patch
5121	/// @sa https://json.nlohmann.me/api/basic_json/merge_patch/
5122	void merge_patch(const basic_json& apply_patch)
5123	{
5124	if (apply_patch.is_object())
5125	{
5126	if (!is_object())
5127	{
5128	*this = object();
5129	}
5130	for (auto it = apply_patch.begin(); it != apply_patch.end(); ++it)
5131	{
5132	if (it.value().is_null())
5133	{
5134	erase(it.key());
5135	}
5136	else
5137	{
5138	operator[](it.key()).merge_patch(it.value());
5139	}
5140	}
5141	}
5142	else
5143	{
5144	*this = apply_patch;
5145	}
5146	}
5147
5148	/// @}
5149	};
5150
5151	/// @brief user-defined to_string function for JSON values
5152	/// @sa https://json.nlohmann.me/api/basic_json/to_string/
5153	NLOHMANN_BASIC_JSON_TPL_DECLARATION
5154	std::string to_string(const NLOHMANN_BASIC_JSON_TPL& j)
5155	{
5156	return j.dump();
5157	}
5158
5159	inline namespace literals
5160	{
5161	inline namespace json_literals
5162	{
5163
5164	/// @brief user-defined string literal for JSON values
5165	/// @sa https://json.nlohmann.me/api/basic_json/operator_literal_json/
5166	JSON_HEDLEY_NON_NULL(`1`)
5167	#if !defined(JSON_HEDLEY_GCC_VERSION) \|\| JSON_HEDLEY_GCC_VERSION_CHECK(4,9,0)
5168	inline nlohmann::json operator ""_json(const char* s, std::size_t n)
5169	#else
5170	inline nlohmann::json operator "" _json(const char* s, std::size_t n)
5171	#endif
5172	{
5173	return nlohmann::json::parse(first: s, last: s + n);
5174	}
5175
5176	/// @brief user-defined string literal for JSON pointer
5177	/// @sa https://json.nlohmann.me/api/basic_json/operator_literal_json_pointer/
5178	JSON_HEDLEY_NON_NULL(`1`)
5179	#if !defined(JSON_HEDLEY_GCC_VERSION) \|\| JSON_HEDLEY_GCC_VERSION_CHECK(4,9,0)
5180	inline nlohmann::json::json_pointer operator ""_json_pointer(const char* s, std::size_t n)
5181	#else
5182	inline nlohmann::json::json_pointer operator "" _json_pointer(const char* s, std::size_t n)
5183	#endif
5184	{
5185	return nlohmann::json::json_pointer (std::string (s, n));
5186	}
5187
5188	} // namespace json_literals
5189	} // namespace literals
5190	NLOHMANN_JSON_NAMESPACE_END
5191
5192	///////////////////////
5193	// nonmember support //
5194	///////////////////////
5195
5196	namespace std // NOLINT(cert-dcl58-cpp)
5197	{
5198
5199	/// @brief hash value for JSON objects
5200	/// @sa https://json.nlohmann.me/api/basic_json/std_hash/
5201	NLOHMANN_BASIC_JSON_TPL_DECLARATION
5202	struct hash<nlohmann::NLOHMANN_BASIC_JSON_TPL> // NOLINT(cert-dcl58-cpp)
5203	{
5204	std::size_t operator()(const nlohmann::NLOHMANN_BASIC_JSON_TPL& j) const
5205	{
5206	return nlohmann::detail::hash(j);
5207	}
5208	};
5209
5210	// specialization for std::less<value_t>
5211	template<>
5212	struct less< ::nlohmann::detail::value_t> // do not remove the space after '<', see https://github.com/nlohmann/json/pull/679
5213	{
5214	/!*
5215	@brief compare two value_t enum values
5216	@since version 3.0.0
5217	*/
5218	bool operator()(::nlohmann::detail::value_t lhs,
5219	::nlohmann::detail::value_t rhs) const noexcept
5220	{
5221	#if JSON_HAS_THREE_WAY_COMPARISON
5222	return std::is_lt(cmp: lhs <=> rhs); // NOPAD
5223	#else
5224	return ::nlohmann::detail::operator<(lhs, rhs);
5225	#endif
5226	}
5227	};
5228
5229	// C++20 prohibit function specialization in the std namespace.
5230	#ifndef JSON_HAS_CPP_20
5231
5232	/// @brief exchanges the values of two JSON objects
5233	/// @sa https://json.nlohmann.me/api/basic_json/std_swap/
5234	NLOHMANN_BASIC_JSON_TPL_DECLARATION
5235	inline void swap(nlohmann::NLOHMANN_BASIC_JSON_TPL& j1, nlohmann::NLOHMANN_BASIC_JSON_TPL& j2) noexcept( // NOLINT(readability-inconsistent-declaration-parameter-name, cert-dcl58-cpp)
5236	is_nothrow_move_constructible<nlohmann::NLOHMANN_BASIC_JSON_TPL>::value&& // NOLINT(misc-redundant-expression,cppcoreguidelines-noexcept-swap,performance-noexcept-swap)
5237	is_nothrow_move_assignable<nlohmann::NLOHMANN_BASIC_JSON_TPL>::value)
5238	{
5239	j1.swap(j2);
5240	}
5241
5242	#endif
5243
5244	} // namespace std
5245
5246	#if JSON_USE_GLOBAL_UDLS
5247	#if !defined(JSON_HEDLEY_GCC_VERSION) \|\| JSON_HEDLEY_GCC_VERSION_CHECK(4,9,0)
5248	using nlohmann::literals::json_literals::operator ""_json; // NOLINT(misc-unused-using-decls,google-global-names-in-headers)
5249	using nlohmann::literals::json_literals::operator ""_json_pointer; //NOLINT(misc-unused-using-decls,google-global-names-in-headers)
5250	#else
5251	using nlohmann::literals::json_literals::operator "" _json; // NOLINT(misc-unused-using-decls,google-global-names-in-headers)
5252	using nlohmann::literals::json_literals::operator "" _json_pointer; //NOLINT(misc-unused-using-decls,google-global-names-in-headers)
5253	#endif
5254	#endif
5255
5256	#include <nlohmann/detail/macro_unscope.hpp>
5257
5258	#endif // INCLUDE_NLOHMANN_JSON_HPP_
5259

Browse the source code of include/nlohmann/json.hpp