Template Class basic_json

Defined in File json.hpp

Inheritance Relationships

Base Type

public nlohmann::detail::json_base_class< void >

Class Documentation

template<template<typename U, typename V, typename ...Args> class ObjectType = std::map, template<typename U, typename ...Args> class ArrayType = std::vector, class StringType = std::string, class BooleanType = bool, class NumberIntegerType = std::int64_t, class NumberUnsignedType = std::uint64_t, class NumberFloatType = double, template<typename U> class AllocatorType = std::allocator, template<typename T, typename SFINAE = void> class JSONSerializer = adl_serializer, class BinaryType = std::vector<std::uint8_t>, class CustomBaseClass = void> class basic_json : public nlohmann::detail::json_base_class<void>

namespace for Niels Lohmann

a class to store JSON values

See also

https://github.com/nlohmann

Since: version 1.0.0

Since: version 1.0.0

element access

Access to the JSON value.

inline reference at(size_type idx)

access specified array element with bounds checking

inline const_reference at(size_type idx) const

access specified array element with bounds checking

inline reference at(const typename object_t::key_type &key)

access specified object element with bounds checking

template<class KeyType, detail::enable_if_t<detail::is_usable_as_basic_json_key_type<basic_json_t, KeyType>::value, int> = 0> inline reference at(KeyType &&key)

access specified object element with bounds checking

inline const_reference at(const typename object_t::key_type &key) const

access specified object element with bounds checking

template<class KeyType, detail::enable_if_t<detail::is_usable_as_basic_json_key_type<basic_json_t, KeyType>::value, int> = 0> inline const_reference at(KeyType &&key) const

access specified object element with bounds checking

inline reference operator[](size_type idx)

access specified array element

inline const_reference operator[](size_type idx) const

access specified array element

inline reference operator[](typename object_t::key_type key)

access specified object element

inline const_reference operator[](const typename object_t::key_type &key) const

access specified object element

template<typename T> inline reference operator[](T *key)

template<typename T> inline const_reference operator[](T *key) const

template<class KeyType, detail::enable_if_t<detail::is_usable_as_basic_json_key_type<basic_json_t, KeyType>::value, int> = 0> inline reference operator[](KeyType &&key)

access specified object element

template<class KeyType, detail::enable_if_t<detail::is_usable_as_basic_json_key_type<basic_json_t, KeyType>::value, int> = 0> inline const_reference operator[](KeyType &&key) const

access specified object element

template<class ValueType, detail::enable_if_t<!detail::is_transparent<object_comparator_t>::value && detail::is_getable<basic_json_t, ValueType>::value && !std::is_same<value_t, detail::uncvref_t<ValueType>>::value, int> = 0> inline ValueType value(const typename object_t::key_type &key, const ValueType &default_value) const

access specified object element with default value

template<class ValueType, class ReturnType = typename value_return_type<ValueType>::type, detail::enable_if_t<!detail::is_transparent<object_comparator_t>::value && detail::is_getable<basic_json_t, ReturnType>::value && !std::is_same<value_t, detail::uncvref_t<ValueType>>::value, int> = 0> inline ReturnType value(const typename object_t::key_type &key, ValueType &&default_value) const

access specified object element with default value

template<class ValueType, class KeyType, detail::enable_if_t<detail::is_transparent<object_comparator_t>::value && !detail::is_json_pointer<KeyType>::value && is_comparable_with_object_key<KeyType>::value && detail::is_getable<basic_json_t, ValueType>::value && !std::is_same<value_t, detail::uncvref_t<ValueType>>::value, int> = 0> inline ValueType value(KeyType &&key, const ValueType &default_value) const

access specified object element with default value

template<class ValueType, class KeyType, class ReturnType = typename value_return_type<ValueType>::type, detail::enable_if_t<detail::is_transparent<object_comparator_t>::value && !detail::is_json_pointer<KeyType>::value && is_comparable_with_object_key<KeyType>::value && detail::is_getable<basic_json_t, ReturnType>::value && !std::is_same<value_t, detail::uncvref_t<ValueType>>::value, int> = 0> inline ReturnType value(KeyType &&key, ValueType &&default_value) const

access specified object element via JSON Pointer with default value

template<class ValueType, detail::enable_if_t<detail::is_getable<basic_json_t, ValueType>::value && !std::is_same<value_t, detail::uncvref_t<ValueType>>::value, int> = 0> inline ValueType value(const json_pointer &ptr, const ValueType &default_value) const

access specified object element via JSON Pointer with default value

template<class ValueType, class ReturnType = typename value_return_type<ValueType>::type, detail::enable_if_t<detail::is_getable<basic_json_t, ReturnType>::value && !std::is_same<value_t, detail::uncvref_t<ValueType>>::value, int> = 0> inline ReturnType value(const json_pointer &ptr, ValueType &&default_value) const

access specified object element via JSON Pointer with default value

template<class ValueType, class BasicJsonType, detail::enable_if_t< detail::is_basic_json< BasicJsonType >::value &&detail::is_getable< basic_json_t, ValueType >::value &&!std::is_same< value_t, detail::uncvref_t< ValueType >>::value, int > = 0> inline JSON_HEDLEY_DEPRECATED_FOR (3.11.0, basic_json::json_pointer or nlohmann::json_pointer< basic_json::string_t >) ValueType value(const

access the first element

inline const_reference front() const

access the first element

inline reference back()

access the last element

inline const_reference back() const

access the last element

template<class IteratorType, detail::enable_if_t<std::is_same<IteratorType, typename basic_json_t::iterator>::value || std::is_same<IteratorType, typename basic_json_t::const_iterator>::value, int> = 0> inline IteratorType erase(IteratorType pos)

remove element given an iterator

template<class IteratorType, detail::enable_if_t<std::is_same<IteratorType, typename basic_json_t::iterator>::value || std::is_same<IteratorType, typename basic_json_t::const_iterator>::value, int> = 0> inline IteratorType erase(IteratorType first, IteratorType last)

remove elements given an iterator range

inline size_type erase(const typename object_t::key_type &key)

remove element from a JSON object given a key

template<class KeyType, detail::enable_if_t<detail::is_usable_as_basic_json_key_type<basic_json_t, KeyType>::value, int> = 0> inline size_type erase(KeyType &&key)

remove element from a JSON object given a key

inline void erase(const size_type idx)

remove element from a JSON array given an index

exceptions

Classes to implement user-defined exceptions.

using exception = detail::exception 

using parse_error = detail::parse_error 

using invalid_iterator = detail::invalid_iterator 

using type_error = detail::type_error 

using out_of_range = detail::out_of_range 

using other_error = detail::other_error 

container types

The canonic container types to use basic_json like any other STL container.

using value_type = basic_json : the type of elements in a basic_json container

using reference = value_type&: the type of an element reference

using const_reference = const value_type&: the type of an element const reference

using difference_type = std::ptrdiff_t: a type to represent differences between iterators

using size_type = std::size_t: a type to represent container sizes

using allocator_type = AllocatorType<basic_json>: the allocator type

using pointer = typename std::allocator_traits<allocator_type>::pointer: the type of an element pointer

using const_pointer = typename std::allocator_traits<allocator_type>::const_pointer: the type of an element const pointer

using iterator = iter_impl<basic_json>: an iterator for a basic_json container

using const_iterator = iter_impl<const basic_json>: a const iterator for a basic_json container

using reverse_iterator = json_reverse_iterator<typename basic_json::iterator>: a reverse iterator for a basic_json container

using const_reverse_iterator = json_reverse_iterator<typename basic_json::const_iterator>: a const reverse iterator for a basic_json container

JSON value data types

The data types to store a JSON value. These types are derived from the template arguments passed to class basic_json.

using default_object_comparator_t = std::less<StringType>

default object key comparator type The actual object key comparator type (object_comparator_t) may be different.

using object_t = ObjectType<StringType, basic_json, default_object_comparator_t, AllocatorType<std::pair<const StringType, basic_json>>>

a type for an object

using array_t = ArrayType<basic_json, AllocatorType<basic_json>>

a type for an array

using string_t = StringType 

a type for a string

using boolean_t = BooleanType 

a type for a boolean

using number_integer_t = NumberIntegerType 

a type for a number (integer)

using number_unsigned_t = NumberUnsignedType 

a type for a number (unsigned)

using number_float_t = NumberFloatType 

a type for a number (floating-point)

using binary_t = nlohmann::byte_container_with_subtype<BinaryType>

a type for a packed binary type

using object_comparator_t = detail::actual_object_comparator_t<basic_json>

object key comparator type

modifiers

checks whether the container is empty.

returns the number of elements

returns the maximum possible number of elements

inline friend void swap (reference left, reference right) noexcept(std::is_nothrow_move_constructible< value_t >::value &&std::is_nothrow_move_assignable< value_t >::value &&std::is_nothrow_move_constructible< json_value >::value &&//NOLINT(cppcoreguidelines-noexcept-swap, performance-noexcept-swap) std::is_nothrow_move_assignable< json_value >::value)

exchanges the values

inline reference operator+=(basic_json &&val)

add an object to an array

inline void push_back(const basic_json &val)

add an object to an array

inline reference operator+=(const basic_json &val)

add an object to an array

inline void push_back(const typename object_t::value_type &val)

add an object to an object

inline reference operator+=(const typename object_t::value_type &val)

add an object to an object

inline void push_back(initializer_list_t init)

add an object to an object

inline reference operator+=(initializer_list_t init)

add an object to an object

template<class ...Args> inline reference emplace_back(Args&&... args)

add an object to an array

template<class ...Args> inline std::pair<iterator, bool> emplace(Args&&... args)

add an object to an object if key does not exist

template<typename ...Args> inline iterator insert_iterator(const_iterator pos, Args&&... args): Helper for insertion of an iterator

Note

: This uses std::distance to support GCC 4.8, see https://github.com/nlohmann/json/pull/1257

inline iterator insert(const_iterator pos, const basic_json &val)

inserts element into array

inline iterator insert(const_iterator pos, basic_json &&val)

inserts element into array

inline iterator insert(const_iterator pos, size_type cnt, const basic_json &val)

inserts copies of element into array

inline iterator insert(const_iterator pos, const_iterator first, const_iterator last)

inserts range of elements into array

inline iterator insert(const_iterator pos, initializer_list_t ilist)

inserts elements from initializer list into array

inline void insert(const_iterator first, const_iterator last)

inserts range of elements into object

inline void update(const_reference j, bool merge_objects = false)

updates a JSON object from another object, overwriting existing keys

inline void update(const_iterator first, const_iterator last, bool merge_objects = false)

updates a JSON object from another object, overwriting existing keys

inline void swap (reference other) noexcept(std::is_nothrow_move_constructible< value_t >::value &&std::is_nothrow_move_assignable< value_t >::value &&std::is_nothrow_move_constructible< json_value >::value &&//NOLINT(cppcoreguidelines-noexcept-swap, performance-noexcept-swap) std::is_nothrow_move_assignable< json_value >::value)

exchanges the values

inline void swap(array_t &other)

exchanges the values

inline void swap(object_t &other)

exchanges the values

inline void swap(string_t &other)

exchanges the values

inline void swap(binary_t &other)

exchanges the values

inline void swap(typename binary_t::container_type &other)

exchanges the values

lexicographical comparison operators

JSON_PRIVATE_UNLESS_TESTED __pad3__

JSON_PRIVATE_UNLESS_TESTED const_reference rhs

JSON_PRIVATE_UNLESS_TESTED const_reference bool inverse

value access

Direct access to the stored value of a JSON value.

template<typename PointerType, typename std::enable_if<std::is_pointer<PointerType>::value, int>::type = 0> inline auto get_ptr() noexcept -> decltype(std::declval<basic_json_t&>().get_impl_ptr(std::declval<PointerType>()))

get a pointer value (implicit)

template<typename PointerType, typename std::enable_if<std::is_pointer<PointerType>::value && std::is_const<typename std::remove_pointer<PointerType>::type>::value, int>::type = 0> inline constexpr auto get_ptr() const noexcept -> decltype(std::declval<const basic_json_t&>().get_impl_ptr(std::declval<PointerType>()))

get a pointer value (implicit)

template<typename ValueTypeCV, typename ValueType = detail::uncvref_t<ValueTypeCV>> inline auto get () const noexcept(noexcept(std::declval< const basic_json_t & >().template get_impl< ValueType >(detail::priority_tag< 4 > {}))) -> decltype(std::declval< const basic_json_t & >().template get_impl< ValueType >(detail::priority_tag< 4 > {}))

get a (pointer) value (explicit)

Performs explicit type conversion between the JSON value and a compatible value if required.

If the requested type is a pointer to the internally stored JSON value that pointer is returned. No copies are made.
If the requested type is the current basic_json, or a different basic_json convertible from the current basic_json.
Otherwise the value is converted by calling the json_serializer<ValueType> from_json() method.

Since: version 2.1.0

Template Parameters:

ValueTypeCV – the provided value type
ValueType – the returned value type
ValueType – if necessary

Throws:

what – json_serializer<ValueType> from_json() method throws if conversion is required

Returns:

copy of the JSON value, converted to

template<typename PointerType, typename std::enable_if< std::is_pointer< PointerType >::value, int >::type = 0> inline auto get () noexcept -> decltype(std::declval< basic_json_t & >().template get_ptr< PointerType >())

get a pointer value (explicit)

Explicit pointer access to the internally stored JSON value. No copies are made.

@complexity Constant.

@liveexample{The example below shows how pointers to internal values of a JSON value can be requested. Note that no type conversions are made and a nullptr is returned if the value and the requested pointer type does not match.,get__PointerType}

See also

see get_ptr() for explicit pointer-member access

Since: version 1.0.0

Warning

The pointer becomes invalid if the underlying JSON object changes.

Template Parameters:: PointerType – pointer type; must be a pointer to array_t, object_t, string_t, boolean_t, number_integer_t, number_unsigned_t, or number_float_t.
Returns:: pointer to the internally stored JSON value if the requested pointer type PointerType fits to the JSON value; nullptr otherwise

template<typename ValueType, detail::enable_if_t<!detail::is_basic_json<ValueType>::value && detail::has_from_json<basic_json_t, ValueType>::value, int> = 0> inline ValueType &get_to(ValueType &v) const noexcept(noexcept(JSONSerializer<ValueType>::from_json(std::declval<const basic_json_t&>(), v)))

get a value (explicit)

template<typename ValueType, detail::enable_if_t<detail::is_basic_json<ValueType>::value, int> = 0> inline ValueType &get_to(ValueType &v) const

template<typename T, std::size_t N, typename Array = T (&)[N], detail::enable_if_t<detail::has_from_json<basic_json_t, Array>::value, int> = 0> inline Array get_to(T (&v)[N]) const noexcept(noexcept(JSONSerializer<Array>::from_json(std::declval<const basic_json_t&>(), v)))

template<typename ReferenceType, typename std::enable_if<std::is_reference<ReferenceType>::value, int>::type = 0> inline ReferenceType get_ref()

get a reference value (implicit)

template<typename ReferenceType, typename std::enable_if<std::is_reference<ReferenceType>::value && std::is_const<typename std::remove_reference<ReferenceType>::type>::value, int>::type = 0> inline ReferenceType get_ref() const

get a reference value (implicit)

template<typename ValueType, typename std::enable_if<detail::conjunction<detail::negation<std::is_pointer<ValueType>>, detail::negation<std::is_same<ValueType, std::nullptr_t>>, detail::negation<std::is_same<ValueType, detail::json_ref<basic_json>>>, detail::negation<std::is_same<ValueType, typename string_t::value_type>>, detail::negation<detail::is_basic_json<ValueType>>, detail::negation<std::is_same<ValueType, std::initializer_list<typename string_t::value_type>>>, detail::is_detected_lazy<detail::get_template_function, const basic_json_t&, ValueType>>::value, int>::type = 0> inline JSON_EXPLICIT operator ValueType() const

get a value (implicit)

Implicit type conversion between the JSON value and a compatible value. The call is realized by calling get() const.

@complexity Linear in the size of the JSON value.

@liveexample{The example below shows several conversions from JSON values to other types. There a few things to note: (1) Floating-point numbers can be converted to integers\, (2) A JSON array can be converted to a standard std::vector<short>\, (3) A JSON object can be converted to C++ associative containers such as std::unordered_map<std::string\, json>.,operator__ValueType}

Since: version 1.0.0

Template Parameters:: ValueType – non-pointer type compatible to the JSON value, for instance int for JSON integer numbers, bool for JSON booleans, or std::vector types for JSON arrays. The character type of string_t as well as an initializer list of this type is excluded to avoid ambiguities as these types implicitly convert to std::string.
Throws:: type_error.302 – in case passed type ValueType is incompatible to the JSON value type (e.g., the JSON value is of type boolean, but a string is requested); see example below
Returns:: copy of the JSON value, converted to type ValueType

inline binary_t &get_binary()

get a binary value

inline const binary_t &get_binary() const

get a binary value

constructors and destructors

Constructors of class basic_json, copy/move constructor, copy assignment, static functions creating objects, and the destructor.

static inline JSON_HEDLEY_WARN_UNUSED_RESULT basic_json binary (const typename binary_t::container_type &init)

explicitly create a binary array (without subtype)

static inline JSON_HEDLEY_WARN_UNUSED_RESULT basic_json binary (const typename binary_t::container_type &init, typename binary_t::subtype_type subtype)

explicitly create a binary array (with subtype)

static inline JSON_HEDLEY_WARN_UNUSED_RESULT basic_json binary (typename binary_t::container_type &&init)

explicitly create a binary array

static inline JSON_HEDLEY_WARN_UNUSED_RESULT basic_json binary (typename binary_t::container_type &&init, typename binary_t::subtype_type subtype)

explicitly create a binary array (with subtype)

static inline JSON_HEDLEY_WARN_UNUSED_RESULT basic_json array (initializer_list_t init={})

explicitly create an array from an initializer list

static inline JSON_HEDLEY_WARN_UNUSED_RESULT basic_json object (initializer_list_t init={})

explicitly create an object from an initializer list

inline basic_json(const value_t v)

create an empty value with a given type

inline basic_json(std::nullptr_t = nullptr) noexcept

create a null object

template<typename CompatibleType, typename U = detail::uncvref_t<CompatibleType>, detail::enable_if_t< !detail::is_basic_json< U >::value &&detail::is_compatible_type< basic_json_t, U >::value, int > = 0> inline basic_json (CompatibleType &&val) noexcept(noexcept(//NOLINT(bugprone-forwarding-reference-overload, bugprone-exception-escape) JSONSerializer< U >::to_json(std::declval< basic_json_t & >(), std::forward< CompatibleType >(val))))

create a JSON value from compatible types

template<typename BasicJsonType, detail::enable_if_t<detail::is_basic_json<BasicJsonType>::value && !std::is_same<basic_json, BasicJsonType>::value, int> = 0> inline basic_json(const BasicJsonType &val)

create a JSON value from an existing one

inline basic_json(initializer_list_t init, bool type_deduction = true, value_t manual_type = value_t::array)

create a container (array or object) from an initializer list

inline basic_json(size_type cnt, const basic_json &val)

construct an array with count copies of given value

template<class InputIT, typename std::enable_if<std::is_same<InputIT, typename basic_json_t::iterator>::value || std::is_same<InputIT, typename basic_json_t::const_iterator>::value, int>::type = 0> inline basic_json(InputIT first, InputIT last)

construct a JSON container given an iterator range

template<typename JsonRef, detail::enable_if_t<detail::conjunction<detail::is_json_ref<JsonRef>, std::is_same<typename JsonRef::value_type, basic_json>>::value, int> = 0> inline basic_json(const JsonRef &ref)

inline basic_json(const basic_json &other)

copy constructor

inline basic_json(basic_json &&other) noexcept

move constructor

inline basic_json &operator=(basic_json other) noexcept(std::is_nothrow_move_constructible<value_t>::value && std::is_nothrow_move_assignable<value_t>::value && std::is_nothrow_move_constructible<json_value>::value && std::is_nothrow_move_assignable<json_value>::value && std::is_nothrow_move_assignable<json_base_class_t>::value)

copy assignment

inline ~basic_json() noexcept

destructor

binary serialization/deserialization support

static inline std::vector<std::uint8_t> to_cbor(const basic_json &j)

create a CBOR serialization of a given JSON value

static inline void to_cbor(const basic_json &j, detail::output_adapter<std::uint8_t> o)

create a CBOR serialization of a given JSON value

static inline void to_cbor(const basic_json &j, detail::output_adapter<char> o)

create a CBOR serialization of a given JSON value

static inline std::vector<std::uint8_t> to_msgpack(const basic_json &j)

create a MessagePack serialization of a given JSON value

static inline void to_msgpack(const basic_json &j, detail::output_adapter<std::uint8_t> o)

create a MessagePack serialization of a given JSON value

static inline void to_msgpack(const basic_json &j, detail::output_adapter<char> o)

create a MessagePack serialization of a given JSON value

static inline std::vector<std::uint8_t> to_ubjson(const basic_json &j, const bool use_size = false, const bool use_type = false)

create a UBJSON serialization of a given JSON value

static inline void to_ubjson(const basic_json &j, detail::output_adapter<std::uint8_t> o, const bool use_size = false, const bool use_type = false)

create a UBJSON serialization of a given JSON value

static inline void to_ubjson(const basic_json &j, detail::output_adapter<char> o, const bool use_size = false, const bool use_type = false)

create a UBJSON serialization of a given JSON value

static inline std::vector<std::uint8_t> to_bjdata(const basic_json &j, const bool use_size = false, const bool use_type = false)

create a BJData serialization of a given JSON value

static inline void to_bjdata(const basic_json &j, detail::output_adapter<std::uint8_t> o, const bool use_size = false, const bool use_type = false)

create a BJData serialization of a given JSON value

static inline void to_bjdata(const basic_json &j, detail::output_adapter<char> o, const bool use_size = false, const bool use_type = false)

create a BJData serialization of a given JSON value

static inline std::vector<std::uint8_t> to_bson(const basic_json &j)

create a BSON serialization of a given JSON value

static inline void to_bson(const basic_json &j, detail::output_adapter<std::uint8_t> o)

create a BSON serialization of a given JSON value

static inline void to_bson(const basic_json &j, detail::output_adapter<char> o)

create a BSON serialization of a given JSON value

template<typename InputType> static inline JSON_HEDLEY_WARN_UNUSED_RESULT basic_json from_cbor (InputType &&i, const bool strict=true, const bool allow_exceptions=true, const cbor_tag_handler_t tag_handler=cbor_tag_handler_t::error)

create a JSON value from an input in CBOR format

template<typename IteratorType> static inline JSON_HEDLEY_WARN_UNUSED_RESULT basic_json from_cbor (IteratorType first, IteratorType last, const bool strict=true, const bool allow_exceptions=true, const cbor_tag_handler_t tag_handler=cbor_tag_handler_t::error)

create a JSON value from an input in CBOR format

template<typename T> static inline JSON_HEDLEY_WARN_UNUSED_RESULT basic_json from_cbor (const T *ptr, std::size_t len, const bool strict=true, const bool allow_exceptions=true, const cbor_tag_handler_t tag_handler=cbor_tag_handler_t::error)

static inline JSON_HEDLEY_WARN_UNUSED_RESULT basic_json from_cbor (detail::span_input_adapter &&i, const bool strict=true, const bool allow_exceptions=true, const cbor_tag_handler_t tag_handler=cbor_tag_handler_t::error)

template<typename InputType> static inline JSON_HEDLEY_WARN_UNUSED_RESULT basic_json from_msgpack (InputType &&i, const bool strict=true, const bool allow_exceptions=true)

create a JSON value from an input in MessagePack format

template<typename IteratorType> static inline JSON_HEDLEY_WARN_UNUSED_RESULT basic_json from_msgpack (IteratorType first, IteratorType last, const bool strict=true, const bool allow_exceptions=true)

create a JSON value from an input in MessagePack format

template<typename T> static inline JSON_HEDLEY_WARN_UNUSED_RESULT basic_json from_msgpack (const T *ptr, std::size_t len, const bool strict=true, const bool allow_exceptions=true)

static inline JSON_HEDLEY_WARN_UNUSED_RESULT basic_json from_msgpack (detail::span_input_adapter &&i, const bool strict=true, const bool allow_exceptions=true)

template<typename InputType> static inline JSON_HEDLEY_WARN_UNUSED_RESULT basic_json from_ubjson (InputType &&i, const bool strict=true, const bool allow_exceptions=true)

create a JSON value from an input in UBJSON format

template<typename IteratorType> static inline JSON_HEDLEY_WARN_UNUSED_RESULT basic_json from_ubjson (IteratorType first, IteratorType last, const bool strict=true, const bool allow_exceptions=true)

create a JSON value from an input in UBJSON format

template<typename T> static inline JSON_HEDLEY_WARN_UNUSED_RESULT basic_json from_ubjson (const T *ptr, std::size_t len, const bool strict=true, const bool allow_exceptions=true)

static inline JSON_HEDLEY_WARN_UNUSED_RESULT basic_json from_ubjson (detail::span_input_adapter &&i, const bool strict=true, const bool allow_exceptions=true)

template<typename InputType> static inline JSON_HEDLEY_WARN_UNUSED_RESULT basic_json from_bjdata (InputType &&i, const bool strict=true, const bool allow_exceptions=true)

create a JSON value from an input in BJData format

template<typename IteratorType> static inline JSON_HEDLEY_WARN_UNUSED_RESULT basic_json from_bjdata (IteratorType first, IteratorType last, const bool strict=true, const bool allow_exceptions=true)

create a JSON value from an input in BJData format

template<typename InputType> static inline JSON_HEDLEY_WARN_UNUSED_RESULT basic_json from_bson (InputType &&i, const bool strict=true, const bool allow_exceptions=true)

create a JSON value from an input in BSON format

template<typename IteratorType> static inline JSON_HEDLEY_WARN_UNUSED_RESULT basic_json from_bson (IteratorType first, IteratorType last, const bool strict=true, const bool allow_exceptions=true)

create a JSON value from an input in BSON format

template<typename T> static inline JSON_HEDLEY_WARN_UNUSED_RESULT basic_json from_bson (const T *ptr, std::size_t len, const bool strict=true, const bool allow_exceptions=true)

static inline JSON_HEDLEY_WARN_UNUSED_RESULT basic_json from_bson (detail::span_input_adapter &&i, const bool strict=true, const bool allow_exceptions=true)

JSON Patch functions

return flattened JSON value

unflatten a previously flattened JSON value

static inline JSON_HEDLEY_WARN_UNUSED_RESULT basic_json diff (const basic_json &source, const basic_json &target, const std::string &path="")

creates a diff as a JSON patch

inline basic_json patch(const basic_json &json_patch) const

applies a JSON patch to a copy of the current object

object inspection

Functions to inspect the type of a JSON value.

inline string_t dump(const int indent = -1, const char indent_char = ' ', const bool ensure_ascii = false, const error_handler_t error_handler = error_handler_t::strict) const

serialization

inline constexpr value_t type() const noexcept

return the type of the JSON value (explicit)

inline constexpr bool is_primitive() const noexcept

return whether type is primitive

inline constexpr bool is_structured() const noexcept

return whether type is structured

inline constexpr bool is_null() const noexcept

return whether value is null

inline constexpr bool is_boolean() const noexcept

return whether value is a boolean

inline constexpr bool is_number() const noexcept

return whether value is a number

inline constexpr bool is_number_integer() const noexcept

return whether value is an integer number

inline constexpr bool is_number_unsigned() const noexcept

return whether value is an unsigned integer number

inline constexpr bool is_number_float() const noexcept

return whether value is a floating-point number

inline constexpr bool is_object() const noexcept

return whether value is an object

inline constexpr bool is_array() const noexcept

return whether value is an array

inline constexpr bool is_string() const noexcept

return whether value is a string

inline constexpr bool is_binary() const noexcept

return whether value is a binary array

inline constexpr bool is_discarded() const noexcept

return whether value is discarded

inline constexpr operator value_t() const noexcept

return the type of the JSON value (implicit)

lookup

inline iterator find(const typename object_t::key_type &key)

find an element in a JSON object

inline const_iterator find(const typename object_t::key_type &key) const

find an element in a JSON object

template<class KeyType, detail::enable_if_t<detail::is_usable_as_basic_json_key_type<basic_json_t, KeyType>::value, int> = 0> inline iterator find(KeyType &&key)

find an element in a JSON object

template<class KeyType, detail::enable_if_t<detail::is_usable_as_basic_json_key_type<basic_json_t, KeyType>::value, int> = 0> inline const_iterator find(KeyType &&key) const

find an element in a JSON object

inline size_type count(const typename object_t::key_type &key) const

returns the number of occurrences of a key in a JSON object

template<class KeyType, detail::enable_if_t<detail::is_usable_as_basic_json_key_type<basic_json_t, KeyType>::value, int> = 0> inline size_type count(KeyType &&key) const

returns the number of occurrences of a key in a JSON object

inline bool contains(const typename object_t::key_type &key) const

check the existence of an element in a JSON object

template<class KeyType, detail::enable_if_t<detail::is_usable_as_basic_json_key_type<basic_json_t, KeyType>::value, int> = 0> inline bool contains(KeyType &&key) const

check the existence of an element in a JSON object

inline bool contains(const json_pointer &ptr) const

check the existence of an element in a JSON object given a JSON pointer

JSON Pointer functions

inline reference operator[](const json_pointer &ptr)

access specified element via JSON Pointer

template<typename BasicJsonType, detail::enable_if_t< detail::is_basic_json< BasicJsonType >::value, int > = 0> inline JSON_HEDLEY_DEPRECATED_FOR (3.11.0, basic_json::json_pointer or nlohmann::json_pointer< basic_json::string_t >) reference operator[](const

inline const_reference operator[](const json_pointer &ptr) const

access specified element via JSON Pointer

template<typename BasicJsonType, detail::enable_if_t< detail::is_basic_json< BasicJsonType >::value, int > = 0> inline JSON_HEDLEY_DEPRECATED_FOR (3.11.0, basic_json::json_pointer or nlohmann::json_pointer< basic_json::string_t >) const _reference operator[](const

access specified element via JSON Pointer

template<typename BasicJsonType, detail::enable_if_t< detail::is_basic_json< BasicJsonType >::value, int > = 0> inline JSON_HEDLEY_DEPRECATED_FOR (3.11.0, basic_json::json_pointer or nlohmann::json_pointer< basic_json::string_t >) reference at(const

inline const_reference at(const json_pointer &ptr) const

access specified element via JSON Pointer

JSON Merge Patch functions

inline void merge_patch(const basic_json &apply_patch)

applies a JSON Merge Patch

Public Types

using value_t = detail::value_t 

using json_pointer = ::nlohmann::json_pointer<StringType>: JSON Pointer, see nlohmann::json_pointer.

template<typename T, typename SFINAE> using json_serializer = JSONSerializer<T, SFINAE>

using error_handler_t = detail::error_handler_t : how to treat decoding errors

using cbor_tag_handler_t = detail::cbor_tag_handler_t : how to treat CBOR tags

using initializer_list_t = std::initializer_list<detail::json_ref<basic_json>>: helper type for initializer lists of basic_json values

using input_format_t = detail::input_format_t 

using json_sax_t = json_sax<basic_json>: SAX interface type, see nlohmann::json_sax.

using parse_event_t = detail::parse_event_t 

parser event types

using parser_callback_t = detail::parser_callback_t<basic_json>

per-element parser callback type

Public Functions

inline JSON_HEDLEY_RETURNS_NON_NULL const char * type_name () const noexcept

return the type as string

inline data(const value_t v)

inline data(size_type cnt, const basic_json &val)

data() noexcept = default

data(data&&) noexcept = default

data(const data&) noexcept = delete

data &operator=(data&&) noexcept = delete

data &operator=(const data&) noexcept = delete

inline ~data() noexcept

Public Members

JSON_PRIVATE_UNLESS_TESTED __pad4__

json_value m_value = {}: the value of the current element

data m_data = {}

Public Static Functions

static inline allocator_type get_allocator()

returns the allocator associated with the container

static inline JSON_HEDLEY_WARN_UNUSED_RESULT basic_json meta ()

returns version information on the library

static inline JSON_PRIVATE_UNLESS_TESTED const_reference bool SAX bool sax_parse (InputType &&i, SAX *sax, input_format_t format=input_format_t::json, const bool strict=true, const bool ignore_comments=false)

template<class IteratorType, class SAX> static inline bool sax_parse(IteratorType first, IteratorType last, SAX *sax, input_format_t format = input_format_t::json, const bool strict = true, const bool ignore_comments = false)

generate SAX events

template<typename SAX> static inline bool sax_parse(detail::span_input_adapter &&i, SAX *sax, input_format_t format = input_format_t::json, const bool strict = true, const bool ignore_comments = false)

generate SAX events

Deprecated:: This function is deprecated since 3.8.0 and will be removed in version 4.0.0 of the library. Please use sax_parse(ptr, ptr + len) instead.

Friends

friend struct detail::external_constructor

friend class ::nlohmann::json_pointer

friend class ::nlohmann::detail::parser

friend class ::nlohmann::detail::iter_impl

friend class ::nlohmann::detail::binary_writer

friend class ::nlohmann::detail::binary_reader

friend class ::nlohmann::detail::json_sax_dom_parser

friend class ::nlohmann::detail::json_sax_dom_callback_parser

friend class ::nlohmann::detail::exception

inline friend std::istream &operator<<(basic_json &j, std::istream &i)

deserialize from stream

Deprecated:: This stream operator is deprecated since 3.0.0 and will be removed in version 4.0.0 of the library. Please use operator>>(std::istream&, basic_json&) instead; that is, replace calls like j << i; with i >> j;.

inline friend std::istream &operator>>(std::istream &i, basic_json &j)

deserialize from stream