Template Class basic_json¶

Defined in File json.hpp

Nested Relationships¶

Nested Types¶

Inheritance Relationships¶

Base Type¶

public nlohmann::detail::json_base_class< CustomBaseClass >

Class Documentation¶

template<template<typename, typename, typename...> class ObjectType, template<typename, typename...> class ArrayType, class StringType, class BooleanType, class NumberIntegerType, class NumberUnsignedType, class NumberFloatType, template<typename> class AllocatorType, template<typename, typename = void> class JSONSerializer, class BinaryType, class CustomBaseClass> class basic_json : public nlohmann::detail::json_base_class<CustomBaseClass>¶

a class to store JSON values

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

inline friend bool operator==(const_reference lhs, const_reference rhs) noexcept¶

comparison: equal

template<typename ScalarType, typename std::enable_if<std::is_scalar<ScalarType>::value, int>::type = 0> inline friend bool operator==(const_reference lhs, ScalarType rhs) noexcept¶

comparison: equal

template<typename ScalarType, typename std::enable_if<std::is_scalar<ScalarType>::value, int>::type = 0> inline friend bool operator==(ScalarType lhs, const_reference rhs) noexcept¶

comparison: equal

inline friend bool operator!=(const_reference lhs, const_reference rhs) noexcept¶

comparison: not equal

template<typename ScalarType, typename std::enable_if<std::is_scalar<ScalarType>::value, int>::type = 0> inline friend bool operator!=(const_reference lhs, ScalarType rhs) noexcept¶

comparison: not equal

template<typename ScalarType, typename std::enable_if<std::is_scalar<ScalarType>::value, int>::type = 0> inline friend bool operator!=(ScalarType lhs, const_reference rhs) noexcept¶

comparison: not equal

inline friend bool operator<(const_reference lhs, const_reference rhs) noexcept¶

comparison: less than

template<typename ScalarType, typename std::enable_if<std::is_scalar<ScalarType>::value, int>::type = 0> inline friend bool operator<(const_reference lhs, ScalarType rhs) noexcept¶

comparison: less than

template<typename ScalarType, typename std::enable_if<std::is_scalar<ScalarType>::value, int>::type = 0> inline friend bool operator<(ScalarType lhs, const_reference rhs) noexcept¶

comparison: less than

inline friend bool operator<=(const_reference lhs, const_reference rhs) noexcept¶

comparison: less than or equal

template<typename ScalarType, typename std::enable_if<std::is_scalar<ScalarType>::value, int>::type = 0> inline friend bool operator<=(const_reference lhs, ScalarType rhs) noexcept¶

comparison: less than or equal

template<typename ScalarType, typename std::enable_if<std::is_scalar<ScalarType>::value, int>::type = 0> inline friend bool operator<=(ScalarType lhs, const_reference rhs) noexcept¶

comparison: less than or equal

inline friend bool operator>(const_reference lhs, const_reference rhs) noexcept¶

comparison: greater than

template<typename ScalarType, typename std::enable_if<std::is_scalar<ScalarType>::value, int>::type = 0> inline friend bool operator>(const_reference lhs, ScalarType rhs) noexcept¶

comparison: greater than

template<typename ScalarType, typename std::enable_if<std::is_scalar<ScalarType>::value, int>::type = 0> inline friend bool operator>(ScalarType lhs, const_reference rhs) noexcept¶

comparison: greater than

inline friend bool operator>=(const_reference lhs, const_reference rhs) noexcept¶

comparison: greater than or equal

template<typename ScalarType, typename std::enable_if<std::is_scalar<ScalarType>::value, int>::type = 0> inline friend bool operator>=(const_reference lhs, ScalarType rhs) noexcept¶

comparison: greater than or equal

template<typename ScalarType, typename std::enable_if<std::is_scalar<ScalarType>::value, int>::type = 0> inline friend bool operator>=(ScalarType lhs, const_reference rhs) noexcept¶

comparison: greater than or equal

serialization

inline friend std::ostream &operator<<(std::ostream &o, const basic_json &j)¶

serialize to stream

inline friend std::ostream &operator>>(const basic_json &j, std::ostream &o)¶

serialize to stream

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

deserialization

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

template<typename InputType> static inline basic_json parse(InputType &&i, const parser_callback_t cb = nullptr, const bool allow_exceptions = true, const bool ignore_comments = false)¶

deserialize from a compatible input

template<typename IteratorType> static inline basic_json parse(IteratorType first, IteratorType last, const parser_callback_t cb = nullptr, const bool allow_exceptions = true, const bool ignore_comments = false)¶

deserialize from a pair of character iterators

static inline basic_json parse(detail::span_input_adapter &&i, const parser_callback_t cb = nullptr, const bool allow_exceptions = true, const bool ignore_comments = false)¶

template<typename InputType> static inline bool accept(InputType &&i, const bool ignore_comments = false)¶

check if the input is valid JSON

template<typename IteratorType> static inline bool accept(IteratorType first, IteratorType last, const bool ignore_comments = false)¶

check if the input is valid JSON

static inline bool accept(detail::span_input_adapter &&i, const bool ignore_comments = false)¶

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

generate SAX events

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.

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 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 basic_json binary(const typename binary_t::container_type &init)¶

explicitly create a binary array (without subtype)

static inline 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 basic_json binary(typename binary_t::container_type &&init)¶

explicitly create a binary array

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

explicitly create a binary array (with subtype)

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

explicitly create an array from an initializer list

static inline 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 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 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 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 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 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 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 basic_json from_msgpack(const T *ptr, std::size_t len, const bool strict = true, const bool allow_exceptions = true)¶

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

template<typename InputType> static inline 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 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 basic_json from_ubjson(const T *ptr, std::size_t len, const bool strict = true, const bool allow_exceptions = true)¶

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

template<typename InputType> static inline 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 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 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 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 basic_json from_bson(const T *ptr, std::size_t len, const bool strict = true, const bool allow_exceptions = true)¶

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

JSON Patch functions

static inline 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 const char *type_name() const noexcept¶

return the type as string

Public Static Functions

static inline allocator_type get_allocator()¶

returns the allocator associated with the container

static inline basic_json meta()¶

returns version information on the library

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

Template Class basic_json¶

Nested Relationships¶

Nested Types¶

Inheritance Relationships¶

Base Type¶

Class Documentation¶

Table of Contents

Previous topic

Next topic

This Page