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 ValueType value(const ::nlohmann::json_pointer<BasicJsonType> &ptr, const ValueType &default_value) const

template<class ValueType, class BasicJsonType, class ReturnType = typename value_return_type<ValueType>::type, detail::enable_if_t<detail::is_basic_json<BasicJsonType>::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 ::nlohmann::json_pointer<BasicJsonType> &ptr, ValueType &&default_value) const

inline reference front()

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

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 void clear() noexcept

clears the contents

inline void push_back(basic_json &&val)

add an object to an array

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

iterators

static inline iteration_proxy<iterator> iterator_wrapper(reference ref) noexcept

wrapper to access iterator member functions in range-based for

Deprecated:: This function is deprecated since 3.1.0 and will be removed in version 4.0.0 of the library. Please use items() instead; that is, replace json::iterator_wrapper(j) with j.items().

static inline iteration_proxy<const_iterator> iterator_wrapper(const_reference ref) noexcept

wrapper to access iterator member functions in range-based for

Deprecated:: This function is deprecated since 3.1.0 and will be removed in version 4.0.0 of the library. Please use items() instead; that is, replace json::iterator_wrapper(j) with j.items().

inline iterator begin() noexcept

returns an iterator to the first element

inline const_iterator begin() const noexcept

returns an iterator to the first element

inline const_iterator cbegin() const noexcept

returns a const iterator to the first element

inline iterator end() noexcept

returns an iterator to one past the last element

inline const_iterator end() const noexcept

returns an iterator to one past the last element

inline const_iterator cend() const noexcept

returns an iterator to one past the last element

inline reverse_iterator rbegin() noexcept

returns an iterator to the reverse-beginning

inline const_reverse_iterator rbegin() const noexcept

returns an iterator to the reverse-beginning

inline reverse_iterator rend() noexcept

returns an iterator to the reverse-end

inline const_reverse_iterator rend() const noexcept

returns an iterator to the reverse-end

inline const_reverse_iterator crbegin() const noexcept

returns a const reverse iterator to the last element

inline const_reverse_iterator crend() const noexcept

returns a const reverse iterator to one before the first

inline iteration_proxy<iterator> items() noexcept

helper to access iterator member functions in range-based for

inline iteration_proxy<const_iterator> items() const noexcept

helper to access iterator member functions in range-based for

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

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 void patch_inplace(const basic_json &json_patch)

applies a JSON patch in-place without copying the object

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

template<typename BasicJsonType, detail::enable_if_t<detail::is_basic_json<BasicJsonType>::value, int> = 0> inline bool contains(const typename ::nlohmann::json_pointer<BasicJsonType> &ptr) const

capacity

inline bool empty() const noexcept

checks whether the container is empty.

inline size_type size() const noexcept

returns the number of elements

inline size_type max_size() const noexcept

returns the maximum possible number of elements

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 reference operator[](const ::nlohmann::json_pointer<BasicJsonType> &ptr)

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 const_reference operator[](const ::nlohmann::json_pointer<BasicJsonType> &ptr) const

inline reference at(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 reference at(const ::nlohmann::json_pointer<BasicJsonType> &ptr)

inline const_reference at(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 const_reference at(const ::nlohmann::json_pointer<BasicJsonType> &ptr) const

inline basic_json flatten() const

return flattened JSON value

inline basic_json unflatten() const

unflatten a previously flattened JSON value

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