29 #ifndef NLOHMANN_JSON_HPP 30 #define NLOHMANN_JSON_HPP 42 #include <forward_list> 44 #include <initializer_list> 56 #include <type_traits> 61 #if defined(__clang__) 62 #if (__clang_major__ * 10000 + __clang_minor__ * 100 + __clang_patchlevel__) < 30400 63 #error "unsupported Clang version - see https://github.com/nlohmann/json#supported-compilers" 65 #elif defined(__GNUC__) 66 #if (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__) < 40900 67 #error "unsupported GCC version - see https://github.com/nlohmann/json#supported-compilers" 72 #if defined(__clang__) || defined(__GNUC__) || defined(__GNUG__) 73 #pragma GCC diagnostic push 74 #pragma GCC diagnostic ignored "-Wfloat-equal" 78 #if defined(__clang__) 79 #pragma GCC diagnostic push 80 #pragma GCC diagnostic ignored "-Wdocumentation" 84 #if defined(__clang__) || defined(__GNUC__) || defined(__GNUG__) 85 #define JSON_DEPRECATED __attribute__((deprecated)) 86 #elif defined(_MSC_VER) 87 #define JSON_DEPRECATED __declspec(deprecated) 89 #define JSON_DEPRECATED 93 #if not defined(JSON_NOEXCEPTION) || defined(__EXCEPTIONS) 94 #define JSON_THROW(exception) throw exception 96 #define JSON_CATCH(exception) catch(exception) 98 #define JSON_THROW(exception) std::abort() 99 #define JSON_TRY if(true) 100 #define JSON_CATCH(exception) if(false) 149 enum class value_t : uint8_t
171 inline bool operator<(
const value_t lhs,
const value_t rhs) noexcept
173 static constexpr std::array<uint8_t, 8> order = {{
186 if (lhs == value_t::discarded or rhs == value_t::discarded)
191 return order[
static_cast<std::size_t
>(lhs)] <
192 order[static_cast<std::size_t>(rhs)];
201 template<
bool B,
typename T =
void>
202 using enable_if_t =
typename std::enable_if<B, T>::type;
205 using uncvref_t =
typename std::remove_cv<typename std::remove_reference<T>::type>::type;
209 using is_unscoped_enum =
210 std::integral_constant<bool, std::is_convertible<T, int>::value and
211 std::is_enum<T>::value>;
226 template<
class...>
struct conjunction : std::true_type {};
227 template<
class B1>
struct conjunction<B1> : B1 {};
228 template<
class B1,
class... Bn>
229 struct conjunction<B1, Bn...> : std::conditional<bool(B1::value), conjunction<Bn...>, B1>::type {};
231 template<
class B>
struct negation : std::integral_constant < bool, !B::value > {};
234 template<
unsigned N>
struct priority_tag : priority_tag < N - 1 > {};
235 template<>
struct priority_tag<0> {};
242 template<value_t>
struct external_constructor;
245 struct external_constructor<value_t::boolean>
247 template<
typename BasicJsonType>
248 static void construct(BasicJsonType& j,
typename BasicJsonType::boolean_t b) noexcept
250 j.m_type = value_t::boolean;
252 j.assert_invariant();
257 struct external_constructor<value_t::string>
259 template<
typename BasicJsonType>
260 static void construct(BasicJsonType& j,
const typename BasicJsonType::string_t& s)
262 j.m_type = value_t::string;
264 j.assert_invariant();
269 struct external_constructor<value_t::number_float>
271 template<
typename BasicJsonType>
272 static void construct(BasicJsonType& j,
typename BasicJsonType::number_float_t val) noexcept
275 if (not std::isfinite(val))
281 j.m_type = value_t::number_float;
284 j.assert_invariant();
289 struct external_constructor<value_t::number_unsigned>
291 template<
typename BasicJsonType>
292 static void construct(BasicJsonType& j,
typename BasicJsonType::number_unsigned_t val) noexcept
294 j.m_type = value_t::number_unsigned;
296 j.assert_invariant();
301 struct external_constructor<value_t::number_integer>
303 template<
typename BasicJsonType>
304 static void construct(BasicJsonType& j,
typename BasicJsonType::number_integer_t val) noexcept
306 j.m_type = value_t::number_integer;
308 j.assert_invariant();
313 struct external_constructor<value_t::array>
315 template<
typename BasicJsonType>
316 static void construct(BasicJsonType& j,
const typename BasicJsonType::array_t& arr)
318 j.m_type = value_t::array;
320 j.assert_invariant();
323 template<
typename BasicJsonType,
typename CompatibleArrayType,
324 enable_if_t<not std::is_same<CompatibleArrayType,
325 typename BasicJsonType::array_t>::value,
327 static void construct(BasicJsonType& j,
const CompatibleArrayType& arr)
331 j.m_type = value_t::array;
332 j.m_value.array = j.template create<typename BasicJsonType::array_t>(begin(arr), end(arr));
333 j.assert_invariant();
338 struct external_constructor<value_t::object>
340 template<
typename BasicJsonType>
341 static void construct(BasicJsonType& j,
const typename BasicJsonType::object_t& obj)
343 j.m_type = value_t::object;
345 j.assert_invariant();
348 template<
typename BasicJsonType,
typename CompatibleObjectType,
349 enable_if_t<not std::is_same<CompatibleObjectType,
350 typename BasicJsonType::object_t>::value,
352 static void construct(BasicJsonType& j,
const CompatibleObjectType& obj)
357 j.m_type = value_t::object;
358 j.m_value.object = j.template create<typename BasicJsonType::object_t>(begin(obj), end(obj));
359 j.assert_invariant();
378 #define NLOHMANN_JSON_HAS_HELPER(type) \ 379 template<typename T> struct has_##type { \ 381 template<typename U, typename = typename U::type> \ 382 static int detect(U &&); \ 383 static void detect(...); \ 385 static constexpr bool value = \ 386 std::is_integral<decltype(detect(std::declval<T>()))>::value; \ 389 NLOHMANN_JSON_HAS_HELPER(mapped_type);
390 NLOHMANN_JSON_HAS_HELPER(key_type);
391 NLOHMANN_JSON_HAS_HELPER(value_type);
392 NLOHMANN_JSON_HAS_HELPER(iterator);
394 #undef NLOHMANN_JSON_HAS_HELPER 397 template<
bool B,
class RealType,
class CompatibleObjectType>
398 struct is_compatible_object_type_impl : std::false_type {};
400 template<
class RealType,
class CompatibleObjectType>
401 struct is_compatible_object_type_impl<true, RealType, CompatibleObjectType>
403 static constexpr
auto value =
404 std::is_constructible<
typename RealType::key_type,
405 typename CompatibleObjectType::key_type>::value and
406 std::is_constructible<
typename RealType::mapped_type,
407 typename CompatibleObjectType::mapped_type>::value;
410 template<
class BasicJsonType,
class CompatibleObjectType>
411 struct is_compatible_object_type
413 static auto constexpr value = is_compatible_object_type_impl <
414 conjunction<negation<std::is_same<void, CompatibleObjectType>>,
415 has_mapped_type<CompatibleObjectType>,
416 has_key_type<CompatibleObjectType>>::value,
417 typename BasicJsonType::object_t, CompatibleObjectType >::value;
420 template<
typename BasicJsonType,
typename T>
421 struct is_basic_json_nested_type
423 static auto constexpr value = std::is_same<T, typename BasicJsonType::iterator>::value or
424 std::is_same<T, typename BasicJsonType::const_iterator>::value or
425 std::is_same<T, typename BasicJsonType::reverse_iterator>::value or
426 std::is_same<T, typename BasicJsonType::const_reverse_iterator>::value or
427 std::is_same<T, typename BasicJsonType::json_pointer>::value;
430 template<
class BasicJsonType,
class CompatibleArrayType>
431 struct is_compatible_array_type
433 static auto constexpr value =
434 conjunction<negation<std::is_same<void, CompatibleArrayType>>,
435 negation<is_compatible_object_type<
436 BasicJsonType, CompatibleArrayType>>,
437 negation<std::is_constructible<
typename BasicJsonType::string_t,
438 CompatibleArrayType>>,
439 negation<is_basic_json_nested_type<BasicJsonType, CompatibleArrayType>>,
440 has_value_type<CompatibleArrayType>,
441 has_iterator<CompatibleArrayType>>::value;
444 template<
bool,
typename,
typename>
445 struct is_compatible_integer_type_impl : std::false_type {};
447 template<
typename RealIntegerType,
typename CompatibleNumberIntegerType>
448 struct is_compatible_integer_type_impl<true, RealIntegerType, CompatibleNumberIntegerType>
451 using RealLimits = std::numeric_limits<RealIntegerType>;
452 using CompatibleLimits = std::numeric_limits<CompatibleNumberIntegerType>;
454 static constexpr
auto value =
455 std::is_constructible<RealIntegerType,
456 CompatibleNumberIntegerType>::value and
457 CompatibleLimits::is_integer and
458 RealLimits::is_signed == CompatibleLimits::is_signed;
461 template<
typename RealIntegerType,
typename CompatibleNumberIntegerType>
462 struct is_compatible_integer_type
464 static constexpr
auto value =
465 is_compatible_integer_type_impl <
466 std::is_integral<CompatibleNumberIntegerType>::value and
467 not std::is_same<bool, CompatibleNumberIntegerType>::value,
468 RealIntegerType, CompatibleNumberIntegerType > ::value;
473 template<
typename BasicJsonType,
typename T>
478 template<typename U, typename = enable_if_t<std::is_same<void, decltype(uncvref_t<U>::from_json(
479 std::declval<BasicJsonType>(), std::declval<T&>()))>::value>>
480 static int detect(U&&);
481 static void detect(...);
484 static constexpr
bool value = std::is_integral<decltype(
485 detect(std::declval<
typename BasicJsonType::template json_serializer<T, void>>()))>::value;
490 template<
typename BasicJsonType,
typename T>
491 struct has_non_default_from_json
496 typename = enable_if_t<std::is_same<
497 T, decltype(uncvref_t<U>::from_json(std::declval<BasicJsonType>()))>::value >>
498 static int detect(U&&);
499 static void detect(...);
502 static constexpr
bool value = std::is_integral<decltype(detect(
503 std::declval<
typename BasicJsonType::template json_serializer<T, void>>()))>::value;
507 template<
typename BasicJsonType,
typename T>
511 template<typename U, typename = decltype(uncvref_t<U>::to_json(
512 std::declval<BasicJsonType&>(), std::declval<T>()))>
513 static int detect(U&&);
514 static void detect(...);
517 static constexpr
bool value = std::is_integral<decltype(detect(
518 std::declval<
typename BasicJsonType::template json_serializer<T, void>>()))>::value;
526 template<
typename BasicJsonType,
typename T, enable_if_t<
527 std::is_same<T, typename BasicJsonType::boolean_t>::value,
int> = 0>
528 void to_json(BasicJsonType& j, T b) noexcept
530 external_constructor<value_t::boolean>::construct(j, b);
533 template<
typename BasicJsonType,
typename CompatibleString,
534 enable_if_t<std::is_constructible<
typename BasicJsonType::string_t,
535 CompatibleString>::value,
int> = 0>
536 void to_json(BasicJsonType& j,
const CompatibleString& s)
538 external_constructor<value_t::string>::construct(j, s);
541 template<
typename BasicJsonType,
typename FloatType,
542 enable_if_t<std::is_floating_point<FloatType>::value,
int> = 0>
543 void to_json(BasicJsonType& j, FloatType val) noexcept
545 external_constructor<value_t::number_float>::construct(j, static_cast<typename BasicJsonType::number_float_t>(val));
549 typename BasicJsonType,
typename CompatibleNumberUnsignedType,
550 enable_if_t<is_compatible_integer_type<
typename BasicJsonType::number_unsigned_t,
551 CompatibleNumberUnsignedType>::value,
int> = 0 >
552 void to_json(BasicJsonType& j, CompatibleNumberUnsignedType val) noexcept
554 external_constructor<value_t::number_unsigned>::construct(j, static_cast<typename BasicJsonType::number_unsigned_t>(val));
558 typename BasicJsonType,
typename CompatibleNumberIntegerType,
559 enable_if_t<is_compatible_integer_type<
typename BasicJsonType::number_integer_t,
560 CompatibleNumberIntegerType>::value,
int> = 0 >
561 void to_json(BasicJsonType& j, CompatibleNumberIntegerType val) noexcept
563 external_constructor<value_t::number_integer>::construct(j, static_cast<typename BasicJsonType::number_integer_t>(val));
566 template<
typename BasicJsonType,
typename UnscopedEnumType,
567 enable_if_t<is_unscoped_enum<UnscopedEnumType>::value,
int> = 0>
568 void to_json(BasicJsonType& j, UnscopedEnumType e) noexcept
570 external_constructor<value_t::number_integer>::construct(j, e);
574 typename BasicJsonType,
typename CompatibleArrayType,
576 is_compatible_array_type<BasicJsonType, CompatibleArrayType>::value or
577 std::is_same<typename BasicJsonType::array_t, CompatibleArrayType>::value,
579 void to_json(BasicJsonType& j,
const CompatibleArrayType& arr)
581 external_constructor<value_t::array>::construct(j, arr);
585 typename BasicJsonType,
typename CompatibleObjectType,
586 enable_if_t<is_compatible_object_type<BasicJsonType, CompatibleObjectType>::value,
588 void to_json(BasicJsonType& j,
const CompatibleObjectType& arr)
590 external_constructor<value_t::object>::construct(j, arr);
599 template<
typename BasicJsonType,
typename ArithmeticType,
600 enable_if_t<std::is_arithmetic<ArithmeticType>::value and
601 not std::is_same<ArithmeticType,
602 typename BasicJsonType::boolean_t>::value,
604 void get_arithmetic_value(
const BasicJsonType& j, ArithmeticType& val)
606 switch (static_cast<value_t>(j))
608 case value_t::number_unsigned:
610 val =
static_cast<ArithmeticType
>(
611 *j.template get_ptr<const typename BasicJsonType::number_unsigned_t*>());
614 case value_t::number_integer:
616 val =
static_cast<ArithmeticType
>(
617 *j.template get_ptr<const typename BasicJsonType::number_integer_t*>());
620 case value_t::number_float:
622 val =
static_cast<ArithmeticType
>(
623 *j.template get_ptr<const typename BasicJsonType::number_float_t*>());
629 std::domain_error(
"type must be number, but is " + j.type_name()));
634 template<
typename BasicJsonType>
635 void from_json(
const BasicJsonType& j,
typename BasicJsonType::boolean_t& b)
637 if (not j.is_boolean())
639 JSON_THROW(std::domain_error(
"type must be boolean, but is " + j.type_name()));
641 b = *j.template get_ptr<const typename BasicJsonType::boolean_t*>();
644 template<
typename BasicJsonType>
645 void from_json(
const BasicJsonType& j,
typename BasicJsonType::string_t& s)
647 if (not j.is_string())
649 JSON_THROW(std::domain_error(
"type must be string, but is " + j.type_name()));
651 s = *j.template get_ptr<const typename BasicJsonType::string_t*>();
654 template<
typename BasicJsonType>
655 void from_json(
const BasicJsonType& j,
typename BasicJsonType::number_float_t& val)
657 get_arithmetic_value(j, val);
660 template<
typename BasicJsonType>
661 void from_json(
const BasicJsonType& j,
typename BasicJsonType::number_unsigned_t& val)
663 get_arithmetic_value(j, val);
666 template<
typename BasicJsonType>
667 void from_json(
const BasicJsonType& j,
typename BasicJsonType::number_integer_t& val)
669 get_arithmetic_value(j, val);
672 template<
typename BasicJsonType,
typename UnscopedEnumType,
673 enable_if_t<is_unscoped_enum<UnscopedEnumType>::value,
int> = 0>
674 void from_json(
const BasicJsonType& j, UnscopedEnumType& e)
676 typename std::underlying_type<UnscopedEnumType>::type val;
677 get_arithmetic_value(j, val);
678 e =
static_cast<UnscopedEnumType
>(val);
681 template<
typename BasicJsonType>
682 void from_json(
const BasicJsonType& j,
typename BasicJsonType::array_t& arr)
684 if (not j.is_array())
686 JSON_THROW(std::domain_error(
"type must be array, but is " + j.type_name()));
688 arr = *j.template get_ptr<const typename BasicJsonType::array_t*>();
692 template<
typename BasicJsonType,
typename T,
typename Allocator>
693 void from_json(
const BasicJsonType& j, std::forward_list<T, Allocator>& l)
699 JSON_THROW(std::domain_error(
"type must be array, but is " + j.type_name()));
701 if (not std::is_same<T, BasicJsonType>::value)
703 if (not j.is_array())
705 JSON_THROW(std::domain_error(
"type must be array, but is " + j.type_name()));
708 for (
auto it = j.rbegin(), end = j.rend(); it != end; ++it)
710 l.push_front(it->template get<T>());
714 template<
typename BasicJsonType,
typename CompatibleArrayType>
715 void from_json_array_impl(
const BasicJsonType& j, CompatibleArrayType& arr, priority_tag<0>)
720 std::transform(j.begin(), j.end(),
721 std::inserter(arr, end(arr)), [](
const BasicJsonType & i)
725 return i.template get<typename CompatibleArrayType::value_type>();
729 template<
typename BasicJsonType,
typename CompatibleArrayType>
730 auto from_json_array_impl(
const BasicJsonType& j, CompatibleArrayType& arr, priority_tag<1>)
732 arr.reserve(std::declval<typename CompatibleArrayType::size_type>()),
738 arr.reserve(j.size());
740 j.begin(), j.end(), std::inserter(arr, end(arr)), [](
const BasicJsonType & i)
744 return i.template get<typename CompatibleArrayType::value_type>();
748 template<
typename BasicJsonType,
typename CompatibleArrayType,
749 enable_if_t<is_compatible_array_type<BasicJsonType, CompatibleArrayType>::value and
750 not std::is_same<typename BasicJsonType::array_t, CompatibleArrayType>::value,
int> = 0>
751 void from_json(
const BasicJsonType& j, CompatibleArrayType& arr)
755 JSON_THROW(std::domain_error(
"type must be array, but is " + j.type_name()));
759 if (not std::is_same<typename CompatibleArrayType::value_type, BasicJsonType>::value)
761 if (not j.is_array())
763 JSON_THROW(std::domain_error(
"type must be array, but is " + j.type_name()));
766 from_json_array_impl(j, arr, priority_tag<1> {});
769 template<
typename BasicJsonType,
typename CompatibleObjectType,
770 enable_if_t<is_compatible_object_type<BasicJsonType, CompatibleObjectType>::value,
int> = 0>
771 void from_json(
const BasicJsonType& j, CompatibleObjectType& obj)
773 if (not j.is_object())
775 JSON_THROW(std::domain_error(
"type must be object, but is " + j.type_name()));
778 auto inner_object = j.template get_ptr<const typename BasicJsonType::object_t*>();
784 obj = CompatibleObjectType(begin(*inner_object), end(*inner_object));
791 template<
typename BasicJsonType,
typename ArithmeticType,
793 std::is_arithmetic<ArithmeticType>::value and
794 not std::is_same<ArithmeticType, typename BasicJsonType::number_unsigned_t>::value and
795 not std::is_same<ArithmeticType, typename BasicJsonType::number_integer_t>::value and
796 not std::is_same<ArithmeticType, typename BasicJsonType::number_float_t>::value and
797 not std::is_same<ArithmeticType, typename BasicJsonType::boolean_t>::value,
799 void from_json(
const BasicJsonType& j, ArithmeticType& val)
801 switch (static_cast<value_t>(j))
803 case value_t::number_unsigned:
805 val =
static_cast<ArithmeticType
>(*j.template get_ptr<const typename BasicJsonType::number_unsigned_t*>());
808 case value_t::number_integer:
810 val =
static_cast<ArithmeticType
>(*j.template get_ptr<const typename BasicJsonType::number_integer_t*>());
813 case value_t::number_float:
815 val =
static_cast<ArithmeticType
>(*j.template get_ptr<const typename BasicJsonType::number_float_t*>());
818 case value_t::boolean:
820 val =
static_cast<ArithmeticType
>(*j.template get_ptr<const typename BasicJsonType::boolean_t*>());
825 JSON_THROW(std::domain_error(
"type must be number, but is " + j.type_name()));
833 template<
typename BasicJsonType,
typename T>
834 auto call(BasicJsonType& j, T&& val, priority_tag<1>)
const noexcept(noexcept(to_json(j, std::forward<T>(val))))
835 -> decltype(to_json(j, std::forward<T>(val)),
void())
837 return to_json(j, std::forward<T>(val));
840 template<
typename BasicJsonType,
typename T>
841 void call(BasicJsonType&, T&&, priority_tag<0>)
const noexcept
843 static_assert(
sizeof(BasicJsonType) == 0,
844 "could not find to_json() method in T's namespace");
848 template<
typename BasicJsonType,
typename T>
849 void operator()(BasicJsonType& j, T&& val)
const 850 noexcept(noexcept(std::declval<to_json_fn>().call(j, std::forward<T>(val), priority_tag<1> {})))
852 return call(j, std::forward<T>(val), priority_tag<1> {});
859 template<
typename BasicJsonType,
typename T>
860 auto call(
const BasicJsonType& j, T& val, priority_tag<1>)
const 861 noexcept(noexcept(from_json(j, val)))
862 -> decltype(from_json(j, val),
void())
864 return from_json(j, val);
867 template<
typename BasicJsonType,
typename T>
868 void call(
const BasicJsonType&, T&, priority_tag<0>)
const noexcept
870 static_assert(
sizeof(BasicJsonType) == 0,
871 "could not find from_json() method in T's namespace");
875 template<
typename BasicJsonType,
typename T>
876 void operator()(
const BasicJsonType& j, T& val)
const 877 noexcept(noexcept(std::declval<from_json_fn>().call(j, val, priority_tag<1> {})))
879 return call(j, val, priority_tag<1> {});
887 static constexpr T value{};
891 constexpr T static_const<T>::value;
898 constexpr
const auto&
to_json = detail::static_const<detail::to_json_fn>::value;
899 constexpr
const auto&
from_json = detail::static_const<detail::from_json_fn>::value;
910 template<
typename =
void,
typename =
void>
922 template<
typename BasicJsonType,
typename ValueType>
923 static void from_json(BasicJsonType&& j, ValueType& val) noexcept(
924 noexcept(::nlohmann::from_json(std::forward<BasicJsonType>(j), val)))
926 ::nlohmann::from_json(std::forward<BasicJsonType>(j), val);
938 template<
typename BasicJsonType,
typename ValueType>
939 static void to_json(BasicJsonType& j, ValueType&& val) noexcept(
940 noexcept(::
nlohmann::to_json(j,
std::forward<ValueType>(val))))
942 ::nlohmann::to_json(j, std::forward<ValueType>(val));
1029 template<
typename U,
typename V,
typename... Args>
class ObjectType = std::map,
1030 template<
typename U,
typename... Args>
class ArrayType = std::vector,
1031 class StringType = std::string,
1032 class BooleanType = bool,
1033 class NumberIntegerType = std::int64_t,
1034 class NumberUnsignedType = std::uint64_t,
1035 class NumberFloatType = double,
1036 template<
typename U>
class AllocatorType = std::allocator,
1037 template<
typename T,
typename SFINAE =
void>
class JSONSerializer =
adl_serializer 1042 template<detail::value_t>
friend struct detail::external_constructor;
1045 BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType,
1046 AllocatorType, JSONSerializer>;
1049 using value_t = detail::value_t;
1054 template<
typename T,
typename SFINAE>
1083 using pointer =
typename std::allocator_traits<allocator_type>::pointer;
1085 using const_pointer =
typename std::allocator_traits<allocator_type>::const_pointer;
1134 result[
"copyright"] =
"(C) 2013-2017 Niels Lohmann";
1135 result[
"name"] =
"JSON for Modern C++";
1136 result[
"url"] =
"https://github.com/nlohmann/json";
1139 {
"string",
"2.1.1"},
1146 result[
"platform"] =
"win32";
1147 #elif defined __linux__ 1148 result[
"platform"] =
"linux";
1149 #elif defined __APPLE__ 1150 result[
"platform"] =
"apple";
1151 #elif defined __unix__ 1152 result[
"platform"] =
"unix";
1154 result[
"platform"] =
"unknown";
1157 #if defined(__clang__) 1158 result[
"compiler"] = {{
"family",
"clang"}, {
"version", __clang_version__}};
1159 #elif defined(__ICC) || defined(__INTEL_COMPILER) 1160 result[
"compiler"] = {{
"family",
"icc"}, {
"version", __INTEL_COMPILER}};
1161 #elif defined(__GNUC__) || defined(__GNUG__) 1162 result[
"compiler"] = {{
"family",
"gcc"}, {
"version", std::to_string(__GNUC__) +
"." + std::to_string(__GNUC_MINOR__) +
"." + std::to_string(__GNUC_PATCHLEVEL__)}};
1163 #elif defined(__HP_cc) || defined(__HP_aCC) 1164 result[
"compiler"] =
"hp" 1165 #elif defined(__IBMCPP__) 1166 result[
"compiler"] = {{
"family",
"ilecpp"}, {
"version", __IBMCPP__}};
1167 #elif defined(_MSC_VER) 1168 result[
"compiler"] = {{
"family",
"msvc"}, {
"version", _MSC_VER}};
1169 #elif defined(__PGI) 1170 result[
"compiler"] = {{
"family",
"pgcpp"}, {
"version", __PGI}};
1171 #elif defined(__SUNPRO_CC) 1172 result[
"compiler"] = {{
"family",
"sunpro"}, {
"version", __SUNPRO_CC}};
1174 result[
"compiler"] = {{
"family",
"unknown"}, {
"version",
"unknown"}};
1178 result[
"compiler"][
"c++"] = std::to_string(__cplusplus);
1180 result[
"compiler"][
"c++"] =
"unknown";
1278 using object_t = ObjectType<StringType,
1280 std::less<StringType>,
1281 AllocatorType<std::pair<
const StringType,
1328 using array_t = ArrayType<basic_json, AllocatorType<basic_json>>;
1625 template<
typename T,
typename... Args>
1626 static T* create(Args&& ... args)
1628 AllocatorType<T> alloc;
1629 auto deleter = [&](T * object)
1631 alloc.deallocate(
object, 1);
1633 std::unique_ptr<T, decltype(deleter)> object(alloc.allocate(1), deleter);
1634 alloc.construct(
object.
get(), std::forward<Args>(args)...);
1635 assert(
object !=
nullptr);
1636 return object.release();
1685 json_value() =
default;
1687 json_value(
boolean_t v) noexcept : boolean(v) {}
1695 json_value(value_t t)
1699 case value_t::object:
1701 object = create<object_t>();
1705 case value_t::array:
1707 array = create<array_t>();
1711 case value_t::string:
1713 string = create<string_t>(
"");
1717 case value_t::boolean:
1723 case value_t::number_integer:
1729 case value_t::number_unsigned:
1735 case value_t::number_float:
1748 if (t == value_t::null)
1750 JSON_THROW(std::domain_error(
"961c151d2e87f2686a955a9be24d316f1362bf21 2.1.1"));
1760 string = create<string_t>(value);
1766 object = create<object_t>(value);
1770 json_value(
const array_t& value)
1772 array = create<array_t>(value);
1785 void assert_invariant()
const 1787 assert(m_type != value_t::object or m_value.object !=
nullptr);
1788 assert(m_type != value_t::array or m_value.array !=
nullptr);
1789 assert(m_type != value_t::string or m_value.string !=
nullptr);
1877 basic_json& parsed)>;
1917 : m_type(value_type), m_value(value_type)
1999 template<
typename CompatibleType,
typename U = detail::uncvref_t<CompatibleType>,
2000 detail::enable_if_t<not std::is_base_of<std::istream, U>::value and
2001 not std::is_same<U, basic_json_t>::value and
2002 not detail::is_basic_json_nested_type<
2003 basic_json_t, U>::value and
2004 detail::has_to_json<basic_json, U>::value,
2006 basic_json(CompatibleType && val) noexcept(noexcept(JSONSerializer<U>::to_json(
2009 JSONSerializer<U>::to_json(*
this, std::forward<CompatibleType>(val));
2083 bool type_deduction =
true,
2084 value_t manual_type = value_t::array)
2088 bool is_an_object = std::all_of(init.begin(), init.end(),
2091 return element.is_array() and element.size() == 2 and element[0].is_string();
2095 if (not type_deduction)
2098 if (manual_type == value_t::array)
2100 is_an_object =
false;
2104 if (manual_type == value_t::object and not is_an_object)
2106 JSON_THROW(std::domain_error(
"cannot create object from initializer list"));
2113 m_type = value_t::object;
2114 m_value = value_t::object;
2116 std::for_each(init.begin(), init.end(), [
this](
const basic_json & element)
2118 m_value.object->emplace(*(element[0].m_value.string), element[1]);
2124 m_type = value_t::array;
2125 m_value.array = create<array_t>(init);
2166 std::initializer_list<basic_json>())
2168 return basic_json(init,
false, value_t::array);
2206 std::initializer_list<basic_json>())
2208 return basic_json(init,
false, value_t::object);
2230 : m_type(value_t::array)
2232 m_value.array = create<array_t>(cnt, val);
2273 template<
class InputIT,
typename std::enable_if<
2274 std::is_same<InputIT, typename basic_json_t::iterator>::value or
2275 std::is_same<InputIT, typename basic_json_t::const_iterator>::value,
int>::type = 0>
2278 assert(first.m_object !=
nullptr);
2279 assert(last.m_object !=
nullptr);
2282 if (first.m_object != last.m_object)
2284 JSON_THROW(std::domain_error(
"iterators are not compatible"));
2288 m_type = first.m_object->m_type;
2293 case value_t::boolean:
2294 case value_t::number_float:
2295 case value_t::number_integer:
2296 case value_t::number_unsigned:
2297 case value_t::string:
2299 if (not first.m_it.primitive_iterator.is_begin() or not last.m_it.primitive_iterator.is_end())
2301 JSON_THROW(std::out_of_range(
"iterators out of range"));
2314 case value_t::number_integer:
2316 m_value.number_integer = first.m_object->m_value.number_integer;
2320 case value_t::number_unsigned:
2322 m_value.number_unsigned = first.m_object->m_value.number_unsigned;
2326 case value_t::number_float:
2328 m_value.number_float = first.m_object->m_value.number_float;
2332 case value_t::boolean:
2334 m_value.boolean = first.m_object->m_value.boolean;
2338 case value_t::string:
2340 m_value = *first.m_object->m_value.string;
2344 case value_t::object:
2346 m_value.object = create<object_t>(first.m_it.object_iterator,
2347 last.m_it.object_iterator);
2351 case value_t::array:
2353 m_value.array = create<array_t>(first.m_it.array_iterator,
2354 last.m_it.array_iterator);
2360 JSON_THROW(std::domain_error(
"cannot use construct with iterators from " + first.m_object->type_name()));
2398 *
this = parser(i, cb).parse();
2429 : m_type(other.m_type)
2432 other.assert_invariant();
2436 case value_t::object:
2438 m_value = *other.m_value.object;
2442 case value_t::array:
2444 m_value = *other.m_value.array;
2448 case value_t::string:
2450 m_value = *other.m_value.string;
2454 case value_t::boolean:
2456 m_value = other.m_value.boolean;
2460 case value_t::number_integer:
2462 m_value = other.m_value.number_integer;
2466 case value_t::number_unsigned:
2468 m_value = other.m_value.number_unsigned;
2472 case value_t::number_float:
2474 m_value = other.m_value.number_float;
2506 : m_type(
std::move(other.m_type)),
2507 m_value(
std::move(other.m_value))
2510 other.assert_invariant();
2513 other.m_type = value_t::null;
2543 std::is_nothrow_move_constructible<value_t>::value and
2544 std::is_nothrow_move_assignable<value_t>::value and
2545 std::is_nothrow_move_constructible<json_value>::value and
2546 std::is_nothrow_move_assignable<json_value>::value
2550 other.assert_invariant();
2553 swap(m_type, other.m_type);
2554 swap(m_value, other.m_value);
2581 case value_t::object:
2583 AllocatorType<object_t> alloc;
2584 alloc.destroy(m_value.object);
2585 alloc.deallocate(m_value.object, 1);
2589 case value_t::array:
2591 AllocatorType<array_t> alloc;
2592 alloc.destroy(m_value.array);
2593 alloc.deallocate(m_value.array, 1);
2597 case value_t::string:
2599 AllocatorType<string_t> alloc;
2600 alloc.destroy(m_value.string);
2601 alloc.deallocate(m_value.string, 1);
2649 std::stringstream ss;
2653 dump(ss,
true, static_cast<unsigned int>(indent));
2681 constexpr value_t
type() const noexcept
2713 return is_null() or is_string() or is_boolean() or is_number();
2740 return is_array() or is_object();
2762 return m_type == value_t::null;
2784 return m_type == value_t::boolean;
2814 return is_number_integer() or is_number_float();
2843 return m_type == value_t::number_integer or m_type == value_t::number_unsigned;
2871 return m_type == value_t::number_unsigned;
2899 return m_type == value_t::number_float;
2921 return m_type == value_t::object;
2943 return m_type == value_t::array;
2965 return m_type == value_t::string;
2992 return m_type == value_t::discarded;
3013 constexpr
operator value_t() const noexcept
3030 return m_value.boolean;
3033 JSON_THROW(std::domain_error(
"type must be boolean, but is " + type_name()));
3039 return is_object() ? m_value.object :
nullptr;
3045 return is_object() ? m_value.object :
nullptr;
3051 return is_array() ? m_value.array :
nullptr;
3055 constexpr
const array_t* get_impl_ptr(
const array_t* )
const noexcept
3057 return is_array() ? m_value.array :
nullptr;
3063 return is_string() ? m_value.string :
nullptr;
3069 return is_string() ? m_value.string :
nullptr;
3075 return is_boolean() ? &m_value.boolean :
nullptr;
3081 return is_boolean() ? &m_value.boolean :
nullptr;
3087 return is_number_integer() ? &m_value.number_integer :
nullptr;
3093 return is_number_integer() ? &m_value.number_integer :
nullptr;
3099 return is_number_unsigned() ? &m_value.number_unsigned :
nullptr;
3105 return is_number_unsigned() ? &m_value.number_unsigned :
nullptr;
3111 return is_number_float() ? &m_value.number_float :
nullptr;
3117 return is_number_float() ? &m_value.number_float :
nullptr;
3131 template<
typename ReferenceType,
typename ThisType>
3132 static ReferenceType get_ref_impl(ThisType& obj)
3135 using PointerType =
typename std::add_pointer<ReferenceType>::type;
3138 auto ptr = obj.template get_ptr<PointerType>();
3145 JSON_THROW(std::domain_error(
"incompatible ReferenceType for get_ref, actual type is " +
3169 typename BasicJsonType,
3170 detail::enable_if_t<std::is_same<typename std::remove_const<BasicJsonType>::type,
3218 typename ValueTypeCV,
3219 typename ValueType = detail::uncvref_t<ValueTypeCV>,
3220 detail::enable_if_t <
3221 not std::is_same<basic_json_t, ValueType>::value and
3222 detail::has_from_json<basic_json_t, ValueType>::value and
3223 not detail::has_non_default_from_json<basic_json_t, ValueType>::value,
3225 ValueType
get()
const noexcept(noexcept(
3226 JSONSerializer<ValueType>::from_json(std::declval<const basic_json_t&>(), std::declval<ValueType&>())))
3231 static_assert(not std::is_reference<ValueTypeCV>::value,
3232 "get() cannot be used with reference types, you might want to use get_ref()");
3233 static_assert(std::is_default_constructible<ValueType>::value,
3234 "types must be DefaultConstructible when used with get()");
3237 JSONSerializer<ValueType>::from_json(*
this, ret);
3273 typename ValueTypeCV,
3274 typename ValueType = detail::uncvref_t<ValueTypeCV>,
3275 detail::enable_if_t<not std::is_same<basic_json_t, ValueType>::value and
3277 ValueType>::value,
int> = 0 >
3278 ValueType
get()
const noexcept(noexcept(
3279 JSONSerializer<ValueTypeCV>::from_json(std::declval<const basic_json_t&>())))
3281 static_assert(not std::is_reference<ValueTypeCV>::value,
3282 "get() cannot be used with reference types, you might want to use get_ref()");
3283 return JSONSerializer<ValueTypeCV>::from_json(*
this);
3313 template<
typename PointerType,
typename std::enable_if<
3314 std::is_pointer<PointerType>::value,
int>::type = 0>
3315 PointerType
get() noexcept
3318 return get_ptr<PointerType>();
3325 template<
typename PointerType,
typename std::enable_if<
3326 std::is_pointer<PointerType>::value,
int>::type = 0>
3327 constexpr
const PointerType
get()
const noexcept
3330 return get_ptr<PointerType>();
3359 template<
typename PointerType,
typename std::enable_if<
3360 std::is_pointer<PointerType>::value,
int>::type = 0>
3364 using pointee_t =
typename std::remove_const<
typename 3365 std::remove_pointer<
typename 3366 std::remove_const<PointerType>::type>::type>::type;
3369 std::is_same<object_t, pointee_t>::value
3370 or std::is_same<array_t, pointee_t>::value
3371 or std::is_same<string_t, pointee_t>::value
3372 or std::is_same<boolean_t, pointee_t>::value
3373 or std::is_same<number_integer_t, pointee_t>::value
3374 or std::is_same<number_unsigned_t, pointee_t>::value
3375 or std::is_same<number_float_t, pointee_t>::value
3376 ,
"incompatible pointer type");
3379 return get_impl_ptr(static_cast<PointerType>(
nullptr));
3386 template<
typename PointerType,
typename std::enable_if<
3387 std::is_pointer<PointerType>::value and
3388 std::is_const<typename std::remove_pointer<PointerType>::type>::value,
int>::type = 0>
3389 constexpr
const PointerType
get_ptr() const noexcept
3392 using pointee_t =
typename std::remove_const<
typename 3393 std::remove_pointer<
typename 3394 std::remove_const<PointerType>::type>::type>::type;
3397 std::is_same<object_t, pointee_t>::value
3398 or std::is_same<array_t, pointee_t>::value
3399 or std::is_same<string_t, pointee_t>::value
3400 or std::is_same<boolean_t, pointee_t>::value
3401 or std::is_same<number_integer_t, pointee_t>::value
3402 or std::is_same<number_unsigned_t, pointee_t>::value
3403 or std::is_same<number_float_t, pointee_t>::value
3404 ,
"incompatible pointer type");
3407 return get_impl_ptr(static_cast<const PointerType>(
nullptr));
3436 template<
typename ReferenceType,
typename std::enable_if<
3437 std::is_reference<ReferenceType>::value,
int>::type = 0>
3441 return get_ref_impl<ReferenceType>(*this);
3448 template<
typename ReferenceType,
typename std::enable_if<
3449 std::is_reference<ReferenceType>::value and
3450 std::is_const<typename std::remove_reference<ReferenceType>::type>::value,
int>::type = 0>
3454 return get_ref_impl<ReferenceType>(*this);
3485 template <
typename ValueType,
typename std::enable_if <
3486 not std::is_pointer<ValueType>::value and
3487 not std::is_same<ValueType, typename string_t::value_type>::value
3488 #ifndef _MSC_VER // fix for issue #167 operator<< ambiguity under VS2015 3489 and not std::is_same<ValueType, std::initializer_list<typename string_t::value_type>>::value
3492 operator ValueType()
const 3495 return get<ValueType>();
3538 return m_value.array->at(idx);
3540 JSON_CATCH (std::out_of_range&)
3543 JSON_THROW(std::out_of_range(
"array index " + std::to_string(idx) +
" is out of range"));
3548 JSON_THROW(std::domain_error(
"cannot use at() with " + type_name()));
3581 return m_value.array->at(idx);
3583 JSON_CATCH (std::out_of_range&)
3586 JSON_THROW(std::out_of_range(
"array index " + std::to_string(idx) +
" is out of range"));
3591 JSON_THROW(std::domain_error(
"cannot use at() with " + type_name()));
3628 return m_value.object->at(key);
3630 JSON_CATCH (std::out_of_range&)
3633 JSON_THROW(std::out_of_range(
"key '" + key +
"' not found"));
3638 JSON_THROW(std::domain_error(
"cannot use at() with " + type_name()));
3675 return m_value.object->at(key);
3677 JSON_CATCH (std::out_of_range&)
3680 JSON_THROW(std::out_of_range(
"key '" + key +
"' not found"));
3685 JSON_THROW(std::domain_error(
"cannot use at() with " + type_name()));
3719 m_type = value_t::array;
3720 m_value.
array = create<array_t>();
3728 if (idx >= m_value.array->size())
3730 m_value.array->insert(m_value.array->end(),
3731 idx - m_value.array->size() + 1,
3735 return m_value.array->operator[](idx);
3738 JSON_THROW(std::domain_error(
"cannot use operator[] with " + type_name()));
3765 return m_value.
array->operator[](idx);
3768 JSON_THROW(std::domain_error(
"cannot use operator[] with " + type_name()));
3803 m_type = value_t::object;
3804 m_value.
object = create<object_t>();
3811 return m_value.object->operator[](key);
3814 JSON_THROW(std::domain_error(
"cannot use operator[] with " + type_name()));
3852 assert(m_value.object->find(key) != m_value.object->end());
3856 JSON_THROW(std::domain_error(
"cannot use operator[] with " + type_name()));
3886 template<
typename T, std::
size_t n>
3889 return operator[](static_cast<const T>(key));
3921 template<
typename T, std::
size_t n>
3924 return operator[](static_cast<const T>(key));
3954 template<
typename T>
3960 m_type = value_t::object;
3961 m_value = value_t::object;
3968 return m_value.object->operator[](key);
3971 JSON_THROW(std::domain_error(
"cannot use operator[] with " + type_name()));
4004 template<
typename T>
4010 assert(m_value.object->find(key) != m_value.object->end());
4014 JSON_THROW(std::domain_error(
"cannot use operator[] with " + type_name()));
4065 template<
class ValueType,
typename std::enable_if<
4066 std::is_convertible<basic_json_t, ValueType>::value,
int>::type = 0>
4067 ValueType
value(
const typename object_t::key_type& key, ValueType default_value)
const 4073 const auto it = find(key);
4079 return default_value;
4083 JSON_THROW(std::domain_error(
"cannot use value() with " + type_name()));
4091 string_t value(
const typename object_t::key_type& key,
const char* default_value)
const 4093 return value(key,
string_t(default_value));
4137 template<
class ValueType,
typename std::enable_if<
4138 std::is_convertible<basic_json_t, ValueType>::value,
int>::type = 0>
4147 return ptr.get_checked(
this);
4149 JSON_CATCH (std::out_of_range&)
4151 return default_value;
4155 JSON_THROW(std::domain_error(
"cannot use value() with " + type_name()));
4164 return value(ptr,
string_t(default_value));
4297 template<
class IteratorType,
typename std::enable_if<
4298 std::is_same<IteratorType, typename basic_json_t::iterator>::value or
4299 std::is_same<IteratorType, typename basic_json_t::const_iterator>::value,
int>::type
4304 if (
this != pos.m_object)
4306 JSON_THROW(std::domain_error(
"iterator does not fit current value"));
4309 IteratorType result = end();
4313 case value_t::boolean:
4314 case value_t::number_float:
4315 case value_t::number_integer:
4316 case value_t::number_unsigned:
4317 case value_t::string:
4319 if (not pos.m_it.primitive_iterator.is_begin())
4321 JSON_THROW(std::out_of_range(
"iterator out of range"));
4326 AllocatorType<string_t> alloc;
4327 alloc.destroy(m_value.string);
4328 alloc.deallocate(m_value.string, 1);
4329 m_value.string =
nullptr;
4332 m_type = value_t::null;
4337 case value_t::object:
4339 result.m_it.object_iterator = m_value.object->erase(pos.m_it.object_iterator);
4343 case value_t::array:
4345 result.m_it.array_iterator = m_value.array->erase(pos.m_it.array_iterator);
4351 JSON_THROW(std::domain_error(
"cannot use erase() with " + type_name()));
4404 template<
class IteratorType,
typename std::enable_if<
4405 std::is_same<IteratorType, typename basic_json_t::iterator>::value or
4406 std::is_same<IteratorType, typename basic_json_t::const_iterator>::value,
int>::type
4408 IteratorType
erase(IteratorType first, IteratorType last)
4411 if (
this != first.m_object or
this != last.m_object)
4413 JSON_THROW(std::domain_error(
"iterators do not fit current value"));
4416 IteratorType result = end();
4420 case value_t::boolean:
4421 case value_t::number_float:
4422 case value_t::number_integer:
4423 case value_t::number_unsigned:
4424 case value_t::string:
4426 if (not first.m_it.primitive_iterator.is_begin() or not last.m_it.primitive_iterator.is_end())
4428 JSON_THROW(std::out_of_range(
"iterators out of range"));
4433 AllocatorType<string_t> alloc;
4434 alloc.destroy(m_value.string);
4435 alloc.deallocate(m_value.string, 1);
4436 m_value.string =
nullptr;
4439 m_type = value_t::null;
4444 case value_t::object:
4446 result.m_it.object_iterator = m_value.object->erase(first.m_it.object_iterator,
4447 last.m_it.object_iterator);
4451 case value_t::array:
4453 result.m_it.array_iterator = m_value.array->erase(first.m_it.array_iterator,
4454 last.m_it.array_iterator);
4460 JSON_THROW(std::domain_error(
"cannot use erase() with " + type_name()));
4501 return m_value.object->erase(key);
4504 JSON_THROW(std::domain_error(
"cannot use erase() with " + type_name()));
4538 JSON_THROW(std::out_of_range(
"array index " + std::to_string(idx) +
" is out of range"));
4541 m_value.array->erase(m_value.array->begin() +
static_cast<difference_type>(idx));
4545 JSON_THROW(std::domain_error(
"cannot use erase() with " + type_name()));
4583 auto result = end();
4587 result.m_it.object_iterator = m_value.object->find(key);
4599 auto result = cend();
4603 result.m_it.object_iterator = m_value.object->find(key);
4633 return is_object() ? m_value.object->count(key) : 0;
4921 template<
typename IteratorType>
class iteration_proxy;
4937 return iteration_proxy<iterator>(cont);
4945 return iteration_proxy<const_iterator>(cont);
5005 case value_t::array:
5008 return m_value.array->empty();
5011 case value_t::object:
5014 return m_value.object->empty();
5073 case value_t::array:
5076 return m_value.array->size();
5079 case value_t::object:
5082 return m_value.object->size();
5133 case value_t::array:
5136 return m_value.array->max_size();
5139 case value_t::object:
5142 return m_value.object->max_size();
5189 case value_t::number_integer:
5191 m_value.number_integer = 0;
5195 case value_t::number_unsigned:
5197 m_value.number_unsigned = 0;
5201 case value_t::number_float:
5203 m_value.number_float = 0.0;
5207 case value_t::boolean:
5209 m_value.boolean =
false;
5213 case value_t::string:
5215 m_value.string->clear();
5219 case value_t::array:
5221 m_value.array->clear();
5225 case value_t::object:
5227 m_value.object->clear();
5261 if (not(is_null() or is_array()))
5263 JSON_THROW(std::domain_error(
"cannot use push_back() with " + type_name()));
5269 m_type = value_t::array;
5270 m_value = value_t::array;
5275 m_value.array->push_back(std::move(val));
5277 val.m_type = value_t::null;
5286 push_back(std::move(val));
5297 if (not(is_null() or is_array()))
5299 JSON_THROW(std::domain_error(
"cannot use push_back() with " + type_name()));
5305 m_type = value_t::array;
5306 m_value = value_t::array;
5311 m_value.array->push_back(val);
5347 if (not(is_null() or is_object()))
5349 JSON_THROW(std::domain_error(
"cannot use push_back() with " + type_name()));
5355 m_type = value_t::object;
5356 m_value = value_t::object;
5361 m_value.object->insert(val);
5401 if (is_object() and init.size() == 2 and init.begin()->is_string())
5403 const string_t key = *init.begin();
5404 push_back(
typename object_t::value_type(key, *(init.begin() + 1)));
5443 template<
class... Args>
5447 if (not(is_null() or is_array()))
5449 JSON_THROW(std::domain_error(
"cannot use emplace_back() with " + type_name()));
5455 m_type = value_t::array;
5456 m_value = value_t::array;
5461 m_value.array->emplace_back(std::forward<Args>(args)...);
5491 template<
class... Args>
5492 std::pair<iterator, bool>
emplace(Args&& ... args)
5495 if (not(is_null() or is_object()))
5497 JSON_THROW(std::domain_error(
"cannot use emplace() with " + type_name()));
5503 m_type = value_t::object;
5504 m_value = value_t::object;
5509 auto res = m_value.object->emplace(std::forward<Args>(args)...);
5512 it.m_it.object_iterator = res.first;
5515 return {it, res.second};
5546 if (pos.m_object !=
this)
5548 JSON_THROW(std::domain_error(
"iterator does not fit current value"));
5553 result.m_it.array_iterator = m_value.array->insert(pos.m_it.array_iterator, val);
5557 JSON_THROW(std::domain_error(
"cannot use insert() with " + type_name()));
5566 return insert(pos, val);
5599 if (pos.m_object !=
this)
5601 JSON_THROW(std::domain_error(
"iterator does not fit current value"));
5606 result.m_it.array_iterator = m_value.array->insert(pos.m_it.array_iterator, cnt, val);
5610 JSON_THROW(std::domain_error(
"cannot use insert() with " + type_name()));
5648 JSON_THROW(std::domain_error(
"cannot use insert() with " + type_name()));
5652 if (pos.m_object !=
this)
5654 JSON_THROW(std::domain_error(
"iterator does not fit current value"));
5658 if (first.m_object != last.m_object)
5660 JSON_THROW(std::domain_error(
"iterators do not fit"));
5663 if (first.m_object ==
this or last.m_object ==
this)
5665 JSON_THROW(std::domain_error(
"passed iterators may not belong to container"));
5670 result.m_it.array_iterator = m_value.array->insert(
5671 pos.m_it.array_iterator,
5672 first.m_it.array_iterator,
5673 last.m_it.array_iterator);
5706 JSON_THROW(std::domain_error(
"cannot use insert() with " + type_name()));
5710 if (pos.m_object !=
this)
5712 JSON_THROW(std::domain_error(
"iterator does not fit current value"));
5717 result.m_it.array_iterator = m_value.array->insert(pos.m_it.array_iterator, ilist);
5739 std::is_nothrow_move_constructible<value_t>::value and
5740 std::is_nothrow_move_assignable<value_t>::value and
5741 std::is_nothrow_move_constructible<json_value>::value and
5742 std::is_nothrow_move_assignable<json_value>::value
5745 std::swap(m_type, other.m_type);
5746 std::swap(m_value, other.m_value);
5775 std::swap(*(m_value.array), other);
5779 JSON_THROW(std::domain_error(
"cannot use swap() with " + type_name()));
5808 std::swap(*(m_value.object), other);
5812 JSON_THROW(std::domain_error(
"cannot use swap() with " + type_name()));
5841 std::swap(*(m_value.string), other);
5845 JSON_THROW(std::domain_error(
"cannot use swap() with " + type_name()));
5884 const auto lhs_type = lhs.type();
5885 const auto rhs_type = rhs.type();
5887 if (lhs_type == rhs_type)
5891 case value_t::array:
5893 return *lhs.m_value.array == *rhs.m_value.array;
5895 case value_t::object:
5897 return *lhs.m_value.object == *rhs.m_value.object;
5903 case value_t::string:
5905 return *lhs.m_value.string == *rhs.m_value.string;
5907 case value_t::boolean:
5909 return lhs.m_value.boolean == rhs.m_value.boolean;
5911 case value_t::number_integer:
5913 return lhs.m_value.number_integer == rhs.m_value.number_integer;
5915 case value_t::number_unsigned:
5917 return lhs.m_value.number_unsigned == rhs.m_value.number_unsigned;
5919 case value_t::number_float:
5921 return lhs.m_value.number_float == rhs.m_value.number_float;
5929 else if (lhs_type == value_t::number_integer and rhs_type == value_t::number_float)
5931 return static_cast<number_float_t>(lhs.m_value.number_integer) == rhs.m_value.number_float;
5933 else if (lhs_type == value_t::number_float and rhs_type == value_t::number_integer)
5935 return lhs.m_value.number_float ==
static_cast<number_float_t>(rhs.m_value.number_integer);
5937 else if (lhs_type == value_t::number_unsigned and rhs_type == value_t::number_float)
5939 return static_cast<number_float_t>(lhs.m_value.number_unsigned) == rhs.m_value.number_float;
5941 else if (lhs_type == value_t::number_float and rhs_type == value_t::number_unsigned)
5943 return lhs.m_value.number_float ==
static_cast<number_float_t>(rhs.m_value.number_unsigned);
5945 else if (lhs_type == value_t::number_unsigned and rhs_type == value_t::number_integer)
5947 return static_cast<number_integer_t>(lhs.m_value.number_unsigned) == rhs.m_value.number_integer;
5949 else if (lhs_type == value_t::number_integer and rhs_type == value_t::number_unsigned)
5951 return lhs.m_value.number_integer ==
static_cast<number_integer_t>(rhs.m_value.number_unsigned);
5961 template<
typename ScalarType,
typename std::enable_if<
5962 std::is_scalar<ScalarType>::value,
int>::type = 0>
5972 template<
typename ScalarType,
typename std::enable_if<
5973 std::is_scalar<ScalarType>::value,
int>::type = 0>
5997 return not (lhs == rhs);
6004 template<
typename ScalarType,
typename std::enable_if<
6005 std::is_scalar<ScalarType>::value,
int>::type = 0>
6015 template<
typename ScalarType,
typename std::enable_if<
6016 std::is_scalar<ScalarType>::value,
int>::type = 0>
6048 const auto lhs_type = lhs.type();
6049 const auto rhs_type = rhs.type();
6051 if (lhs_type == rhs_type)
6055 case value_t::array:
6057 return *lhs.m_value.array < *rhs.m_value.array;
6059 case value_t::object:
6061 return *lhs.m_value.object < *rhs.m_value.object;
6067 case value_t::string:
6069 return *lhs.m_value.string < *rhs.m_value.string;
6071 case value_t::boolean:
6073 return lhs.m_value.boolean < rhs.m_value.boolean;
6075 case value_t::number_integer:
6077 return lhs.m_value.number_integer < rhs.m_value.number_integer;
6079 case value_t::number_unsigned:
6081 return lhs.m_value.number_unsigned < rhs.m_value.number_unsigned;
6083 case value_t::number_float:
6085 return lhs.m_value.number_float < rhs.m_value.number_float;
6093 else if (lhs_type == value_t::number_integer and rhs_type == value_t::number_float)
6095 return static_cast<number_float_t>(lhs.m_value.number_integer) < rhs.m_value.number_float;
6097 else if (lhs_type == value_t::number_float and rhs_type == value_t::number_integer)
6099 return lhs.m_value.number_float <
static_cast<number_float_t>(rhs.m_value.number_integer);
6101 else if (lhs_type == value_t::number_unsigned and rhs_type == value_t::number_float)
6103 return static_cast<number_float_t>(lhs.m_value.number_unsigned) < rhs.m_value.number_float;
6105 else if (lhs_type == value_t::number_float and rhs_type == value_t::number_unsigned)
6107 return lhs.m_value.number_float <
static_cast<number_float_t>(rhs.m_value.number_unsigned);
6109 else if (lhs_type == value_t::number_integer and rhs_type == value_t::number_unsigned)
6111 return lhs.m_value.number_integer <
static_cast<number_integer_t>(rhs.m_value.number_unsigned);
6113 else if (lhs_type == value_t::number_unsigned and rhs_type == value_t::number_integer)
6115 return static_cast<number_integer_t>(lhs.m_value.number_unsigned) < rhs.m_value.number_integer;
6121 return operator<(lhs_type, rhs_type);
6143 return not (rhs < lhs);
6165 return not (lhs <= rhs);
6187 return not (lhs < rhs);
6225 const bool pretty_print = (o.width() > 0);
6226 const auto indentation = (pretty_print ? o.width() : 0);
6232 j.
dump(o, pretty_print, static_cast<unsigned int>(indentation));
6283 template<
class T, std::
size_t N>
6288 return parse(std::begin(array), std::end(array), cb);
6318 template<
typename CharT,
typename std::enable_if<
6319 std::is_pointer<CharT>::value and
6320 std::is_integral<typename std::remove_pointer<CharT>::type>::value and
6321 sizeof(
typename std::remove_pointer<CharT>::type) == 1,
int>::type = 0>
6325 return parser(reinterpret_cast<const char*>(s), cb).
parse();
6355 return parser(i, cb).
parse();
6364 return parser(i, cb).
parse();
6408 template<
class IteratorType,
typename std::enable_if<
6410 std::random_access_iterator_tag,
6411 typename std::iterator_traits<IteratorType>::iterator_category>::value,
int>::type = 0>
6417 assert(std::accumulate(first, last, std::pair<bool, int>(
true, 0),
6418 [&first](std::pair<bool, int> res, decltype(*first) val)
6420 res.first &= (val == *(std::next(std::addressof(*first), res.second++)));
6425 static_assert(
sizeof(
typename std::iterator_traits<IteratorType>::value_type) == 1,
6426 "each element in the iterator range must have the size of 1 byte");
6430 if (std::distance(first, last) <= 0)
6432 return parser(
"").parse();
6435 return parser(first, last, cb).parse();
6478 template<
class ContiguousContainer,
typename std::enable_if<
6479 not std::is_pointer<ContiguousContainer>::value and
6481 std::random_access_iterator_tag,
6482 typename std::iterator_traits<decltype(std::begin(std::declval<ContiguousContainer const>()))>::iterator_category>::value
6488 return parse(std::begin(c), std::end(c), cb);
6516 j = parser(i).
parse();
6526 j = parser(i).
parse();
6545 template<
typename T>
6546 static void add_to_vector(std::vector<uint8_t>& vec,
size_t bytes,
const T number)
6548 assert(bytes == 1 or bytes == 2 or bytes == 4 or bytes == 8);
6554 vec.push_back(static_cast<uint8_t>((static_cast<uint64_t>(number) >> 070) & 0xff));
6555 vec.push_back(static_cast<uint8_t>((static_cast<uint64_t>(number) >> 060) & 0xff));
6556 vec.push_back(static_cast<uint8_t>((static_cast<uint64_t>(number) >> 050) & 0xff));
6557 vec.push_back(static_cast<uint8_t>((static_cast<uint64_t>(number) >> 040) & 0xff));
6558 vec.push_back(static_cast<uint8_t>((number >> 030) & 0xff));
6559 vec.push_back(static_cast<uint8_t>((number >> 020) & 0xff));
6560 vec.push_back(static_cast<uint8_t>((number >> 010) & 0xff));
6561 vec.push_back(static_cast<uint8_t>(number & 0xff));
6567 vec.push_back(static_cast<uint8_t>((number >> 030) & 0xff));
6568 vec.push_back(static_cast<uint8_t>((number >> 020) & 0xff));
6569 vec.push_back(static_cast<uint8_t>((number >> 010) & 0xff));
6570 vec.push_back(static_cast<uint8_t>(number & 0xff));
6576 vec.push_back(static_cast<uint8_t>((number >> 010) & 0xff));
6577 vec.push_back(static_cast<uint8_t>(number & 0xff));
6583 vec.push_back(static_cast<uint8_t>(number & 0xff));
6625 template<
typename T>
6626 static T get_from_vector(
const std::vector<uint8_t>& vec,
const size_t current_index)
6628 if (current_index +
sizeof(T) + 1 > vec.size())
6630 JSON_THROW(std::out_of_range(
"cannot read " + std::to_string(
sizeof(T)) +
" bytes from vector"));
6634 auto* ptr =
reinterpret_cast<uint8_t*
>(&result);
6635 for (
size_t i = 0; i <
sizeof(T); ++i)
6637 *ptr++ = vec[current_index +
sizeof(T) - i];
6652 static void to_msgpack_internal(
const basic_json& j, std::vector<uint8_t>& v)
6663 case value_t::boolean:
6666 v.push_back(j.m_value.boolean ? 0xc3 : 0xc2);
6670 case value_t::number_integer:
6672 if (j.m_value.number_integer >= 0)
6678 if (j.m_value.number_unsigned < 128)
6681 add_to_vector(v, 1, j.m_value.number_unsigned);
6683 else if (j.m_value.number_unsigned <= std::numeric_limits<uint8_t>::max())
6687 add_to_vector(v, 1, j.m_value.number_unsigned);
6689 else if (j.m_value.number_unsigned <= std::numeric_limits<uint16_t>::max())
6693 add_to_vector(v, 2, j.m_value.number_unsigned);
6695 else if (j.m_value.number_unsigned <= std::numeric_limits<uint32_t>::max())
6699 add_to_vector(v, 4, j.m_value.number_unsigned);
6701 else if (j.m_value.number_unsigned <= std::numeric_limits<uint64_t>::max())
6705 add_to_vector(v, 8, j.m_value.number_unsigned);
6710 if (j.m_value.number_integer >= -32)
6713 add_to_vector(v, 1, j.m_value.number_integer);
6715 else if (j.m_value.number_integer >= std::numeric_limits<int8_t>::min() and j.m_value.number_integer <= std::numeric_limits<int8_t>::max())
6719 add_to_vector(v, 1, j.m_value.number_integer);
6721 else if (j.m_value.number_integer >= std::numeric_limits<int16_t>::min() and j.m_value.number_integer <= std::numeric_limits<int16_t>::max())
6725 add_to_vector(v, 2, j.m_value.number_integer);
6727 else if (j.m_value.number_integer >= std::numeric_limits<int32_t>::min() and j.m_value.number_integer <= std::numeric_limits<int32_t>::max())
6731 add_to_vector(v, 4, j.m_value.number_integer);
6733 else if (j.m_value.number_integer >= std::numeric_limits<int64_t>::min() and j.m_value.number_integer <= std::numeric_limits<int64_t>::max())
6737 add_to_vector(v, 8, j.m_value.number_integer);
6743 case value_t::number_unsigned:
6745 if (j.m_value.number_unsigned < 128)
6748 add_to_vector(v, 1, j.m_value.number_unsigned);
6750 else if (j.m_value.number_unsigned <= std::numeric_limits<uint8_t>::max())
6754 add_to_vector(v, 1, j.m_value.number_unsigned);
6756 else if (j.m_value.number_unsigned <= std::numeric_limits<uint16_t>::max())
6760 add_to_vector(v, 2, j.m_value.number_unsigned);
6762 else if (j.m_value.number_unsigned <= std::numeric_limits<uint32_t>::max())
6766 add_to_vector(v, 4, j.m_value.number_unsigned);
6768 else if (j.m_value.number_unsigned <= std::numeric_limits<uint64_t>::max())
6772 add_to_vector(v, 8, j.m_value.number_unsigned);
6777 case value_t::number_float:
6781 const auto* helper =
reinterpret_cast<const uint8_t*
>(&(j.m_value.number_float));
6782 for (
size_t i = 0; i < 8; ++i)
6784 v.push_back(helper[7 - i]);
6789 case value_t::string:
6791 const auto N = j.m_value.string->size();
6795 v.push_back(static_cast<uint8_t>(0xa0 | N));
6801 add_to_vector(v, 1, N);
6803 else if (N <= 65535)
6807 add_to_vector(v, 2, N);
6809 else if (N <= 4294967295)
6813 add_to_vector(v, 4, N);
6817 std::copy(j.m_value.string->begin(), j.m_value.string->end(),
6818 std::back_inserter(v));
6822 case value_t::array:
6824 const auto N = j.m_value.array->size();
6828 v.push_back(static_cast<uint8_t>(0x90 | N));
6830 else if (N <= 0xffff)
6834 add_to_vector(v, 2, N);
6836 else if (N <= 0xffffffff)
6840 add_to_vector(v, 4, N);
6844 for (
const auto& el : *j.m_value.array)
6846 to_msgpack_internal(el, v);
6851 case value_t::object:
6853 const auto N = j.m_value.object->size();
6857 v.push_back(static_cast<uint8_t>(0x80 | (N & 0xf)));
6859 else if (N <= 65535)
6863 add_to_vector(v, 2, N);
6865 else if (N <= 4294967295)
6869 add_to_vector(v, 4, N);
6873 for (
const auto& el : *j.m_value.object)
6875 to_msgpack_internal(el.first, v);
6876 to_msgpack_internal(el.second, v);
6898 static void to_cbor_internal(
const basic_json& j, std::vector<uint8_t>& v)
6908 case value_t::boolean:
6910 v.push_back(j.m_value.boolean ? 0xf5 : 0xf4);
6914 case value_t::number_integer:
6916 if (j.m_value.number_integer >= 0)
6921 if (j.m_value.number_integer <= 0x17)
6923 add_to_vector(v, 1, j.m_value.number_integer);
6925 else if (j.m_value.number_integer <= std::numeric_limits<uint8_t>::max())
6929 add_to_vector(v, 1, j.m_value.number_integer);
6931 else if (j.m_value.number_integer <= std::numeric_limits<uint16_t>::max())
6935 add_to_vector(v, 2, j.m_value.number_integer);
6937 else if (j.m_value.number_integer <= std::numeric_limits<uint32_t>::max())
6941 add_to_vector(v, 4, j.m_value.number_integer);
6947 add_to_vector(v, 8, j.m_value.number_integer);
6954 const auto positive_number = -1 - j.m_value.number_integer;
6955 if (j.m_value.number_integer >= -24)
6957 v.push_back(static_cast<uint8_t>(0x20 + positive_number));
6959 else if (positive_number <= std::numeric_limits<uint8_t>::max())
6963 add_to_vector(v, 1, positive_number);
6965 else if (positive_number <= std::numeric_limits<uint16_t>::max())
6969 add_to_vector(v, 2, positive_number);
6971 else if (positive_number <= std::numeric_limits<uint32_t>::max())
6975 add_to_vector(v, 4, positive_number);
6981 add_to_vector(v, 8, positive_number);
6987 case value_t::number_unsigned:
6989 if (j.m_value.number_unsigned <= 0x17)
6991 v.push_back(static_cast<uint8_t>(j.m_value.number_unsigned));
6993 else if (j.m_value.number_unsigned <= 0xff)
6997 add_to_vector(v, 1, j.m_value.number_unsigned);
6999 else if (j.m_value.number_unsigned <= 0xffff)
7003 add_to_vector(v, 2, j.m_value.number_unsigned);
7005 else if (j.m_value.number_unsigned <= 0xffffffff)
7009 add_to_vector(v, 4, j.m_value.number_unsigned);
7011 else if (j.m_value.number_unsigned <= 0xffffffffffffffff)
7015 add_to_vector(v, 8, j.m_value.number_unsigned);
7020 case value_t::number_float:
7024 const auto* helper =
reinterpret_cast<const uint8_t*
>(&(j.m_value.number_float));
7025 for (
size_t i = 0; i < 8; ++i)
7027 v.push_back(helper[7 - i]);
7032 case value_t::string:
7034 const auto N = j.m_value.string->size();
7037 v.push_back(0x60 + static_cast<uint8_t>(N));
7042 add_to_vector(v, 1, N);
7044 else if (N <= 0xffff)
7047 add_to_vector(v, 2, N);
7049 else if (N <= 0xffffffff)
7052 add_to_vector(v, 4, N);
7055 else if (N <= 0xffffffffffffffff)
7058 add_to_vector(v, 8, N);
7063 std::copy(j.m_value.string->begin(), j.m_value.string->end(),
7064 std::back_inserter(v));
7068 case value_t::array:
7070 const auto N = j.m_value.array->size();
7073 v.push_back(0x80 + static_cast<uint8_t>(N));
7078 add_to_vector(v, 1, N);
7080 else if (N <= 0xffff)
7083 add_to_vector(v, 2, N);
7085 else if (N <= 0xffffffff)
7088 add_to_vector(v, 4, N);
7091 else if (N <= 0xffffffffffffffff)
7094 add_to_vector(v, 8, N);
7099 for (
const auto& el : *j.m_value.array)
7101 to_cbor_internal(el, v);
7106 case value_t::object:
7108 const auto N = j.m_value.object->size();
7111 v.push_back(0xa0 + static_cast<uint8_t>(N));
7116 add_to_vector(v, 1, N);
7118 else if (N <= 0xffff)
7121 add_to_vector(v, 2, N);
7123 else if (N <= 0xffffffff)
7126 add_to_vector(v, 4, N);
7129 else if (N <= 0xffffffffffffffff)
7132 add_to_vector(v, 8, N);
7137 for (
const auto& el : *j.m_value.object)
7139 to_cbor_internal(el.first, v);
7140 to_cbor_internal(el.second, v);
7175 static void check_length(
const size_t size,
const size_t len,
const size_t offset)
7178 if (len > size or offset > size)
7180 JSON_THROW(std::out_of_range(
"len out of range"));
7184 if ((size > (std::numeric_limits<size_t>::max() - offset)))
7186 JSON_THROW(std::out_of_range(
"len+offset out of range"));
7190 if (len + offset > size)
7192 JSON_THROW(std::out_of_range(
"len+offset out of range"));
7210 static basic_json from_msgpack_internal(
const std::vector<uint8_t>& v,
size_t& idx)
7213 check_length(v.size(), 1, idx);
7216 const size_t current_idx = idx++;
7218 if (v[current_idx] <= 0xbf)
7220 if (v[current_idx] <= 0x7f)
7222 return v[current_idx];
7224 if (v[current_idx] <= 0x8f)
7227 const size_t len = v[current_idx] & 0x0f;
7228 for (
size_t i = 0; i < len; ++i)
7230 std::string key = from_msgpack_internal(v, idx);
7231 result[key] = from_msgpack_internal(v, idx);
7235 else if (v[current_idx] <= 0x9f)
7238 const size_t len = v[current_idx] & 0x0f;
7239 for (
size_t i = 0; i < len; ++i)
7241 result.
push_back(from_msgpack_internal(v, idx));
7247 const size_t len = v[current_idx] & 0x1f;
7248 const size_t offset = current_idx + 1;
7250 check_length(v.size(), len, offset);
7251 return std::string(reinterpret_cast<const char*>(v.data()) + offset, len);
7254 else if (v[current_idx] >= 0xe0)
7256 return static_cast<int8_t
>(v[current_idx]);
7260 switch (v[current_idx])
7264 return value_t::null;
7281 for (
size_t byte = 0; byte <
sizeof(float); ++byte)
7283 reinterpret_cast<uint8_t*
>(&res)[
sizeof(
float) - byte - 1] = v.at(current_idx + 1 + byte);
7285 idx +=
sizeof(float);
7293 for (
size_t byte = 0; byte <
sizeof(double); ++byte)
7295 reinterpret_cast<uint8_t*
>(&res)[
sizeof(
double) - byte - 1] = v.at(current_idx + 1 + byte);
7297 idx +=
sizeof(double);
7304 return get_from_vector<uint8_t>(v, current_idx);
7310 return get_from_vector<uint16_t>(v, current_idx);
7316 return get_from_vector<uint32_t>(v, current_idx);
7322 return get_from_vector<uint64_t>(v, current_idx);
7328 return get_from_vector<int8_t>(v, current_idx);
7334 return get_from_vector<int16_t>(v, current_idx);
7340 return get_from_vector<int32_t>(v, current_idx);
7346 return get_from_vector<int64_t>(v, current_idx);
7351 const auto len =
static_cast<size_t>(get_from_vector<uint8_t>(v, current_idx));
7352 const size_t offset = current_idx + 2;
7354 check_length(v.size(), len, offset);
7355 return std::string(reinterpret_cast<const char*>(v.data()) + offset, len);
7360 const auto len =
static_cast<size_t>(get_from_vector<uint16_t>(v, current_idx));
7361 const size_t offset = current_idx + 3;
7363 check_length(v.size(), len, offset);
7364 return std::string(reinterpret_cast<const char*>(v.data()) + offset, len);
7369 const auto len =
static_cast<size_t>(get_from_vector<uint32_t>(v, current_idx));
7370 const size_t offset = current_idx + 5;
7372 check_length(v.size(), len, offset);
7373 return std::string(reinterpret_cast<const char*>(v.data()) + offset, len);
7379 const auto len =
static_cast<size_t>(get_from_vector<uint16_t>(v, current_idx));
7381 for (
size_t i = 0; i < len; ++i)
7383 result.
push_back(from_msgpack_internal(v, idx));
7391 const auto len =
static_cast<size_t>(get_from_vector<uint32_t>(v, current_idx));
7393 for (
size_t i = 0; i < len; ++i)
7395 result.
push_back(from_msgpack_internal(v, idx));
7403 const auto len =
static_cast<size_t>(get_from_vector<uint16_t>(v, current_idx));
7405 for (
size_t i = 0; i < len; ++i)
7407 std::string key = from_msgpack_internal(v, idx);
7408 result[key] = from_msgpack_internal(v, idx);
7416 const auto len =
static_cast<size_t>(get_from_vector<uint32_t>(v, current_idx));
7418 for (
size_t i = 0; i < len; ++i)
7420 std::string key = from_msgpack_internal(v, idx);
7421 result[key] = from_msgpack_internal(v, idx);
7428 JSON_THROW(std::invalid_argument(
"error parsing a msgpack @ " + std::to_string(current_idx) +
": " + std::to_string(static_cast<int>(v[current_idx]))));
7448 static basic_json from_cbor_internal(
const std::vector<uint8_t>& v,
size_t& idx)
7451 const size_t current_idx = idx++;
7453 switch (v.at(current_idx))
7481 return v[current_idx];
7487 return get_from_vector<uint8_t>(v, current_idx);
7493 return get_from_vector<uint16_t>(v, current_idx);
7499 return get_from_vector<uint32_t>(v, current_idx);
7505 return get_from_vector<uint64_t>(v, current_idx);
7534 return static_cast<int8_t
>(0x20 - 1 - v[current_idx]);
7541 return static_cast<number_integer_t>(-1) - get_from_vector<uint8_t>(v, current_idx);
7547 return static_cast<number_integer_t>(-1) - get_from_vector<uint16_t>(v, current_idx);
7553 return static_cast<number_integer_t>(-1) - get_from_vector<uint32_t>(v, current_idx);
7559 return static_cast<number_integer_t>(-1) - static_cast<number_integer_t>(get_from_vector<uint64_t>(v, current_idx));
7588 const auto len =
static_cast<size_t>(v[current_idx] - 0x60);
7589 const size_t offset = current_idx + 1;
7591 check_length(v.size(), len, offset);
7592 return std::string(reinterpret_cast<const char*>(v.data()) + offset, len);
7597 const auto len =
static_cast<size_t>(get_from_vector<uint8_t>(v, current_idx));
7598 const size_t offset = current_idx + 2;
7600 check_length(v.size(), len, offset);
7601 return std::string(reinterpret_cast<const char*>(v.data()) + offset, len);
7606 const auto len =
static_cast<size_t>(get_from_vector<uint16_t>(v, current_idx));
7607 const size_t offset = current_idx + 3;
7609 check_length(v.size(), len, offset);
7610 return std::string(reinterpret_cast<const char*>(v.data()) + offset, len);
7615 const auto len =
static_cast<size_t>(get_from_vector<uint32_t>(v, current_idx));
7616 const size_t offset = current_idx + 5;
7618 check_length(v.size(), len, offset);
7619 return std::string(reinterpret_cast<const char*>(v.data()) + offset, len);
7624 const auto len =
static_cast<size_t>(get_from_vector<uint64_t>(v, current_idx));
7625 const size_t offset = current_idx + 9;
7627 check_length(v.size(), len, offset);
7628 return std::string(reinterpret_cast<const char*>(v.data()) + offset, len);
7634 while (v.at(idx) != 0xff)
7636 string_t s = from_cbor_internal(v, idx);
7671 const auto len =
static_cast<size_t>(v[current_idx] - 0x80);
7672 for (
size_t i = 0; i < len; ++i)
7674 result.
push_back(from_cbor_internal(v, idx));
7682 const auto len =
static_cast<size_t>(get_from_vector<uint8_t>(v, current_idx));
7684 for (
size_t i = 0; i < len; ++i)
7686 result.
push_back(from_cbor_internal(v, idx));
7694 const auto len =
static_cast<size_t>(get_from_vector<uint16_t>(v, current_idx));
7696 for (
size_t i = 0; i < len; ++i)
7698 result.
push_back(from_cbor_internal(v, idx));
7706 const auto len =
static_cast<size_t>(get_from_vector<uint32_t>(v, current_idx));
7708 for (
size_t i = 0; i < len; ++i)
7710 result.
push_back(from_cbor_internal(v, idx));
7718 const auto len =
static_cast<size_t>(get_from_vector<uint64_t>(v, current_idx));
7720 for (
size_t i = 0; i < len; ++i)
7722 result.
push_back(from_cbor_internal(v, idx));
7730 while (v.at(idx) != 0xff)
7732 result.
push_back(from_cbor_internal(v, idx));
7766 const auto len =
static_cast<size_t>(v[current_idx] - 0xa0);
7767 for (
size_t i = 0; i < len; ++i)
7769 std::string key = from_cbor_internal(v, idx);
7770 result[key] = from_cbor_internal(v, idx);
7778 const auto len =
static_cast<size_t>(get_from_vector<uint8_t>(v, current_idx));
7780 for (
size_t i = 0; i < len; ++i)
7782 std::string key = from_cbor_internal(v, idx);
7783 result[key] = from_cbor_internal(v, idx);
7791 const auto len =
static_cast<size_t>(get_from_vector<uint16_t>(v, current_idx));
7793 for (
size_t i = 0; i < len; ++i)
7795 std::string key = from_cbor_internal(v, idx);
7796 result[key] = from_cbor_internal(v, idx);
7804 const auto len =
static_cast<size_t>(get_from_vector<uint32_t>(v, current_idx));
7806 for (
size_t i = 0; i < len; ++i)
7808 std::string key = from_cbor_internal(v, idx);
7809 result[key] = from_cbor_internal(v, idx);
7817 const auto len =
static_cast<size_t>(get_from_vector<uint64_t>(v, current_idx));
7819 for (
size_t i = 0; i < len; ++i)
7821 std::string key = from_cbor_internal(v, idx);
7822 result[key] = from_cbor_internal(v, idx);
7830 while (v.at(idx) != 0xff)
7832 std::string key = from_cbor_internal(v, idx);
7833 result[key] = from_cbor_internal(v, idx);
7852 return value_t::null;
7866 const int half = (v.at(current_idx + 1) << 8) + v.at(current_idx + 2);
7867 const int exp = (half >> 10) & 0x1f;
7868 const int mant = half & 0x3ff;
7872 val = std::ldexp(mant, -24);
7876 val = std::ldexp(mant + 1024, exp - 25);
7881 ? std::numeric_limits<double>::infinity()
7882 : std::numeric_limits<double>::quiet_NaN();
7884 return (half & 0x8000) != 0 ? -val : val;
7891 for (
size_t byte = 0; byte <
sizeof(float); ++byte)
7893 reinterpret_cast<uint8_t*
>(&res)[
sizeof(
float) - byte - 1] = v.at(current_idx + 1 + byte);
7895 idx +=
sizeof(float);
7903 for (
size_t byte = 0; byte <
sizeof(double); ++byte)
7905 reinterpret_cast<uint8_t*
>(&res)[
sizeof(
double) - byte - 1] = v.at(current_idx + 1 + byte);
7907 idx +=
sizeof(double);
7913 JSON_THROW(std::invalid_argument(
"error parsing a CBOR @ " + std::to_string(current_idx) +
": " + std::to_string(static_cast<int>(v[current_idx]))));
7943 std::vector<uint8_t> result;
7944 to_msgpack_internal(j, result);
7975 const size_t start_index = 0)
7977 size_t i = start_index;
7978 return from_msgpack_internal(v, i);
8006 std::vector<uint8_t> result;
8007 to_cbor_internal(j, result);
8038 const size_t start_index = 0)
8040 size_t i = start_index;
8041 return from_cbor_internal(v, i);
8072 case value_t::object:
8074 case value_t::array:
8076 case value_t::string:
8078 case value_t::boolean:
8080 case value_t::discarded:
8097 static std::size_t extra_space(
const string_t& s) noexcept
8099 return std::accumulate(s.begin(), s.end(),
size_t{},
8100 [](
size_t res,
typename string_t::value_type c)
8118 if (c >= 0x00 and c <= 0x1f)
8145 const auto space = extra_space(s);
8152 string_t result(s.size() + space,
'\\');
8153 std::size_t pos = 0;
8155 for (
const auto& c : s)
8162 result[pos + 1] =
'"';
8178 result[pos + 1] =
'b';
8186 result[pos + 1] =
'f';
8194 result[pos + 1] =
'n';
8202 result[pos + 1] =
'r';
8210 result[pos + 1] =
't';
8217 if (c >= 0x00 and c <= 0x1f)
8221 static const char hexify[16] =
8223 '0',
'1',
'2',
'3',
'4',
'5',
'6',
'7',
8224 '8',
'9',
'a',
'b',
'c',
'd',
'e',
'f' 8229 {
'u',
'0',
'0', hexify[c >> 4], hexify[c & 0x0f]
8257 template<
typename NumberType>
8258 numtostr(NumberType value)
8260 x_write(value, std::is_integral<NumberType>());
8263 const char* c_str()
const 8265 return m_buf.data();
8270 std::array < char, 64 > m_buf{{}};
8272 template<
typename NumberType>
8273 void x_write(NumberType x, std::true_type)
8282 const bool is_negative = x < 0;
8286 while (x != 0 and i < m_buf.size() - 1)
8288 const auto digit = std::labs(static_cast<long>(x % 10));
8289 m_buf[i++] =
static_cast<char>(
'0' + digit);
8299 assert(i < m_buf.size() - 2);
8303 std::reverse(m_buf.begin(), m_buf.begin() + i);
8306 template<
typename NumberType>
8307 void x_write(NumberType x, std::false_type)
8313 if (std::signbit(x))
8324 static constexpr
auto d = std::numeric_limits<NumberType>::digits10;
8327 const auto written_bytes = snprintf(m_buf.data(), m_buf.size(),
"%.*g", d, x);
8330 assert(written_bytes > 0);
8332 assert(static_cast<size_t>(written_bytes) < m_buf.size());
8335 const auto loc = localeconv();
8336 assert(loc !=
nullptr);
8337 const char thousands_sep = !loc->thousands_sep ?
'\0' 8338 : loc->thousands_sep[0];
8340 const char decimal_point = !loc->decimal_point ?
'\0' 8341 : loc->decimal_point[0];
8344 if (thousands_sep !=
'\0')
8346 const auto end = std::remove(m_buf.begin(), m_buf.begin() + written_bytes, thousands_sep);
8347 std::fill(end, m_buf.end(),
'\0');
8351 if (decimal_point !=
'\0' and decimal_point !=
'.')
8353 for (
auto& c : m_buf)
8355 if (c == decimal_point)
8365 bool value_is_int_like =
true;
8366 for (i = 0; i < m_buf.size(); ++i)
8369 if (m_buf[i] ==
'\0')
8375 value_is_int_like = value_is_int_like and m_buf[i] !=
'.' and
8376 m_buf[i] !=
'e' and m_buf[i] !=
'E';
8379 if (value_is_int_like)
8382 assert((i + 2) < m_buf.size());
8384 assert(m_buf[i] ==
'\0');
8385 assert(m_buf[i - 1] !=
'\0');
8392 assert(m_buf[i + 2] ==
'\0');
8415 void dump(std::ostream& o,
8416 const bool pretty_print,
8417 const unsigned int indent_step,
8418 const unsigned int current_indent = 0)
const 8421 unsigned int new_indent = current_indent;
8425 case value_t::object:
8427 if (m_value.object->empty())
8438 new_indent += indent_step;
8442 for (
auto i = m_value.object->cbegin(); i != m_value.object->cend(); ++i)
8444 if (i != m_value.object->cbegin())
8446 o << (pretty_print ?
",\n" :
",");
8448 o <<
string_t(new_indent,
' ') <<
"\"" 8449 << escape_string(i->first) <<
"\":" 8450 << (pretty_print ?
" " :
"");
8451 i->second.dump(o, pretty_print, indent_step, new_indent);
8457 new_indent -= indent_step;
8461 o <<
string_t(new_indent,
' ') +
"}";
8465 case value_t::array:
8467 if (m_value.array->empty())
8478 new_indent += indent_step;
8482 for (
auto i = m_value.array->cbegin(); i != m_value.array->cend(); ++i)
8484 if (i != m_value.array->cbegin())
8486 o << (pretty_print ?
",\n" :
",");
8489 i->dump(o, pretty_print, indent_step, new_indent);
8495 new_indent -= indent_step;
8499 o <<
string_t(new_indent,
' ') <<
"]";
8503 case value_t::string:
8505 o <<
string_t(
"\"") << escape_string(*m_value.string) <<
"\"";
8509 case value_t::boolean:
8511 o << (m_value.boolean ?
"true" :
"false");
8515 case value_t::number_integer:
8517 o << numtostr(m_value.number_integer).c_str();
8521 case value_t::number_unsigned:
8523 o << numtostr(m_value.number_unsigned).c_str();
8527 case value_t::number_float:
8529 o << numtostr(m_value.number_float).c_str();
8533 case value_t::discarded:
8553 value_t m_type = value_t::null;
8556 json_value m_value = {};
8573 class primitive_iterator_t
8582 void set_begin() noexcept
8588 void set_end() noexcept
8594 constexpr
bool is_begin()
const noexcept
8596 return (m_it == begin_value);
8600 constexpr
bool is_end()
const noexcept
8602 return (m_it == end_value);
8605 friend constexpr
bool operator==(primitive_iterator_t lhs, primitive_iterator_t rhs) noexcept
8607 return lhs.m_it == rhs.m_it;
8610 friend constexpr
bool operator!=(primitive_iterator_t lhs, primitive_iterator_t rhs) noexcept
8612 return !(lhs == rhs);
8615 friend constexpr
bool operator<(primitive_iterator_t lhs, primitive_iterator_t rhs) noexcept
8617 return lhs.m_it < rhs.m_it;
8620 friend constexpr
bool operator<=(primitive_iterator_t lhs, primitive_iterator_t rhs) noexcept
8622 return lhs.m_it <= rhs.m_it;
8625 friend constexpr
bool operator>(primitive_iterator_t lhs, primitive_iterator_t rhs) noexcept
8627 return lhs.m_it > rhs.m_it;
8630 friend constexpr
bool operator>=(primitive_iterator_t lhs, primitive_iterator_t rhs) noexcept
8632 return lhs.m_it >= rhs.m_it;
8637 auto result = *
this;
8642 friend constexpr
difference_type operator-(primitive_iterator_t lhs, primitive_iterator_t rhs) noexcept
8644 return lhs.m_it - rhs.m_it;
8647 friend std::ostream& operator<<(std::ostream& os, primitive_iterator_t it)
8649 return os << it.m_it;
8652 primitive_iterator_t& operator++()
8658 primitive_iterator_t operator++(
int)
8660 auto result = *
this;
8665 primitive_iterator_t& operator--()
8671 primitive_iterator_t operator--(
int)
8673 auto result = *
this;
8695 difference_type m_it = std::numeric_limits<std::ptrdiff_t>::denorm_min();
8705 struct internal_iterator
8708 typename object_t::iterator object_iterator;
8710 typename array_t::iterator array_iterator;
8712 primitive_iterator_t primitive_iterator;
8715 internal_iterator() noexcept
8716 : object_iterator(), array_iterator(), primitive_iterator()
8721 template<
typename IteratorType>
8722 class iteration_proxy
8726 class iteration_proxy_internal
8730 IteratorType anchor;
8732 size_t array_index = 0;
8735 explicit iteration_proxy_internal(IteratorType it) noexcept
8740 iteration_proxy_internal& operator*()
8746 iteration_proxy_internal& operator++()
8755 bool operator!= (
const iteration_proxy_internal& o)
const 8757 return anchor != o.anchor;
8763 assert(anchor.m_object !=
nullptr);
8765 switch (anchor.m_object->type())
8768 case value_t::array:
8770 return std::to_string(array_index);
8774 case value_t::object:
8776 return anchor.key();
8788 typename IteratorType::reference value()
const 8790 return anchor.value();
8795 typename IteratorType::reference container;
8799 explicit iteration_proxy(
typename IteratorType::reference cont)
8804 iteration_proxy_internal begin() noexcept
8806 return iteration_proxy_internal(container.begin());
8810 iteration_proxy_internal end() noexcept
8812 return iteration_proxy_internal(container.end());
8836 template<
typename U>
8837 class iter_impl :
public std::iterator<std::random_access_iterator_tag, U>
8843 static_assert(std::is_same<U, basic_json>::value
8844 or std::is_same<U, const basic_json>::value,
8845 "iter_impl only accepts (const) basic_json");
8853 using pointer =
typename std::conditional<std::is_const<U>::value,
8857 using reference =
typename std::conditional<std::is_const<U>::value,
8875 assert(m_object !=
nullptr);
8877 switch (m_object->m_type)
8879 case basic_json::value_t::object:
8881 m_it.object_iterator =
typename object_t::iterator();
8885 case basic_json::value_t::array:
8887 m_it.array_iterator =
typename array_t::iterator();
8893 m_it.primitive_iterator = primitive_iterator_t();
8913 ret.m_object = m_object;
8926 : m_object(other.m_object), m_it(other.m_it)
8935 std::is_nothrow_move_constructible<pointer>::value and
8936 std::is_nothrow_move_assignable<pointer>::value and
8937 std::is_nothrow_move_constructible<internal_iterator>::value and
8938 std::is_nothrow_move_assignable<internal_iterator>::value
8941 std::swap(m_object, other.m_object);
8942 std::swap(m_it, other.m_it);
8951 void set_begin() noexcept
8953 assert(m_object !=
nullptr);
8955 switch (m_object->m_type)
8957 case basic_json::value_t::object:
8959 m_it.object_iterator = m_object->m_value.object->begin();
8963 case basic_json::value_t::array:
8965 m_it.array_iterator = m_object->m_value.array->begin();
8969 case basic_json::value_t::null:
8972 m_it.primitive_iterator.set_end();
8978 m_it.primitive_iterator.set_begin();
8988 void set_end() noexcept
8990 assert(m_object !=
nullptr);
8992 switch (m_object->m_type)
8994 case basic_json::value_t::object:
8996 m_it.object_iterator = m_object->m_value.object->end();
9000 case basic_json::value_t::array:
9002 m_it.array_iterator = m_object->m_value.array->end();
9008 m_it.primitive_iterator.set_end();
9021 assert(m_object !=
nullptr);
9023 switch (m_object->m_type)
9025 case basic_json::value_t::object:
9027 assert(m_it.object_iterator != m_object->m_value.object->end());
9028 return m_it.object_iterator->second;
9031 case basic_json::value_t::array:
9033 assert(m_it.array_iterator != m_object->m_value.array->end());
9034 return *m_it.array_iterator;
9037 case basic_json::value_t::null:
9039 JSON_THROW(std::out_of_range(
"cannot get value"));
9044 if (m_it.primitive_iterator.is_begin())
9049 JSON_THROW(std::out_of_range(
"cannot get value"));
9060 assert(m_object !=
nullptr);
9062 switch (m_object->m_type)
9064 case basic_json::value_t::object:
9066 assert(m_it.object_iterator != m_object->m_value.object->end());
9067 return &(m_it.object_iterator->second);
9070 case basic_json::value_t::array:
9072 assert(m_it.array_iterator != m_object->m_value.array->end());
9073 return &*m_it.array_iterator;
9078 if (m_it.primitive_iterator.is_begin())
9083 JSON_THROW(std::out_of_range(
"cannot get value"));
9094 auto result = *
this;
9105 assert(m_object !=
nullptr);
9107 switch (m_object->m_type)
9109 case basic_json::value_t::object:
9111 std::advance(m_it.object_iterator, 1);
9115 case basic_json::value_t::array:
9117 std::advance(m_it.array_iterator, 1);
9123 ++m_it.primitive_iterator;
9137 auto result = *
this;
9148 assert(m_object !=
nullptr);
9150 switch (m_object->m_type)
9152 case basic_json::value_t::object:
9154 std::advance(m_it.object_iterator, -1);
9158 case basic_json::value_t::array:
9160 std::advance(m_it.array_iterator, -1);
9166 --m_it.primitive_iterator;
9181 if (m_object != other.m_object)
9183 JSON_THROW(std::domain_error(
"cannot compare iterators of different containers"));
9186 assert(m_object !=
nullptr);
9188 switch (m_object->m_type)
9190 case basic_json::value_t::object:
9192 return (m_it.object_iterator == other.m_it.object_iterator);
9195 case basic_json::value_t::array:
9197 return (m_it.array_iterator == other.m_it.array_iterator);
9202 return (m_it.primitive_iterator == other.m_it.primitive_iterator);
9213 return not operator==(other);
9223 if (m_object != other.m_object)
9225 JSON_THROW(std::domain_error(
"cannot compare iterators of different containers"));
9228 assert(m_object !=
nullptr);
9230 switch (m_object->m_type)
9232 case basic_json::value_t::object:
9234 JSON_THROW(std::domain_error(
"cannot compare order of object iterators"));
9237 case basic_json::value_t::array:
9239 return (m_it.array_iterator < other.m_it.array_iterator);
9244 return (m_it.primitive_iterator < other.m_it.primitive_iterator);
9255 return not other.operator < (*this);
9264 return not operator<=(other);
9273 return not operator<(other);
9282 assert(m_object !=
nullptr);
9284 switch (m_object->m_type)
9286 case basic_json::value_t::object:
9288 JSON_THROW(std::domain_error(
"cannot use offsets with object iterators"));
9291 case basic_json::value_t::array:
9293 std::advance(m_it.array_iterator, i);
9299 m_it.primitive_iterator += i;
9313 return operator+=(-i);
9322 auto result = *
this;
9333 auto result = *
this;
9344 assert(m_object !=
nullptr);
9346 switch (m_object->m_type)
9348 case basic_json::value_t::object:
9350 JSON_THROW(std::domain_error(
"cannot use offsets with object iterators"));
9353 case basic_json::value_t::array:
9355 return m_it.array_iterator - other.m_it.array_iterator;
9360 return m_it.primitive_iterator - other.m_it.primitive_iterator;
9371 assert(m_object !=
nullptr);
9373 switch (m_object->m_type)
9375 case basic_json::value_t::object:
9377 JSON_THROW(std::domain_error(
"cannot use operator[] for object iterators"));
9380 case basic_json::value_t::array:
9382 return *std::next(m_it.array_iterator, n);
9385 case basic_json::value_t::null:
9387 JSON_THROW(std::out_of_range(
"cannot get value"));
9392 if (m_it.primitive_iterator.get_value() == -n)
9397 JSON_THROW(std::out_of_range(
"cannot get value"));
9406 typename object_t::key_type
key()
const 9408 assert(m_object !=
nullptr);
9410 if (m_object->is_object())
9412 return m_it.object_iterator->first;
9415 JSON_THROW(std::domain_error(
"cannot use key() for non-object iterators"));
9431 internal_iterator m_it = internal_iterator();
9451 template<
typename Base>
9473 return base_iterator::operator++(1);
9479 base_iterator::operator++();
9486 return base_iterator::operator--(1);
9492 base_iterator::operator--();
9499 base_iterator::operator+=(i);
9506 auto result = *
this;
9514 auto result = *
this;
9522 return this->base() - other.base();
9528 return *(this->operator+(n));
9532 typename object_t::key_type
key()
const 9534 auto it = --this->base();
9541 auto it = --this->base();
9542 return it.operator * ();
9563 enum class token_type
9584 using lexer_char_t =
unsigned char;
9587 lexer(
const lexer_char_t* buff,
const size_t len) noexcept
9590 assert(m_content !=
nullptr);
9591 m_start = m_cursor = m_content;
9592 m_limit = m_content + len;
9596 explicit lexer(std::istream& s)
9597 : m_stream(&s), m_line_buffer()
9602 JSON_THROW(std::invalid_argument(
"stream error"));
9609 if (m_line_buffer.size() >= 3 and m_line_buffer.substr(0, 3) ==
"\xEF\xBB\xBF")
9611 m_line_buffer[0] =
' ';
9612 m_line_buffer[1] =
' ';
9613 m_line_buffer[2] =
' ';
9619 lexer(
const lexer&) =
delete;
9620 lexer operator=(
const lexer&) =
delete;
9645 static string_t to_unicode(
const std::size_t codepoint1,
9646 const std::size_t codepoint2 = 0)
9649 std::size_t codepoint = codepoint1;
9652 if (codepoint1 >= 0xD800 and codepoint1 <= 0xDBFF)
9655 if (codepoint2 >= 0xDC00 and codepoint2 <= 0xDFFF)
9669 JSON_THROW(std::invalid_argument(
"missing or wrong low surrogate"));
9675 if (codepoint < 0x80)
9678 result.append(1, static_cast<typename string_t::value_type>(codepoint));
9680 else if (codepoint <= 0x7ff)
9683 result.append(1, static_cast<typename string_t::value_type>(0xC0 | ((codepoint >> 6) & 0x1F)));
9684 result.append(1, static_cast<typename string_t::value_type>(0x80 | (codepoint & 0x3F)));
9686 else if (codepoint <= 0xffff)
9689 result.append(1, static_cast<typename string_t::value_type>(0xE0 | ((codepoint >> 12) & 0x0F)));
9690 result.append(1, static_cast<typename string_t::value_type>(0x80 | ((codepoint >> 6) & 0x3F)));
9691 result.append(1, static_cast<typename string_t::value_type>(0x80 | (codepoint & 0x3F)));
9693 else if (codepoint <= 0x10ffff)
9696 result.append(1, static_cast<typename string_t::value_type>(0xF0 | ((codepoint >> 18) & 0x07)));
9697 result.append(1, static_cast<typename string_t::value_type>(0x80 | ((codepoint >> 12) & 0x3F)));
9698 result.append(1, static_cast<typename string_t::value_type>(0x80 | ((codepoint >> 6) & 0x3F)));
9699 result.append(1, static_cast<typename string_t::value_type>(0x80 | (codepoint & 0x3F)));
9703 JSON_THROW(std::out_of_range(
"code points above 0x10FFFF are invalid"));
9710 static std::string token_type_name(
const token_type t)
9714 case token_type::uninitialized:
9715 return "<uninitialized>";
9716 case token_type::literal_true:
9717 return "true literal";
9718 case token_type::literal_false:
9719 return "false literal";
9720 case token_type::literal_null:
9721 return "null literal";
9722 case token_type::value_string:
9723 return "string literal";
9724 case lexer::token_type::value_unsigned:
9725 case lexer::token_type::value_integer:
9726 case lexer::token_type::value_float:
9727 return "number literal";
9728 case token_type::begin_array:
9730 case token_type::begin_object:
9732 case token_type::end_array:
9734 case token_type::end_object:
9736 case token_type::name_separator:
9738 case token_type::value_separator:
9740 case token_type::parse_error:
9741 return "<parse error>";
9742 case token_type::end_of_input:
9743 return "end of input";
9747 return "unknown token";
9782 assert(m_start !=
nullptr);
9787 unsigned int yyaccept = 0;
9788 static const unsigned char yybm[] = {
9789 0, 0, 0, 0, 0, 0, 0, 0,
9790 0, 32, 32, 0, 0, 32, 0, 0,
9791 0, 0, 0, 0, 0, 0, 0, 0,
9792 0, 0, 0, 0, 0, 0, 0, 0,
9793 160, 128, 0, 128, 128, 128, 128, 128,
9794 128, 128, 128, 128, 128, 128, 128, 128,
9795 192, 192, 192, 192, 192, 192, 192, 192,
9796 192, 192, 128, 128, 128, 128, 128, 128,
9797 128, 128, 128, 128, 128, 128, 128, 128,
9798 128, 128, 128, 128, 128, 128, 128, 128,
9799 128, 128, 128, 128, 128, 128, 128, 128,
9800 128, 128, 128, 128, 0, 128, 128, 128,
9801 128, 128, 128, 128, 128, 128, 128, 128,
9802 128, 128, 128, 128, 128, 128, 128, 128,
9803 128, 128, 128, 128, 128, 128, 128, 128,
9804 128, 128, 128, 128, 128, 128, 128, 128,
9805 0, 0, 0, 0, 0, 0, 0, 0,
9806 0, 0, 0, 0, 0, 0, 0, 0,
9807 0, 0, 0, 0, 0, 0, 0, 0,
9808 0, 0, 0, 0, 0, 0, 0, 0,
9809 0, 0, 0, 0, 0, 0, 0, 0,
9810 0, 0, 0, 0, 0, 0, 0, 0,
9811 0, 0, 0, 0, 0, 0, 0, 0,
9812 0, 0, 0, 0, 0, 0, 0, 0,
9813 0, 0, 0, 0, 0, 0, 0, 0,
9814 0, 0, 0, 0, 0, 0, 0, 0,
9815 0, 0, 0, 0, 0, 0, 0, 0,
9816 0, 0, 0, 0, 0, 0, 0, 0,
9817 0, 0, 0, 0, 0, 0, 0, 0,
9818 0, 0, 0, 0, 0, 0, 0, 0,
9819 0, 0, 0, 0, 0, 0, 0, 0,
9820 0, 0, 0, 0, 0, 0, 0, 0,
9822 if ((m_limit - m_cursor) < 5) fill_line_buffer(5);
9824 if (yybm[0+yych] & 32) {
9825 goto basic_json_parser_6;
9830 if (yych <= 0x00)
goto basic_json_parser_2;
9831 if (yych <=
'!')
goto basic_json_parser_4;
9832 goto basic_json_parser_9;
9834 if (yych <=
'+')
goto basic_json_parser_4;
9835 if (yych <=
',')
goto basic_json_parser_10;
9836 goto basic_json_parser_12;
9840 if (yych <=
'/')
goto basic_json_parser_4;
9841 if (yych <=
'0')
goto basic_json_parser_13;
9842 goto basic_json_parser_15;
9844 if (yych <=
':')
goto basic_json_parser_17;
9845 if (yych <=
'Z')
goto basic_json_parser_4;
9846 goto basic_json_parser_19;
9852 if (yych ==
']')
goto basic_json_parser_21;
9853 goto basic_json_parser_4;
9855 if (yych <=
'f')
goto basic_json_parser_23;
9856 if (yych <=
'm')
goto basic_json_parser_4;
9857 goto basic_json_parser_24;
9861 if (yych ==
't')
goto basic_json_parser_25;
9862 goto basic_json_parser_4;
9864 if (yych <=
'{')
goto basic_json_parser_26;
9865 if (yych ==
'}')
goto basic_json_parser_28;
9866 goto basic_json_parser_4;
9870 basic_json_parser_2:
9872 { last_token_type = token_type::end_of_input;
break; }
9873 basic_json_parser_4:
9875 basic_json_parser_5:
9876 { last_token_type = token_type::parse_error;
break; }
9877 basic_json_parser_6:
9879 if (m_limit <= m_cursor) fill_line_buffer(1);
9881 if (yybm[0+yych] & 32) {
9882 goto basic_json_parser_6;
9885 basic_json_parser_9:
9887 yych = *(m_marker = ++m_cursor);
9888 if (yych <= 0x1F)
goto basic_json_parser_5;
9889 if (yych <= 0x7F)
goto basic_json_parser_31;
9890 if (yych <= 0xC1)
goto basic_json_parser_5;
9891 if (yych <= 0xF4)
goto basic_json_parser_31;
9892 goto basic_json_parser_5;
9893 basic_json_parser_10:
9895 { last_token_type = token_type::value_separator;
break; }
9896 basic_json_parser_12:
9898 if (yych <=
'/')
goto basic_json_parser_5;
9899 if (yych <=
'0')
goto basic_json_parser_43;
9900 if (yych <=
'9')
goto basic_json_parser_45;
9901 goto basic_json_parser_5;
9902 basic_json_parser_13:
9904 yych = *(m_marker = ++m_cursor);
9906 if (yych ==
'.')
goto basic_json_parser_47;
9907 if (yych >=
'0')
goto basic_json_parser_48;
9910 if (yych >=
'E')
goto basic_json_parser_51;
9912 if (yych ==
'e')
goto basic_json_parser_51;
9915 basic_json_parser_14:
9916 { last_token_type = token_type::value_unsigned;
break; }
9917 basic_json_parser_15:
9919 m_marker = ++m_cursor;
9920 if ((m_limit - m_cursor) < 3) fill_line_buffer(3);
9922 if (yybm[0+yych] & 64) {
9923 goto basic_json_parser_15;
9926 if (yych ==
'.')
goto basic_json_parser_47;
9927 goto basic_json_parser_14;
9929 if (yych <=
'E')
goto basic_json_parser_51;
9930 if (yych ==
'e')
goto basic_json_parser_51;
9931 goto basic_json_parser_14;
9933 basic_json_parser_17:
9935 { last_token_type = token_type::name_separator;
break; }
9936 basic_json_parser_19:
9938 { last_token_type = token_type::begin_array;
break; }
9939 basic_json_parser_21:
9941 { last_token_type = token_type::end_array;
break; }
9942 basic_json_parser_23:
9944 yych = *(m_marker = ++m_cursor);
9945 if (yych ==
'a')
goto basic_json_parser_52;
9946 goto basic_json_parser_5;
9947 basic_json_parser_24:
9949 yych = *(m_marker = ++m_cursor);
9950 if (yych ==
'u')
goto basic_json_parser_53;
9951 goto basic_json_parser_5;
9952 basic_json_parser_25:
9954 yych = *(m_marker = ++m_cursor);
9955 if (yych ==
'r')
goto basic_json_parser_54;
9956 goto basic_json_parser_5;
9957 basic_json_parser_26:
9959 { last_token_type = token_type::begin_object;
break; }
9960 basic_json_parser_28:
9962 { last_token_type = token_type::end_object;
break; }
9963 basic_json_parser_30:
9965 if (m_limit <= m_cursor) fill_line_buffer(1);
9967 basic_json_parser_31:
9968 if (yybm[0+yych] & 128) {
9969 goto basic_json_parser_30;
9973 if (yych <= 0x1F)
goto basic_json_parser_32;
9974 if (yych <=
'"')
goto basic_json_parser_33;
9975 goto basic_json_parser_35;
9977 if (yych <= 0xC1)
goto basic_json_parser_32;
9978 if (yych <= 0xDF)
goto basic_json_parser_36;
9979 goto basic_json_parser_37;
9983 if (yych == 0xED)
goto basic_json_parser_39;
9984 goto basic_json_parser_38;
9986 if (yych <= 0xF0)
goto basic_json_parser_40;
9987 if (yych <= 0xF3)
goto basic_json_parser_41;
9988 if (yych <= 0xF4)
goto basic_json_parser_42;
9991 basic_json_parser_32:
9992 m_cursor = m_marker;
9993 if (yyaccept <= 1) {
9994 if (yyaccept == 0) {
9995 goto basic_json_parser_5;
9997 goto basic_json_parser_14;
10000 if (yyaccept == 2) {
10001 goto basic_json_parser_44;
10003 goto basic_json_parser_58;
10006 basic_json_parser_33:
10008 { last_token_type = token_type::value_string;
break; }
10009 basic_json_parser_35:
10011 if (m_limit <= m_cursor) fill_line_buffer(1);
10015 if (yych ==
'"')
goto basic_json_parser_30;
10016 if (yych <=
'.')
goto basic_json_parser_32;
10017 goto basic_json_parser_30;
10019 if (yych <=
'\\') {
10020 if (yych <=
'[')
goto basic_json_parser_32;
10021 goto basic_json_parser_30;
10023 if (yych ==
'b')
goto basic_json_parser_30;
10024 goto basic_json_parser_32;
10029 if (yych <=
'f')
goto basic_json_parser_30;
10030 if (yych ==
'n')
goto basic_json_parser_30;
10031 goto basic_json_parser_32;
10034 if (yych <=
'r')
goto basic_json_parser_30;
10035 goto basic_json_parser_32;
10037 if (yych <=
't')
goto basic_json_parser_30;
10038 if (yych <=
'u')
goto basic_json_parser_55;
10039 goto basic_json_parser_32;
10043 basic_json_parser_36:
10045 if (m_limit <= m_cursor) fill_line_buffer(1);
10047 if (yych <= 0x7F)
goto basic_json_parser_32;
10048 if (yych <= 0xBF)
goto basic_json_parser_30;
10049 goto basic_json_parser_32;
10050 basic_json_parser_37:
10052 if (m_limit <= m_cursor) fill_line_buffer(1);
10054 if (yych <= 0x9F)
goto basic_json_parser_32;
10055 if (yych <= 0xBF)
goto basic_json_parser_36;
10056 goto basic_json_parser_32;
10057 basic_json_parser_38:
10059 if (m_limit <= m_cursor) fill_line_buffer(1);
10061 if (yych <= 0x7F)
goto basic_json_parser_32;
10062 if (yych <= 0xBF)
goto basic_json_parser_36;
10063 goto basic_json_parser_32;
10064 basic_json_parser_39:
10066 if (m_limit <= m_cursor) fill_line_buffer(1);
10068 if (yych <= 0x7F)
goto basic_json_parser_32;
10069 if (yych <= 0x9F)
goto basic_json_parser_36;
10070 goto basic_json_parser_32;
10071 basic_json_parser_40:
10073 if (m_limit <= m_cursor) fill_line_buffer(1);
10075 if (yych <= 0x8F)
goto basic_json_parser_32;
10076 if (yych <= 0xBF)
goto basic_json_parser_38;
10077 goto basic_json_parser_32;
10078 basic_json_parser_41:
10080 if (m_limit <= m_cursor) fill_line_buffer(1);
10082 if (yych <= 0x7F)
goto basic_json_parser_32;
10083 if (yych <= 0xBF)
goto basic_json_parser_38;
10084 goto basic_json_parser_32;
10085 basic_json_parser_42:
10087 if (m_limit <= m_cursor) fill_line_buffer(1);
10089 if (yych <= 0x7F)
goto basic_json_parser_32;
10090 if (yych <= 0x8F)
goto basic_json_parser_38;
10091 goto basic_json_parser_32;
10092 basic_json_parser_43:
10094 yych = *(m_marker = ++m_cursor);
10096 if (yych ==
'.')
goto basic_json_parser_47;
10097 if (yych >=
'0')
goto basic_json_parser_48;
10100 if (yych >=
'E')
goto basic_json_parser_51;
10102 if (yych ==
'e')
goto basic_json_parser_51;
10105 basic_json_parser_44:
10106 { last_token_type = token_type::value_integer;
break; }
10107 basic_json_parser_45:
10109 m_marker = ++m_cursor;
10110 if ((m_limit - m_cursor) < 3) fill_line_buffer(3);
10113 if (yych ==
'.')
goto basic_json_parser_47;
10114 if (yych <=
'/')
goto basic_json_parser_44;
10115 goto basic_json_parser_45;
10118 if (yych <=
'D')
goto basic_json_parser_44;
10119 goto basic_json_parser_51;
10121 if (yych ==
'e')
goto basic_json_parser_51;
10122 goto basic_json_parser_44;
10125 basic_json_parser_47:
10126 yych = *++m_cursor;
10127 if (yych <=
'/')
goto basic_json_parser_32;
10128 if (yych <=
'9')
goto basic_json_parser_56;
10129 goto basic_json_parser_32;
10130 basic_json_parser_48:
10132 if (m_limit <= m_cursor) fill_line_buffer(1);
10134 if (yych <=
'/')
goto basic_json_parser_50;
10135 if (yych <=
'9')
goto basic_json_parser_48;
10136 basic_json_parser_50:
10137 { last_token_type = token_type::parse_error;
break; }
10138 basic_json_parser_51:
10139 yych = *++m_cursor;
10141 if (yych ==
'+')
goto basic_json_parser_59;
10142 goto basic_json_parser_32;
10144 if (yych <=
'-')
goto basic_json_parser_59;
10145 if (yych <=
'/')
goto basic_json_parser_32;
10146 if (yych <=
'9')
goto basic_json_parser_60;
10147 goto basic_json_parser_32;
10149 basic_json_parser_52:
10150 yych = *++m_cursor;
10151 if (yych ==
'l')
goto basic_json_parser_62;
10152 goto basic_json_parser_32;
10153 basic_json_parser_53:
10154 yych = *++m_cursor;
10155 if (yych ==
'l')
goto basic_json_parser_63;
10156 goto basic_json_parser_32;
10157 basic_json_parser_54:
10158 yych = *++m_cursor;
10159 if (yych ==
'u')
goto basic_json_parser_64;
10160 goto basic_json_parser_32;
10161 basic_json_parser_55:
10163 if (m_limit <= m_cursor) fill_line_buffer(1);
10166 if (yych <=
'/')
goto basic_json_parser_32;
10167 if (yych <=
'9')
goto basic_json_parser_65;
10168 goto basic_json_parser_32;
10170 if (yych <=
'F')
goto basic_json_parser_65;
10171 if (yych <=
'`')
goto basic_json_parser_32;
10172 if (yych <=
'f')
goto basic_json_parser_65;
10173 goto basic_json_parser_32;
10175 basic_json_parser_56:
10177 m_marker = ++m_cursor;
10178 if ((m_limit - m_cursor) < 3) fill_line_buffer(3);
10181 if (yych <=
'/')
goto basic_json_parser_58;
10182 if (yych <=
'9')
goto basic_json_parser_56;
10184 if (yych <=
'E')
goto basic_json_parser_51;
10185 if (yych ==
'e')
goto basic_json_parser_51;
10187 basic_json_parser_58:
10188 { last_token_type = token_type::value_float;
break; }
10189 basic_json_parser_59:
10190 yych = *++m_cursor;
10191 if (yych <=
'/')
goto basic_json_parser_32;
10192 if (yych >=
':')
goto basic_json_parser_32;
10193 basic_json_parser_60:
10195 if (m_limit <= m_cursor) fill_line_buffer(1);
10197 if (yych <=
'/')
goto basic_json_parser_58;
10198 if (yych <=
'9')
goto basic_json_parser_60;
10199 goto basic_json_parser_58;
10200 basic_json_parser_62:
10201 yych = *++m_cursor;
10202 if (yych ==
's')
goto basic_json_parser_66;
10203 goto basic_json_parser_32;
10204 basic_json_parser_63:
10205 yych = *++m_cursor;
10206 if (yych ==
'l')
goto basic_json_parser_67;
10207 goto basic_json_parser_32;
10208 basic_json_parser_64:
10209 yych = *++m_cursor;
10210 if (yych ==
'e')
goto basic_json_parser_69;
10211 goto basic_json_parser_32;
10212 basic_json_parser_65:
10214 if (m_limit <= m_cursor) fill_line_buffer(1);
10217 if (yych <=
'/')
goto basic_json_parser_32;
10218 if (yych <=
'9')
goto basic_json_parser_71;
10219 goto basic_json_parser_32;
10221 if (yych <=
'F')
goto basic_json_parser_71;
10222 if (yych <=
'`')
goto basic_json_parser_32;
10223 if (yych <=
'f')
goto basic_json_parser_71;
10224 goto basic_json_parser_32;
10226 basic_json_parser_66:
10227 yych = *++m_cursor;
10228 if (yych ==
'e')
goto basic_json_parser_72;
10229 goto basic_json_parser_32;
10230 basic_json_parser_67:
10232 { last_token_type = token_type::literal_null;
break; }
10233 basic_json_parser_69:
10235 { last_token_type = token_type::literal_true;
break; }
10236 basic_json_parser_71:
10238 if (m_limit <= m_cursor) fill_line_buffer(1);
10241 if (yych <=
'/')
goto basic_json_parser_32;
10242 if (yych <=
'9')
goto basic_json_parser_74;
10243 goto basic_json_parser_32;
10245 if (yych <=
'F')
goto basic_json_parser_74;
10246 if (yych <=
'`')
goto basic_json_parser_32;
10247 if (yych <=
'f')
goto basic_json_parser_74;
10248 goto basic_json_parser_32;
10250 basic_json_parser_72:
10252 { last_token_type = token_type::literal_false;
break; }
10253 basic_json_parser_74:
10255 if (m_limit <= m_cursor) fill_line_buffer(1);
10258 if (yych <=
'/')
goto basic_json_parser_32;
10259 if (yych <=
'9')
goto basic_json_parser_30;
10260 goto basic_json_parser_32;
10262 if (yych <=
'F')
goto basic_json_parser_30;
10263 if (yych <=
'`')
goto basic_json_parser_32;
10264 if (yych <=
'f')
goto basic_json_parser_30;
10265 goto basic_json_parser_32;
10271 return last_token_type;
10302 void fill_line_buffer(
size_t n = 0)
10305 assert(m_line_buffer.empty()
10306 or m_content ==
reinterpret_cast<const lexer_char_t*
>(m_line_buffer.data()));
10309 assert(m_line_buffer.empty()
10310 or m_limit == m_content + m_line_buffer.size());
10313 assert(m_content <= m_start);
10314 assert(m_start <= m_cursor);
10315 assert(m_cursor <= m_limit);
10316 assert(m_marker ==
nullptr or m_marker <= m_limit);
10319 const auto num_processed_chars =
static_cast<size_t>(m_start - m_content);
10321 const auto offset_marker = (m_marker ==
nullptr) ? 0 : m_marker - m_start;
10323 const auto offset_cursor = m_cursor - m_start;
10326 if (m_stream ==
nullptr or m_stream->eof())
10331 m_line_buffer.assign(m_start, m_limit);
10335 m_line_buffer.append(1,
'\x00');
10338 m_line_buffer.append(n - 1,
'\x01');
10344 m_line_buffer.erase(0, num_processed_chars);
10346 m_line_buffer_tmp.clear();
10347 std::getline(*m_stream, m_line_buffer_tmp,
'\n');
10350 m_line_buffer += m_line_buffer_tmp;
10351 m_line_buffer.push_back(
'\n');
10355 m_content =
reinterpret_cast<const lexer_char_t*
>(m_line_buffer.data());
10356 assert(m_content !=
nullptr);
10357 m_start = m_content;
10358 m_marker = m_start + offset_marker;
10359 m_cursor = m_start + offset_cursor;
10360 m_limit = m_start + m_line_buffer.size();
10366 assert(m_start !=
nullptr);
10367 return string_t(reinterpret_cast<typename string_t::const_pointer>(m_start),
10368 static_cast<size_t>(m_cursor - m_start));
10430 assert(m_cursor - m_start >= 2);
10433 result.reserve(static_cast<size_t>(m_cursor - m_start - 2));
10436 for (
const lexer_char_t* i = m_start + 1; i < m_cursor - 1; ++i)
10439 auto e = std::find(i, m_cursor - 1,
'\\');
10443 for (
auto k = i; k < e; k++)
10445 result.push_back(static_cast<typename string_t::value_type>(*k));
10503 auto codepoint = std::strtoul(std::string(reinterpret_cast<typename string_t::const_pointer>(i + 1),
10504 4).c_str(),
nullptr, 16);
10507 if (codepoint >= 0xD800 and codepoint <= 0xDBFF)
10510 if ((i + 6 >= m_limit) or * (i + 5) !=
'\\' or * (i + 6) !=
'u')
10512 JSON_THROW(std::invalid_argument(
"missing low surrogate"));
10516 auto codepoint2 = std::strtoul(std::string(reinterpret_cast<typename string_t::const_pointer>
10517 (i + 7), 4).c_str(),
nullptr, 16);
10518 result += to_unicode(codepoint, codepoint2);
10522 else if (codepoint >= 0xDC00 and codepoint <= 0xDFFF)
10525 JSON_THROW(std::invalid_argument(
"missing high surrogate"));
10530 result += to_unicode(codepoint);
10557 : m_start(start), m_end(end)
10566 template<typename T, typename = typename std::enable_if<std::is_arithmetic<T>::value>::type>
10569 return parse(val, std::is_integral<T>());
10573 const char*
const m_start =
nullptr;
10574 const char*
const m_end =
nullptr;
10580 static void strtof(
float& f,
const char* str,
char** endptr)
10582 f = std::strtof(str, endptr);
10585 static void strtof(
double& f,
const char* str,
char** endptr)
10587 f = std::strtod(str, endptr);
10590 static void strtof(
long double& f,
const char* str,
char** endptr)
10592 f = std::strtold(str, endptr);
10595 template<
typename T>
10596 bool parse(T& value, std::false_type)
const 10601 std::string tempstr;
10602 std::array<char, 64> buf;
10603 const size_t len =
static_cast<size_t>(m_end - m_start);
10611 const auto loc = localeconv();
10612 assert(loc !=
nullptr);
10613 const char decimal_point_char = (loc->decimal_point ==
nullptr) ?
'.' : loc->decimal_point[0];
10615 const char* data = m_start;
10617 if (decimal_point_char !=
'.')
10619 const size_t ds_pos =
static_cast<size_t>(std::find(m_start, m_end,
'.') - m_start);
10626 if ((len + 1) < buf.size())
10628 std::copy(m_start, m_end, buf.begin());
10630 buf[ds_pos] = decimal_point_char;
10635 tempstr.assign(m_start, m_end);
10636 tempstr[ds_pos] = decimal_point_char;
10637 data = tempstr.c_str();
10642 char* endptr =
nullptr;
10645 strtof(value, data, &endptr);
10649 const bool ok = (endptr == (data + len));
10651 if (ok and (value == static_cast<T>(0.0)) and (*data ==
'-'))
10662 signed long long parse_integral(
char** endptr, std::true_type)
const 10664 return std::strtoll(m_start, endptr, 10);
10667 unsigned long long parse_integral(
char** endptr, std::false_type)
const 10669 return std::strtoull(m_start, endptr, 10);
10672 template<
typename T>
10673 bool parse(T& value, std::true_type)
const 10675 char* endptr =
nullptr;
10677 const auto x = parse_integral(&endptr, std::is_signed<T>());
10680 static_assert(std::is_signed<T>() == std::is_signed<decltype(x)>(),
"");
10682 value =
static_cast<T
>(x);
10684 return (x ==
static_cast<decltype(x)
>(value))
10685 and (x < 0) == (value < 0)
10688 and (m_start < m_end)
10689 and (endptr == m_end);
10712 bool get_number(
basic_json& result,
const token_type token)
const 10714 assert(m_start !=
nullptr);
10715 assert(m_start < m_cursor);
10716 assert((token == token_type::value_unsigned) or
10717 (token == token_type::value_integer) or
10718 (token == token_type::value_float));
10720 strtonum num_converter(reinterpret_cast<const char*>(m_start),
10721 reinterpret_cast<const char*>(m_cursor));
10725 case lexer::token_type::value_unsigned:
10728 if (num_converter.
to(val))
10731 result.m_type = value_t::number_unsigned;
10732 result.m_value = val;
10738 case lexer::token_type::value_integer:
10741 if (num_converter.
to(val))
10744 result.m_type = value_t::number_integer;
10745 result.m_value = val;
10760 if (num_converter.
to(val))
10763 result.m_type = value_t::number_float;
10764 result.m_value = val;
10767 if (not std::isfinite(result.m_value.number_float))
10769 result.m_type = value_t::null;
10770 result.m_value = basic_json::json_value();
10782 std::istream* m_stream =
nullptr;
10788 const lexer_char_t* m_content =
nullptr;
10790 const lexer_char_t* m_start =
nullptr;
10792 const lexer_char_t* m_marker =
nullptr;
10794 const lexer_char_t* m_cursor =
nullptr;
10796 const lexer_char_t* m_limit =
nullptr;
10798 token_type last_token_type = token_type::end_of_input;
10812 m_lexer(reinterpret_cast<const typename lexer::lexer_char_t*>(buff), std::strlen(buff))
10817 : callback(cb), m_lexer(is)
10821 template<
class IteratorType,
typename std::enable_if<
10822 std::is_same<typename std::iterator_traits<IteratorType>::iterator_category, std::random_access_iterator_tag>::value
10825 parser(IteratorType first, IteratorType last,
const parser_callback_t cb =
nullptr)
10827 m_lexer(reinterpret_cast<const typename lexer::lexer_char_t*>(&(*first)),
10828 static_cast<size_t>(std::distance(first, last)))
10838 result.assert_invariant();
10840 expect(lexer::token_type::end_of_input);
10851 auto result =
basic_json(value_t::discarded);
10853 switch (last_token)
10855 case lexer::token_type::begin_object:
10857 if (keep and (not callback
10858 or ((keep = callback(depth++, parse_event_t::object_start, result)) != 0)))
10861 result.m_type = value_t::object;
10862 result.m_value = value_t::object;
10869 if (last_token == lexer::token_type::end_object)
10872 if (keep and callback and not callback(--depth, parse_event_t::object_end, result))
10880 unexpect(lexer::token_type::value_separator);
10886 if (last_token == lexer::token_type::value_separator)
10892 expect(lexer::token_type::value_string);
10893 const auto key = m_lexer.get_string();
10895 bool keep_tag =
false;
10901 keep_tag = callback(depth, parse_event_t::key, k);
10911 expect(lexer::token_type::name_separator);
10915 auto value = parse_internal(keep);
10916 if (keep and keep_tag and not value.is_discarded())
10918 result[key] = std::move(value);
10921 while (last_token == lexer::token_type::value_separator);
10924 expect(lexer::token_type::end_object);
10926 if (keep and callback and not callback(--depth, parse_event_t::object_end, result))
10934 case lexer::token_type::begin_array:
10936 if (keep and (not callback
10937 or ((keep = callback(depth++, parse_event_t::array_start, result)) != 0)))
10940 result.m_type = value_t::array;
10941 result.m_value = value_t::array;
10948 if (last_token == lexer::token_type::end_array)
10951 if (callback and not callback(--depth, parse_event_t::array_end, result))
10959 unexpect(lexer::token_type::value_separator);
10965 if (last_token == lexer::token_type::value_separator)
10971 auto value = parse_internal(keep);
10972 if (keep and not value.is_discarded())
10974 result.push_back(std::move(value));
10977 while (last_token == lexer::token_type::value_separator);
10980 expect(lexer::token_type::end_array);
10982 if (keep and callback and not callback(--depth, parse_event_t::array_end, result))
10990 case lexer::token_type::literal_null:
10993 result.m_type = value_t::null;
10997 case lexer::token_type::value_string:
10999 const auto s = m_lexer.get_string();
11005 case lexer::token_type::literal_true:
11008 result.m_type = value_t::boolean;
11009 result.m_value =
true;
11013 case lexer::token_type::literal_false:
11016 result.m_type = value_t::boolean;
11017 result.m_value =
false;
11021 case lexer::token_type::value_unsigned:
11022 case lexer::token_type::value_integer:
11023 case lexer::token_type::value_float:
11025 m_lexer.get_number(result, last_token);
11033 unexpect(last_token);
11037 if (keep and callback and not callback(depth, parse_event_t::value, result))
11045 typename lexer::token_type get_token()
11047 last_token = m_lexer.scan();
11051 void expect(
typename lexer::token_type t)
const 11053 if (t != last_token)
11055 std::string error_msg =
"parse error - unexpected ";
11056 error_msg += (last_token == lexer::token_type::parse_error ? (
"'" + m_lexer.get_token_string() +
11058 lexer::token_type_name(last_token));
11059 error_msg +=
"; expected " + lexer::token_type_name(t);
11060 JSON_THROW(std::invalid_argument(error_msg));
11064 void unexpect(
typename lexer::token_type t)
const 11066 if (t == last_token)
11068 std::string error_msg =
"parse error - unexpected ";
11069 error_msg += (last_token == lexer::token_type::parse_error ? (
"'" + m_lexer.get_token_string() +
11071 lexer::token_type_name(last_token));
11072 JSON_THROW(std::invalid_argument(error_msg));
11082 typename lexer::token_type last_token = lexer::token_type::uninitialized;
11128 : reference_tokens(split(s))
11146 std::string to_string()
const noexcept
11148 return std::accumulate(reference_tokens.begin(),
11149 reference_tokens.end(), std::string{},
11150 [](
const std::string & a,
const std::string & b)
11152 return a +
"/" + escape(b);
11157 operator std::string()
const 11159 return to_string();
11164 std::string pop_back()
11168 JSON_THROW(std::domain_error(
"JSON pointer has no parent"));
11171 auto last = reference_tokens.back();
11172 reference_tokens.pop_back();
11177 bool is_root()
const 11179 return reference_tokens.empty();
11186 JSON_THROW(std::domain_error(
"JSON pointer has no parent"));
11190 result.reference_tokens = {reference_tokens[0]};
11205 for (
const auto& reference_token : reference_tokens)
11207 switch (result->m_type)
11209 case value_t::null:
11211 if (reference_token ==
"0")
11214 result = &result->operator[](0);
11219 result = &result->operator[](reference_token);
11224 case value_t::object:
11227 result = &result->operator[](reference_token);
11231 case value_t::array:
11234 result = &result->operator[](
static_cast<size_type>(std::stoi(reference_token)));
11247 JSON_THROW(std::domain_error(
"invalid value to unflatten"));
11276 for (
const auto& reference_token : reference_tokens)
11279 if (ptr->m_type == value_t::null)
11282 const bool nums = std::all_of(reference_token.begin(),
11283 reference_token.end(),
11286 return std::isdigit(x);
11291 if (nums or reference_token ==
"-")
11293 *ptr = value_t::array;
11297 *ptr = value_t::object;
11301 switch (ptr->m_type)
11303 case value_t::object:
11306 ptr = &ptr->operator[](reference_token);
11310 case value_t::array:
11313 if (reference_token.size() > 1 and reference_token[0] ==
'0')
11315 JSON_THROW(std::domain_error(
"array index must not begin with '0'"));
11318 if (reference_token ==
"-")
11321 ptr = &ptr->operator[](ptr->m_value.array->size());
11326 ptr = &ptr->operator[](
static_cast<size_type>(std::stoi(reference_token)));
11333 JSON_THROW(std::out_of_range(
"unresolved reference token '" + reference_token +
"'"));
11343 for (
const auto& reference_token : reference_tokens)
11345 switch (ptr->m_type)
11347 case value_t::object:
11350 ptr = &ptr->
at(reference_token);
11354 case value_t::array:
11356 if (reference_token ==
"-")
11359 JSON_THROW(std::out_of_range(
"array index '-' (" +
11360 std::to_string(ptr->m_value.array->size()) +
11361 ") is out of range"));
11365 if (reference_token.size() > 1 and reference_token[0] ==
'0')
11367 JSON_THROW(std::domain_error(
"array index must not begin with '0'"));
11371 ptr = &ptr->at(static_cast<size_type>(std::stoi(reference_token)));
11377 JSON_THROW(std::out_of_range(
"unresolved reference token '" + reference_token +
"'"));
11395 for (
const auto& reference_token : reference_tokens)
11397 switch (ptr->m_type)
11399 case value_t::object:
11402 ptr = &ptr->operator[](reference_token);
11406 case value_t::array:
11408 if (reference_token ==
"-")
11411 JSON_THROW(std::out_of_range(
"array index '-' (" +
11412 std::to_string(ptr->m_value.array->size()) +
11413 ") is out of range"));
11417 if (reference_token.size() > 1 and reference_token[0] ==
'0')
11419 JSON_THROW(std::domain_error(
"array index must not begin with '0'"));
11423 ptr = &ptr->operator[](
static_cast<size_type>(std::stoi(reference_token)));
11429 JSON_THROW(std::out_of_range(
"unresolved reference token '" + reference_token +
"'"));
11439 for (
const auto& reference_token : reference_tokens)
11441 switch (ptr->m_type)
11443 case value_t::object:
11446 ptr = &ptr->
at(reference_token);
11450 case value_t::array:
11452 if (reference_token ==
"-")
11455 JSON_THROW(std::out_of_range(
"array index '-' (" +
11456 std::to_string(ptr->m_value.array->size()) +
11457 ") is out of range"));
11461 if (reference_token.size() > 1 and reference_token[0] ==
'0')
11463 JSON_THROW(std::domain_error(
"array index must not begin with '0'"));
11467 ptr = &ptr->at(static_cast<size_type>(std::stoi(reference_token)));
11473 JSON_THROW(std::out_of_range(
"unresolved reference token '" + reference_token +
"'"));
11482 static std::vector<std::string> split(
const std::string& reference_string)
11484 std::vector<std::string> result;
11487 if (reference_string.empty())
11493 if (reference_string[0] !=
'/')
11495 JSON_THROW(std::domain_error(
"JSON pointer must be empty or begin with '/'"));
11503 size_t slash = reference_string.find_first_of(
'/', 1),
11512 slash = reference_string.find_first_of(
'/', start))
11516 auto reference_token = reference_string.substr(start, slash - start);
11519 for (
size_t pos = reference_token.find_first_of(
'~');
11520 pos != std::string::npos;
11521 pos = reference_token.find_first_of(
'~', pos + 1))
11523 assert(reference_token[pos] ==
'~');
11526 if (pos == reference_token.size() - 1 or
11527 (reference_token[pos + 1] !=
'0' and
11528 reference_token[pos + 1] !=
'1'))
11530 JSON_THROW(std::domain_error(
"escape error: '~' must be followed with '0' or '1'"));
11535 unescape(reference_token);
11536 result.push_back(reference_token);
11555 static void replace_substring(std::string& s,
11556 const std::string& f,
11557 const std::string& t)
11559 assert(not f.empty());
11562 size_t pos = s.find(f);
11563 pos != std::string::npos;
11564 s.replace(pos, f.size(), t),
11565 pos = s.find(f, pos + t.size())
11570 static std::string escape(std::string s)
11573 replace_substring(s,
"~",
"~0");
11574 replace_substring(s,
"/",
"~1");
11579 static void unescape(std::string& s)
11582 replace_substring(s,
"~1",
"/");
11584 replace_substring(s,
"~0",
"~");
11594 static void flatten(
const std::string& reference_string,
11598 switch (value.m_type)
11600 case value_t::array:
11602 if (value.m_value.array->empty())
11605 result[reference_string] =
nullptr;
11610 for (
size_t i = 0; i < value.m_value.array->size(); ++i)
11612 flatten(reference_string +
"/" + std::to_string(i),
11613 value.m_value.array->operator[](i), result);
11619 case value_t::object:
11621 if (value.m_value.object->empty())
11624 result[reference_string] =
nullptr;
11629 for (
const auto& element : *value.m_value.object)
11631 flatten(reference_string +
"/" + escape(element.first),
11632 element.second, result);
11641 result[reference_string] = value;
11656 JSON_THROW(std::domain_error(
"only objects can be unflattened"));
11662 for (
const auto& element : *value.m_value.object)
11664 if (not element.second.is_primitive())
11666 JSON_THROW(std::domain_error(
"values in object must be primitive"));
11674 json_pointer(element.first).get_and_create(result) = element.second;
11684 return lhs.reference_tokens == rhs.reference_tokens;
11690 return !(lhs == rhs);
11694 std::vector<std::string> reference_tokens {};
11739 return ptr.get_unchecked(
this);
11766 return ptr.get_unchecked(
this);
11791 return ptr.get_checked(
this);
11816 return ptr.get_checked(
this);
11844 json_pointer::flatten(
"", *
this, result);
11877 return json_pointer::unflatten(*
this);
11931 enum class patch_operations {add,
remove, replace, move, copy, test, invalid};
11933 const auto get_op = [](
const std::string op)
11937 return patch_operations::add;
11939 if (op ==
"remove")
11941 return patch_operations::remove;
11943 if (op ==
"replace")
11945 return patch_operations::replace;
11949 return patch_operations::move;
11953 return patch_operations::copy;
11957 return patch_operations::test;
11960 return patch_operations::invalid;
11975 if (top_pointer != ptr)
11977 result.
at(top_pointer);
11981 const auto last_path = ptr.pop_back();
11984 switch (parent.m_type)
11986 case value_t::null:
11987 case value_t::object:
11990 parent[last_path] = val;
11994 case value_t::array:
11996 if (last_path ==
"-")
12003 const auto idx = std::stoi(last_path);
12004 if (static_cast<size_type>(idx) > parent.
size())
12007 JSON_THROW(std::out_of_range(
"array index " + std::to_string(idx) +
" is out of range"));
12028 const auto operation_remove = [&result](
json_pointer & ptr)
12031 const auto last_path = ptr.pop_back();
12038 auto it = parent.
find(last_path);
12039 if (it != parent.
end())
12045 JSON_THROW(std::out_of_range(
"key '" + last_path +
"' not found"));
12051 parent.
erase(static_cast<size_type>(std::stoi(last_path)));
12059 JSON_THROW(std::invalid_argument(
"JSON patch must be an array of objects"));
12063 for (
const auto& val : json_patch)
12066 const auto get_value = [&val](
const std::string & op,
12067 const std::string & member,
12071 auto it = val.m_value.object->find(member);
12074 const auto error_msg = (op ==
"op") ?
"operation" :
"operation '" + op +
"'";
12077 if (it == val.m_value.object->end())
12079 JSON_THROW(std::invalid_argument(error_msg +
" must have member '" + member +
"'"));
12083 if (string_type and not it->second.is_string())
12085 JSON_THROW(std::invalid_argument(error_msg +
" must have string member '" + member +
"'"));
12093 if (not val.is_object())
12095 JSON_THROW(std::invalid_argument(
"JSON patch must be an array of objects"));
12099 const std::string op = get_value(
"op",
"op",
true);
12100 const std::string path = get_value(op,
"path",
true);
12103 switch (get_op(op))
12105 case patch_operations::add:
12107 operation_add(ptr, get_value(
"add",
"value",
false));
12111 case patch_operations::remove:
12113 operation_remove(ptr);
12117 case patch_operations::replace:
12120 result.
at(ptr) = get_value(
"replace",
"value",
false);
12124 case patch_operations::move:
12126 const std::string from_path = get_value(
"move",
"from",
true);
12136 operation_remove(from_ptr);
12137 operation_add(ptr, v);
12141 case patch_operations::copy:
12143 const std::string from_path = get_value(
"copy",
"from",
true);;
12147 result[ptr] = result.
at(from_ptr);
12151 case patch_operations::test:
12153 bool success =
false;
12158 success = (result.
at(ptr) == get_value(
"test",
"value",
false));
12160 JSON_CATCH (std::out_of_range&)
12168 JSON_THROW(std::domain_error(
"unsuccessful: " + val.dump()));
12174 case patch_operations::invalid:
12178 JSON_THROW(std::invalid_argument(
"operation value '" + op +
"' is invalid"));
12220 const std::string& path =
"")
12226 if (source == target)
12231 if (source.
type() != target.
type())
12243 switch (source.
type())
12245 case value_t::array:
12249 while (i < source.
size() and i < target.
size())
12252 auto temp_diff = diff(source[i], target[i], path +
"/" + std::to_string(i));
12253 result.insert(result.end(), temp_diff.begin(), temp_diff.end());
12262 while (i < source.
size())
12266 result.insert(result.begin() + end_index, object(
12269 {
"path", path +
"/" + std::to_string(i)}
12275 while (i < target.
size())
12280 {
"path", path +
"/" + std::to_string(i)},
12281 {
"value", target[i]}
12289 case value_t::object:
12292 for (
auto it = source.
begin(); it != source.
end(); ++it)
12295 const auto key = json_pointer::escape(it.key());
12297 if (target.
find(it.key()) != target.
end())
12300 auto temp_diff = diff(it.value(), target[it.key()], path +
"/" + key);
12301 result.insert(result.end(), temp_diff.begin(), temp_diff.end());
12306 result.push_back(
object(
12309 {
"path", path +
"/" + key}
12315 for (
auto it = target.
begin(); it != target.
end(); ++it)
12317 if (source.
find(it.key()) == source.
end())
12320 const auto key = json_pointer::escape(it.key());
12324 {
"path", path +
"/" + key},
12325 {
"value", it.value()}
12384 is_nothrow_move_constructible<nlohmann::json>::value and
12385 is_nothrow_move_assignable<nlohmann::json>::value
12403 const auto& h = hash<nlohmann::json::string_t>();
12422 inline nlohmann::json operator "" _json(
const char* s, std::size_t n)
12446 #if defined(__clang__) || defined(__GNUC__) || defined(__GNUG__) 12447 #pragma GCC diagnostic pop 12452 #undef JSON_DEPRECATED typename std::allocator_traits< allocator_type >::pointer pointer
the type of an element pointer
bool operator>=(const iter_impl &other) const
comparison: greater than or equal
difference_type operator-(const iter_impl &other) const
return difference
friend bool operator<=(const_reference lhs, const_reference rhs) noexcept
comparison: less than or equal
ValueType value(const json_pointer &ptr, ValueType default_value) const
access specified object element via JSON Pointer with default value
JSONSerializer< T, SFINAE > json_serializer
NumberFloatType number_float_t
a type for a number (floating-point)
BooleanType boolean_t
a type for a boolean
bool operator<=(const iter_impl &other) const
comparison: less than or equal
typename basic_json::value_type value_type
the type of the values when the iterator is dereferenced
friend std::istream & operator>>(std::istream &i, basic_json &j)
deserialize from stream
static iteration_proxy< const_iterator > iterator_wrapper(const_reference cont)
wrapper to access iterator member functions in range-based for
std::reverse_iterator< Base > base_iterator
shortcut to the reverse iterator adaptor
const_reverse_iterator crend() const noexcept
returns a const reverse iterator to one before the first
reference operator[](difference_type n) const
access to successor
iterator begin() noexcept
returns an iterator to the first element
basic_json(CompatibleType &&val) noexcept(noexcept(JSONSerializer< U >::to_json(std::declval< basic_json_t & >(), std::forward< CompatibleType >(val))))
create a JSON value
const_reference back() const
access the last element
static basic_json parse(const CharT s, const parser_callback_t cb=nullptr)
deserialize from string literal
iterator end() noexcept
returns an iterator to one past the last element
constexpr value_t type() const noexcept
return the type of the JSON value (explicit)
reference operator+=(const basic_json &val)
add an object to an array
IteratorType erase(IteratorType first, IteratorType last)
remove elements given an iterator range
friend bool operator!=(const ScalarType lhs, const_reference rhs) noexcept
comparison: not equal
basic_json(std::nullptr_t=nullptr) noexcept
create a null object
size_type count(typename object_t::key_type key) const
returns the number of occurrences of a key in a JSON object
static basic_json object(std::initializer_list< basic_json > init=std::initializer_list< basic_json >())
explicitly create an object from an initializer list
const_reference operator[](T *(&key)[n]) const
read-only access specified object element
string_t dump(const int indent=-1) const
serialization
friend bool operator!=(const_reference lhs, const_reference rhs) noexcept
comparison: not equal
iter_impl(const iter_impl &other) noexcept
copy constructor
reference operator*() const
return a reference to the value pointed to by the iterator
basic_json(InputIT first, InputIT last)
construct a JSON container given an iterator range
ReferenceType get_ref()
get a reference value (implicit)
void push_back(std::initializer_list< basic_json > init)
add an object to an object
a class to store JSON values
iterator insert(const_iterator pos, std::initializer_list< basic_json > ilist)
inserts elements
void erase(const size_type idx)
remove element from a JSON array given an index
ValueType value(const typename object_t::key_type &key, ValueType default_value) const
access specified object element with default value
typename std::conditional< std::is_const< U >::value, typename basic_json::const_pointer, typename basic_json::pointer >::type pointer
defines a pointer to the type iterated over (value_type)
const_reference operator[](const typename object_t::key_type &key) const
read-only access specified object element
const_iterator end() const noexcept
returns a const iterator to one past the last element
static allocator_type get_allocator()
returns the allocator associated with the container
friend bool operator==(const ScalarType lhs, const_reference rhs) noexcept
comparison: equal
reference operator[](size_type idx)
access specified array element
default JSONSerializer template argument
iterator find(typename object_t::key_type key)
find an element in a JSON object
constexpr bool is_structured() const noexcept
return whether type is structured
const_reference front() const
access the first element
static basic_json parse(T(&array)[N], const parser_callback_t cb=nullptr)
deserialize from an array
typename std::conditional< std::is_const< U >::value, typename basic_json::const_reference, typename basic_json::reference >::type reference
defines a reference to the type iterated over (value_type)
void swap(string_t &other)
exchanges the values
void swap(object_t &other)
exchanges the values
static basic_json parse(std::istream &i, const parser_callback_t cb=nullptr)
deserialize from stream
reference operator+=(std::initializer_list< basic_json > init)
add an object to an object
json_reverse_iterator & operator--()
pre-decrement (–it)
std::bidirectional_iterator_tag iterator_category
the category of the iterator
json_reverse_iterator operator--(int)
post-decrement (it–)
iter_impl operator-(difference_type i)
subtract from iterator
size_type max_size() const noexcept
returns the maximum possible number of elements
basic_json(std::initializer_list< basic_json > init, bool type_deduction=true, value_t manual_type=value_t::array)
create a container (array or object) from an initializer list
reference at(size_type idx)
access specified array element with bounds checking
JSON_DEPRECATED basic_json(std::istream &i, const parser_callback_t cb=nullptr)
construct a JSON value given an input stream
friend class basic_json
allow basic_json to access private members
constexpr bool is_number() const noexcept
return whether value is a number
const value_type & const_reference
the type of an element const reference
strtonum(const char *start, const char *end)
constexpr bool is_primitive() const noexcept
return whether type is primitive
object_t::key_type key() const
return the key of an object iterator
reference front()
access the first element
const_reverse_iterator crbegin() const noexcept
returns a const reverse iterator to the last element
reference value() const
return the value of an iterator
std::size_t size_type
a type to represent container sizes
const_iterator begin() const noexcept
returns a const iterator to the first element
iter_impl & operator++()
pre-increment (++it)
reference operator[](const typename object_t::key_type &key)
access specified object element
static iteration_proxy< iterator > iterator_wrapper(reference cont)
wrapper to access iterator member functions in range-based for
static void from_json(BasicJsonType &&j, ValueType &val) noexcept(noexcept(::nlohmann::from_json(std::forward< BasicJsonType >(j), val)))
convert a JSON value to any value type
reference operator[](difference_type n) const
access to successor
difference_type operator-(const json_reverse_iterator &other) const
return difference
static basic_json from_msgpack(const std::vector< uint8_t > &v, const size_t start_index=0)
create a JSON value from a byte vector in MessagePack format
iter_impl operator+(difference_type i)
add to iterator
NumberIntegerType number_integer_t
a type for a number (integer)
constexpr bool is_array() const noexcept
return whether value is an array
iter_impl & operator=(iter_impl other) noexcept(std::is_nothrow_move_constructible< pointer >::value andstd::is_nothrow_move_assignable< pointer >::value andstd::is_nothrow_move_constructible< internal_iterator >::value andstd::is_nothrow_move_assignable< internal_iterator >::value)
copy assignment
pointer operator->() const
dereference the iterator
NumberUnsignedType number_unsigned_t
a type for a number (unsigned)
friend bool operator==(const_reference lhs, const ScalarType rhs) noexcept
comparison: equal
friend bool operator>=(const_reference lhs, const_reference rhs) noexcept
comparison: greater than or equal
friend bool operator<(const_reference lhs, const_reference rhs) noexcept
comparison: less than
size_type size() const noexcept
returns the number of elements
string_t value(const typename object_t::key_type &key, const char *default_value) const
overload for a default value of type const char*
json_reverse_iterator(const typename base_iterator::iterator_type &it) noexcept
create reverse iterator from iterator
parse string into a built-in arithmetic type as if the current locale is POSIX.
const_reference operator[](T *key) const
read-only access specified object element
const_iterator cbegin() const noexcept
returns a const iterator to the first element
reference operator[](T *key)
access specified object element
static basic_json meta()
returns version information on the library
reference value() const
return the value of an iterator
static basic_json parse(std::istream &&i, const parser_callback_t cb=nullptr)
deserialize from stream
basic_json(size_type cnt, const basic_json &val)
construct an array with count copies of given value
json_reverse_iterator operator++(int)
post-increment (it++)
constexpr const auto & from_json
constexpr bool is_boolean() const noexcept
return whether value is a boolean
friend std::ostream & operator>>(const basic_json &j, std::ostream &o)
serialize to stream
reference at(const typename object_t::key_type &key)
access specified object element with bounds checking
PointerType get_ptr() noexcept
get a pointer value (implicit)
friend bool operator!=(const_reference lhs, const ScalarType rhs) noexcept
comparison: not equal
ObjectType< StringType, basic_json, std::less< StringType >, AllocatorType< std::pair< const StringType, basic_json >>> object_t
a type for an object
namespace for Niels Lohmann
constexpr bool is_number_integer() const noexcept
return whether value is an integer number
basic_json(const value_t value_type)
create an empty value with a given type
json_reverse_iterator(const base_iterator &it) noexcept
create reverse iterator from base class
reference operator+=(const typename object_t::value_type &val)
add an object to an object
constexpr bool is_object() const noexcept
return whether value is an object
reference operator+=(basic_json &&val)
add an object to an array
constexpr bool is_number_float() const noexcept
return whether value is a floating-point number
static basic_json parse(IteratorType first, IteratorType last, const parser_callback_t cb=nullptr)
deserialize from an iterator range with contiguous storage
json_reverse_iterator & operator+=(difference_type i)
add to iterator
iter_impl operator++(int)
post-increment (it++)
iter_impl operator--(int)
post-decrement (it–)
bool operator>(const iter_impl &other) const
comparison: greater than
iter_impl & operator--()
pre-decrement (–it)
bool operator<(const iter_impl &other) const
comparison: smaller
reverse_iterator rbegin() noexcept
returns an iterator to the reverse-beginning
reference back()
access the last element
iterator insert(const_iterator pos, size_type cnt, const basic_json &val)
inserts elements
static void to_json(BasicJsonType &j, ValueType &&val) noexcept(noexcept(::nlohmann::to_json(j, std::forward< ValueType >(val))))
convert any value type to a JSON value
iter_impl(pointer object) noexcept
constructor for a given JSON instance
iterator insert(const_iterator pos, const_iterator first, const_iterator last)
inserts elements
std::function< bool(int depth, parse_event_t event, basic_json &parsed)> parser_callback_t
per-element parser callback type
constexpr bool is_string() const noexcept
return whether value is a string
const_iterator cend() const noexcept
returns a const iterator to one past the last element
const_reference at(const typename object_t::key_type &key) const
access specified object element with bounds checking
friend bool operator==(const_reference lhs, const_reference rhs) noexcept
comparison: equal
void push_back(const basic_json &val)
add an object to an array
void push_back(const typename object_t::value_type &val)
add an object to an object
void swap(array_t &other)
exchanges the values
ArrayType< basic_json, AllocatorType< basic_json >> array_t
a type for an array
size_type erase(const typename object_t::key_type &key)
remove element from a JSON object given a key
constexpr const auto & to_json
bool empty() const noexcept
checks whether the container is empty
reference & operator=(basic_json other) noexcept(std::is_nothrow_move_constructible< value_t >::value andstd::is_nothrow_move_assignable< value_t >::value andstd::is_nothrow_move_constructible< json_value >::value andstd::is_nothrow_move_assignable< json_value >::value)
copy assignment
const_reference at(size_type idx) const
access specified array element with bounds checking
const_reverse_iterator rbegin() const noexcept
returns a const reverse iterator to the last element
static basic_json from_cbor(const std::vector< uint8_t > &v, const size_t start_index=0)
create a JSON value from a byte vector in CBOR format
ReferenceType get_ref() const
get a reference value (implicit)
std::ptrdiff_t difference_type
a type to represent differences between iterators
static basic_json parse(const ContiguousContainer &c, const parser_callback_t cb=nullptr)
deserialize from a container with contiguous storage
AllocatorType< basic_json > allocator_type
the allocator type
json_pointer(const std::string &s="")
create JSON pointer
iterator insert(const_iterator pos, basic_json &&val)
inserts element
const_reverse_iterator rend() const noexcept
returns a const reverse iterator to one before the first
const_reference operator[](size_type idx) const
access specified array element
constexpr bool is_null() const noexcept
return whether value is null
json_reverse_iterator operator-(difference_type i) const
subtract from iterator
static std::vector< uint8_t > to_msgpack(const basic_json &j)
create a MessagePack serialization of a given JSON value
typename std::allocator_traits< allocator_type >::const_pointer const_pointer
the type of an element const pointer
StringType string_t
a type for a string
static basic_json array(std::initializer_list< basic_json > init=std::initializer_list< basic_json >())
explicitly create an array from an initializer list
void swap(reference other) noexcept(std::is_nothrow_move_constructible< value_t >::value andstd::is_nothrow_move_assignable< value_t >::value andstd::is_nothrow_move_constructible< json_value >::value andstd::is_nothrow_move_assignable< json_value >::value)
exchanges the values
const_iterator find(typename object_t::key_type key) const
find an element in a JSON object
basic_json(basic_json &&other) noexcept
move constructor
friend bool operator>(const_reference lhs, const_reference rhs) noexcept
comparison: greater than
string_t value(const json_pointer &ptr, const char *default_value) const
overload for a default value of type const char*
constexpr bool is_number_unsigned() const noexcept
return whether value is an unsigned integer number
typename basic_json::difference_type difference_type
a type to represent differences between iterators
constexpr const PointerType get_ptr() const noexcept
get a pointer value (implicit)
bool operator==(const iter_impl &other) const
comparison: equal
iter_impl & operator-=(difference_type i)
subtract from iterator
typename Base::reference reference
the reference type for the pointed-to element
a template for a reverse iterator class
void push_back(basic_json &&val)
add an object to an array
json_reverse_iterator operator+(difference_type i) const
add to iterator
iterator insert(const_iterator pos, const basic_json &val)
inserts element
void clear() noexcept
clears the contents
static std::vector< uint8_t > to_cbor(const basic_json &j)
create a MessagePack serialization of a given JSON value
std::pair< iterator, bool > emplace(Args &&...args)
add an object to an object if key does not exist
basic_json value_type
the type of elements in a basic_json container
iter_impl & operator+=(difference_type i)
add to iterator
object_t::key_type key() const
return the key of an object iterator
friend std::istream & operator<<(basic_json &j, std::istream &i)
deserialize from stream
basic_json(const basic_json &other)
copy constructor
bool operator!=(const iter_impl &other) const
comparison: not equal
friend std::ostream & operator<<(std::ostream &o, const basic_json &j)
serialize to stream
IteratorType erase(IteratorType pos)
remove element given an iterator
a template for a random access iterator for the basic_json class
json_reverse_iterator & operator++()
pre-increment (++it)
std::string type_name() const
return the type as string
constexpr bool is_discarded() const noexcept
return whether value is discarded
void emplace_back(Args &&...args)
add an object to an array
parse_event_t
JSON callback events.
reference operator[](T *(&key)[n])
access specified object element
reverse_iterator rend() noexcept
returns an iterator to the reverse-end