namespace for Niels Lohmann

See Also

https://github.com/nlohmann

namespace for Niels Lohmann

See Also

https://github.com/nlohmann

default specialization

Synopsis

using json = basic_json;

specialization that maintains the insertion order of object keys

Synopsis

using ordered_json = basic_json<ordered_map>;

default JSONSerializer template argument

Synopsis

template<
    typename T = void,
    typename SFINAE = void>
struct adl_serializer;

Description

This serializer ignores the template arguments and uses ADL(argument-dependent lookup)for serialization.

convert a JSON value to any value type

Synopses

convert a JSON value to any value type

template<
    typename BasicJsonType,
    typename TargetType = ValueType>
static
decltype(::nlohmann::from_json(std::forward<BasicJsonType>(j), detail::identity_tag<TargetType> {}))
from_json(BasicJsonType&& j) noexcept(noexcept(::nlohmann::from_json(std::forward<BasicJsonType>(j), detail::identity_tag<TargetType>{})));

convert a JSON value to any value type

template<
    typename BasicJsonType,
    typename TargetType = ValueType>
static
decltype(::nlohmann::from_json(std::forward<BasicJsonType>(j), val), void())
from_json(
    BasicJsonType&& j,
    TargetType& val) noexcept(noexcept(::nlohmann::from_json(std::forward<BasicJsonType>(j), val)));

convert a JSON value to any value type

Synopsis

template<
    typename BasicJsonType,
    typename TargetType = ValueType>
static
decltype(::nlohmann::from_json(std::forward<BasicJsonType>(j), detail::identity_tag<TargetType> {}))
from_json(BasicJsonType&& j) noexcept(noexcept(::nlohmann::from_json(std::forward<BasicJsonType>(j), detail::identity_tag<TargetType>{})));

convert a JSON value to any value type

Synopsis

template<
    typename BasicJsonType,
    typename TargetType = ValueType>
static
decltype(::nlohmann::from_json(std::forward<BasicJsonType>(j), val), void())
from_json(
    BasicJsonType&& j,
    TargetType& val) noexcept(noexcept(::nlohmann::from_json(std::forward<BasicJsonType>(j), val)));

convert any value type to a JSON value

Synopsis

template<
    typename BasicJsonType,
    typename TargetType = ValueType>
static
decltype(::nlohmann::to_json(j, std::forward<TargetType>(val)), void())
to_json(
    BasicJsonType& j,
    TargetType&& val) noexcept(noexcept(::nlohmann::to_json(j, std::forward<TargetType>(val))));

Synopsis

template<>
class basic_json<>
    : public nlohmann::detail::json_base_class<void>

Base Classes

Friends

the allocator type

Synopsis

using allocator_type = allocator<basic_json>;

a type for an array

Synopsis

using array_t = vector<basic_json, allocator<basic_json>>;

a type for a packed binary type

Synopsis

using binary_t = nlohmann::byte_container_with_subtype<vector<unsigned char>>;

how to encode BJData

Synopsis

using bjdata_version_t = detail::bjdata_version_t;

a type for a boolean

Synopsis

using boolean_t = bool;

how to treat CBOR tags

Synopsis

using cbor_tag_handler_t = detail::cbor_tag_handler_t;

a const iterator for a basic_json container

Synopsis

using const_iterator = iter_impl<basic_json const>;

the type of an element const pointer

Synopsis

using const_pointer = std::allocator_traits<allocator_type>::const_pointer;

the type of an element const reference

Synopsis

using const_reference = value_type const&;

a const reverse iterator for a basic_json container

Synopsis

using const_reverse_iterator = json_reverse_iterator<basic_json::const_iterator>;

Synopsis

using default_object_comparator_t = std::less;

a type to represent differences between iterators

Synopsis

using difference_type = std::ptrdiff_t;

how to treat decoding errors

Synopsis

using error_handler_t = detail::error_handler_t;

Classes to implement user-defined exceptions. @{

Synopsis

using exception = detail::exception;

helper type for initializer lists of basic_json values

Synopsis

using initializer_list_t = std::initializer_list<detail::json_ref<basic_json>>;

Synopsis

using input_format_t = detail::input_format_t;

Synopsis

using invalid_iterator = detail::invalid_iterator;

an iterator for a basic_json container

Synopsis

using iterator = iter_impl<basic_json>;

JSON Pointer, see nlohmann::json_pointer

Synopsis

using json_pointer = nlohmann::json_pointer<basic_string<char>>;

SAX interface type, see nlohmann::json_sax

Synopsis

using json_sax_t = json_sax<basic_json>;

Synopsis

template<
    typename T,
    typename SFINAE>
using json_serializer = adl_serializer<T, SFINAE>;

a type for a number (floating-point)

Synopsis

using number_float_t = double;

a type for a number (integer)

Synopsis

using number_integer_t = long long;

a type for a number (unsigned)

Synopsis

using number_unsigned_t = unsigned long long;

object key comparator type

Synopsis

using object_comparator_t = detail::actual_object_comparator_t<basic_json>;

a type for an object

Synopsis

using object_t = map<basic_string<char>, basic_json, default_object_comparator_t, allocator<std::pair<basic_string<char> const, basic_json>>>;

Synopsis

using other_error = detail::other_error;

Synopsis

using out_of_range = detail::out_of_range;

Synopsis

using parse_error = detail::parse_error;

parser event types

Synopsis

using parse_event_t = detail::parse_event_t;

per-element parser callback type

Synopsis

using parser_callback_t = detail::parser_callback_t<basic_json>;

the type of an element pointer

Synopsis

using pointer = std::allocator_traits<allocator_type>::pointer;

the type of an element reference

Synopsis

using reference = value_type&;

a reverse iterator for a basic_json container

Synopsis

using reverse_iterator = json_reverse_iterator<basic_json::iterator>;

a type to represent container sizes

Synopsis

using size_type = std::size_t;

a type for a string

Synopsis

using string_t = basic_string<char>;

Synopsis

using type_error = detail::type_error;

Synopsis

using value_t = detail::value_t;

the type of elements in a basic_json container

Synopsis

using value_type = basic_json;

Construct from nullptr_t

Synopsis

basic_json(std::nullptr_t value = nullptr) noexcept;

Parameters

Construct from value_t

Synopsis

basic_json(value_t const v);

Parameters

Construct from basic_json

Synopsis

basic_json(basic_json const& other);

Parameters

Construct from basic_json

Synopsis

basic_json(basic_json&& other) noexcept;

Parameters

create a JSON value from an existing one

Synopsis

template<typename BasicJsonType>
requires detail::is_basic_json<BasicJsonType>::value&& !std::is_same<basic_json, BasicJsonType>::value
basic_json(BasicJsonType const& val);

Parameters

////////////////////////////////////

Synopsis

template<typename JsonRef>
requires detail::conjunction<detail::is_json_ref<JsonRef>,
                                 std::is_same<typename JsonRef::value_type, basic_json>>::value
basic_json(JsonRef const& ref);

Parameters

create a JSON value from compatible types

Synopsis

template<
    typename CompatibleType,
    typename U = detail::uncvref_t<CompatibleType>>
requires !detail::is_basic_json<U>::value && detail::is_compatible_type<basic_json_t, U>::value
basic_json(CompatibleType&& val) noexcept(noexcept(JSONSerializer<U, void>::to_json(std::declval<basic_json_t &>(), std::forward<CompatibleType>(val))));

Parameters

Constructor

Synopsis

basic_json(
    size_type cnt,
    basic_json const& val);

Parameters

construct a JSON container given an iterator range

Synopsis

template<class InputIT>
requires std::is_same<InputIT, typename basic_json_t::iterator>::value ||
                   std::is_same<InputIT, typename basic_json_t::const_iterator>::value
basic_json(
    InputIT first,
    InputIT last);

Parameters

Synopsis

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

Destructor

Synopsis

~basic_json() noexcept;

Assignment operator

Synopsis

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);

Return Value

Parameters

Synopsis

reference
at(size_type idx);

Synopsis

const_reference
at(size_type idx) const;

Synopsis

reference
at(json_pointer const& ptr);

Synopsis

const_reference
at(json_pointer const& ptr) const;

Synopsis

reference
at(object_t::key_type const& key);

Synopsis

const_reference
at(object_t::key_type const& key) const;

Synopsis

template<typename BasicJsonType>
requires detail::is_basic_json<BasicJsonType>::value
[[__deprecated__]]
reference
at(nlohmann::json_pointer<BasicJsonType> const& ptr);

Synopsis

template<typename BasicJsonType>
requires detail::is_basic_json<BasicJsonType>::value
[[__deprecated__]]
const_reference
at(nlohmann::json_pointer<BasicJsonType> const& ptr) const;

access specified object element with bounds checking

Synopsis

template<class KeyType>
requires detail::is_usable_as_basic_json_key_type<basic_json_t, KeyType>::value
reference
at(KeyType&& key);

Return Value

access specified object element with bounds checking

Synopsis

template<class KeyType>
requires detail::is_usable_as_basic_json_key_type<basic_json_t, KeyType>::value
const_reference
at(KeyType&& key) const;

Return Value

Synopsis

reference
back();

Synopsis

const_reference
back() const;

Synopsis

iterator
begin() noexcept;

Synopsis

const_iterator
begin() const noexcept;

Synopsis

const_iterator
cbegin() const noexcept;

Synopsis

const_iterator
cend() const noexcept;

Synopsis

void
clear() noexcept;

Synopsis

bool
contains(json_pointer const& ptr) const;

Synopsis

bool
contains(object_t::key_type const& key) const;

Synopsis

template<typename BasicJsonType>
requires detail::is_basic_json<BasicJsonType>::value
[[__deprecated__]]
bool
contains(nlohmann::json_pointer<BasicJsonType> const& ptr) const;

check the existence of an element in a JSON object

Synopsis

template<class KeyType>
requires detail::is_usable_as_basic_json_key_type<basic_json_t, KeyType>::value
bool
contains(KeyType&& key) const;

Synopsis

size_type
count(object_t::key_type const& key) const;

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

Synopsis

template<class KeyType>
requires detail::is_usable_as_basic_json_key_type<basic_json_t, KeyType>::value
size_type
count(KeyType&& key) const;

Return Value

Synopsis

const_reverse_iterator
crbegin() const noexcept;

Synopsis

const_reverse_iterator
crend() const noexcept;

Synopsis

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

add an object to an object if key does not exist

Synopsis

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

add an object to an array

Synopsis

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

Return Value

Synopsis

bool
empty() const noexcept;

Synopsis

iterator
end() noexcept;

Synopsis

const_iterator
end() const noexcept;

Synopsis

void
erase(size_type const idx);

Synopsis

size_type
erase(object_t::key_type const& key);

remove element given an iterator

Synopsis

template<class IteratorType>
requires std::is_same<IteratorType, typename basic_json_t::iterator>::value ||
                   std::is_same<IteratorType, typename basic_json_t::const_iterator>::value
IteratorType
erase(IteratorType pos);

remove element from a JSON object given a key

Synopsis

template<class KeyType>
requires detail::is_usable_as_basic_json_key_type<basic_json_t, KeyType>::value
size_type
erase(KeyType&& key);

Return Value

remove elements given an iterator range

Synopsis

template<class IteratorType>
requires std::is_same<IteratorType, typename basic_json_t::iterator>::value ||
                   std::is_same<IteratorType, typename basic_json_t::const_iterator>::value
IteratorType
erase(
    IteratorType first,
    IteratorType last);

Synopsis

iterator
find(object_t::key_type const& key);

Synopsis

const_iterator
find(object_t::key_type const& key) const;

find an element in a JSON object

Synopsis

template<class KeyType>
requires detail::is_usable_as_basic_json_key_type<basic_json_t, KeyType>::value
iterator
find(KeyType&& key);

Return Value

find an element in a JSON object

Synopsis

template<class KeyType>
requires detail::is_usable_as_basic_json_key_type<basic_json_t, KeyType>::value
const_iterator
find(KeyType&& key) const;

Return Value

Synopsis

basic_json
flatten() const;

Synopsis

reference
front();

Synopsis

const_reference
front() const;

get a pointer value (explicit)

Synopsis

template<typename PointerType>
requires std::is_pointer<PointerType>::value
decltype(std::declval<basic_json_t&>().template get_ptr<PointerType>())
get() noexcept;

Description

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

Constant.

{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}

Return Value

Template Parameters

get a (pointer) value (explicit)

Synopsis

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

Description

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.

Exceptions

Return Value

Template Parameters

Synopsis

binary_t&
get_binary();

Synopsis

binary_t const&
get_binary() const;

get a pointer value (implicit)

Synopsis

template<typename PointerType>
requires std::is_pointer<PointerType>::value
decltype(std::declval<basic_json_t&>().get_impl_ptr(std::declval<PointerType>()))
get_ptr() noexcept;

get a pointer value (implicit)

Synopsis

template<typename PointerType>
requires std::is_pointer<PointerType>::value&&
                   std::is_const<typename std::remove_pointer<PointerType>::type>::value
constexpr
decltype(std::declval<const basic_json_t&>().get_impl_ptr(std::declval<PointerType>()))
get_ptr() const noexcept;

get a reference value (implicit)

Synopsis

template<typename ReferenceType>
requires std::is_reference<ReferenceType>::value
ReferenceType
get_ref();

get a reference value (implicit)

Synopsis

template<typename ReferenceType>
requires std::is_reference<ReferenceType>::value&&
                   std::is_const<typename std::remove_reference<ReferenceType>::type>::value
ReferenceType
get_ref() const;

get a value (explicit)

Synopsis

template<typename ValueType>
requires !detail::is_basic_json<ValueType>::value&&
                   detail::has_from_json<basic_json_t, ValueType>::value
ValueType&
get_to(ValueType& v) const noexcept(noexcept(JSONSerializer<ValueType, void>::from_json(std::declval<const basic_json_t &>(), v)));

Synopsis

template<typename ValueType>
requires detail::is_basic_json<ValueType>::value
ValueType&
get_to(ValueType& v) const;

Synopsis

template<
    typename T,
    std::size_t N,
    typename Array = T(&)[]>
requires detail::has_from_json<basic_json_t, Array>::value
Array
get_to(T(& v)[]) const noexcept(noexcept(JSONSerializer<Array, void>::from_json(std::declval<const basic_json_t &>(), v)));

Synopsis

void
insert(
    const_iterator first,
    const_iterator last);

Synopsis

iterator
insert(
    const_iterator pos,
    initializer_list_t ilist);

Synopsis

iterator
insert(
    const_iterator pos,
    basic_json const& val);

Synopsis

iterator
insert(
    const_iterator pos,
    basic_json&& val);

Synopsis

iterator
insert(
    const_iterator pos,
    const_iterator first,
    const_iterator last);

Synopsis

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

Helper for insertion of an iterator

Synopsis

template<typename... Args>
iterator
insert_iterator(
    const_iterator pos,
    Args...&&... args);

Description

Return Value

Parameters

Synopsis

constexpr
bool
is_array() const noexcept;

Synopsis

constexpr
bool
is_binary() const noexcept;

Synopsis

constexpr
bool
is_boolean() const noexcept;

Synopsis

constexpr
bool
is_discarded() const noexcept;

Synopsis

constexpr
bool
is_null() const noexcept;

Synopsis

constexpr
bool
is_number() const noexcept;

Synopsis

constexpr
bool
is_number_float() const noexcept;

Synopsis

constexpr
bool
is_number_integer() const noexcept;

Synopsis

constexpr
bool
is_number_unsigned() const noexcept;

Synopsis

constexpr
bool
is_object() const noexcept;

Synopsis

constexpr
bool
is_primitive() const noexcept;

Synopsis

constexpr
bool
is_string() const noexcept;

Synopsis

constexpr
bool
is_structured() const noexcept;

Synopsis

iteration_proxy<iterator>
items() noexcept;

Synopsis

iteration_proxy<const_iterator>
items() const noexcept;

Synopsis

size_type
max_size() const noexcept;

Synopsis

void
merge_patch(basic_json const& apply_patch);

Addition assignment operator

Synopsis

reference
operator+=(initializer_list_t init);

Return Value

Parameters

Addition assignment operator

Synopsis

reference
operator+=(object_t::value_type const& val);

Return Value

Parameters

Addition assignment operator

Synopsis

reference
operator+=(basic_json const& val);

Return Value

Parameters

Addition assignment operator

Synopsis

reference
operator+=(basic_json&& val);

Return Value

Parameters

Subscript operator

Synopsis

reference
operator[](object_t::key_type key);

Return Value

Parameters

Subscript operator

Synopsis

reference
operator[](size_type idx);

Return Value

Parameters

Subscript operator

Synopsis

const_reference
operator[](size_type idx) const;

Return Value

Parameters

Subscript operator

Synopsis

reference
operator[](json_pointer const& ptr);

Return Value

Parameters

Subscript operator

Synopsis

const_reference
operator[](json_pointer const& ptr) const;

Return Value

Parameters

Subscript operator

Synopsis

const_reference
operator[](object_t::key_type const& key) const;

Return Value

Parameters

Subscript operator

Synopsis

template<typename BasicJsonType>
requires detail::is_basic_json<BasicJsonType>::value
[[__deprecated__]]
reference
operator[](nlohmann::json_pointer<BasicJsonType> const& ptr);

Return Value

Parameters

Subscript operator

Synopsis

template<typename BasicJsonType>
requires detail::is_basic_json<BasicJsonType>::value
[[__deprecated__]]
const_reference
operator[](nlohmann::json_pointer<BasicJsonType> const& ptr) const;

Return Value

Parameters

access specified object element

Synopsis

template<class KeyType>
requires detail::is_usable_as_basic_json_key_type<basic_json_t, KeyType>::value
reference
operator[](KeyType&& key);

Return Value

Parameters

access specified object element

Synopsis

template<class KeyType>
requires detail::is_usable_as_basic_json_key_type<basic_json_t, KeyType>::value
const_reference
operator[](KeyType&& key) const;

Return Value

Parameters

Subscript operator

Synopsis

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

Return Value

Parameters

Subscript operator

Synopsis

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

Return Value

Parameters

Synopsis

basic_json
patch(basic_json const& json_patch) const;

Synopsis

void
patch_inplace(basic_json const& json_patch);

Synopsis

void
push_back(initializer_list_t init);

Synopsis

void
push_back(object_t::value_type const& val);

Synopsis

void
push_back(basic_json const& val);

Synopsis

void
push_back(basic_json&& val);

Synopsis

reverse_iterator
rbegin() noexcept;

Synopsis

const_reverse_iterator
rbegin() const noexcept;

Synopsis

reverse_iterator
rend() noexcept;

Synopsis

const_reverse_iterator
rend() const noexcept;

Synopsis

size_type
size() const noexcept;

Synopsis

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 && std::is_nothrow_move_assignable<json_value>::value);

Synopsis

void
swap(array_t& other);

Synopsis

void
swap(binary_t& other);

Synopsis

void
swap(binary_t::container_type& other);

Synopsis

void
swap(object_t& other);

Synopsis

void
swap(string_t& other);

Synopsis

constexpr
value_t
type() const noexcept;

Synopsis

[[__returns_nonnull__]]
char const*
type_name() const noexcept;

Synopsis

basic_json
unflatten() const;

Synopsis

void
update(
    const_reference j,
    bool merge_objects = false);

Synopsis

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

access specified object element via JSON Pointer with default value

Synopsis

template<class ValueType>
requires detail::is_getable<basic_json_t, ValueType>::value
                   && !std::is_same<value_t, detail::uncvref_t<ValueType>>::value
ValueType
value(
    json_pointer const& ptr,
    ValueType const& default_value) const;

Parameters

access specified object element with default value

Synopsis

template<class ValueType>
requires !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
ValueType
value(
    object_t::key_type const& key,
    ValueType const& default_value) const;

access specified object element via JSON Pointer with default value

Synopsis

template<
    class ValueType,
    class ReturnType = value_return_type<ValueType>::type>
requires detail::is_getable<basic_json_t, ReturnType>::value
                   && !std::is_same<value_t, detail::uncvref_t<ValueType>>::value
ReturnType
value(
    json_pointer const& ptr,
    ValueType&& default_value) const;

Parameters

access specified object element with default value

Synopsis

template<
    class ValueType,
    class ReturnType = value_return_type<ValueType>::type>
requires !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
ReturnType
value(
    object_t::key_type const& key,
    ValueType&& default_value) const;

Synopsis

template<
    class ValueType,
    class BasicJsonType>
requires detail::is_basic_json<BasicJsonType>::value
                   && detail::is_getable<basic_json_t, ValueType>::value
                   && !std::is_same<value_t, detail::uncvref_t<ValueType>>::value
[[__deprecated__]]
ValueType
value(
    nlohmann::json_pointer<BasicJsonType> const& ptr,
    ValueType const& default_value) const;

access specified object element with default value

Synopsis

template<
    class ValueType,
    class KeyType>
requires 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
ValueType
value(
    KeyType&& key,
    ValueType const& default_value) const;

Synopsis

template<
    class ValueType,
    class BasicJsonType,
    class ReturnType = value_return_type<ValueType>::type>
requires detail::is_basic_json<BasicJsonType>::value
                   && detail::is_getable<basic_json_t, ReturnType>::value
                   && !std::is_same<value_t, detail::uncvref_t<ValueType>>::value
[[__deprecated__]]
ReturnType
value(
    nlohmann::json_pointer<BasicJsonType> const& ptr,
    ValueType&& default_value) const;

access specified object element via JSON Pointer with default value

Synopsis

template<
    class ValueType,
    class KeyType,
    class ReturnType = value_return_type<ValueType>::type>
requires 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
ReturnType
value(
    KeyType&& key,
    ValueType&& default_value) const;

get a value (implicit)

Synopsis

template<typename ValueType>
requires 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>>>,
#if defined(JSON_HAS_CPP_17) && (defined(__GNUC__) || (defined(_MSC_VER) && _MSC_VER >= 1910 && _MSC_VER <= 1914))
                                                detail::negation<std::is_same<ValueType, std::string_view>>,
#endif
#if defined(JSON_HAS_CPP_17) && JSON_HAS_STATIC_RTTI
                                                detail::negation<std::is_same<ValueType, std::any>>,
#endif
                                                detail::is_detected_lazy<detail::get_template_function, const basic_json_t&, ValueType>
                                                >::value
operator ValueType() const;

Description

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

Linear in the size of the JSON value.

{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}

Exceptions

Return Value

Template Parameters

Conversion to value_t

Synopsis

constexpr
operator value_t() const noexcept;

Return Value

comparison: equal

Synopsis

template<typename ScalarType>
requires std::is_scalar_v<ScalarType>
bool
operator==(ScalarType rhs) const noexcept;

Return Value

Parameters

Equality operator

Synopsis

bool
operator==(const_reference rhs) const noexcept;

Return Value

Parameters

Inequality operator

Synopsis

bool
operator!=(const_reference rhs) const noexcept;

Return Value

Parameters

comparison: 3-way

Synopsis

template<typename ScalarType>
requires std::is_scalar_v<ScalarType>
std::partial_ordering
operator<=>(ScalarType rhs) const noexcept;

Return Value

Parameters

Three-way comparison operator

Synopsis

std::partial_ordering
operator<=>(const_reference rhs) const noexcept;

Return Value

Parameters

Synopsis

[[__warn_unused_result__, __deprecated__]]
static
bool
accept(
    detail::span_input_adapter&& i,
    bool const ignore_comments = false,
    bool const ignore_trailing_commas = false);

check if the input is valid JSON

Synopsis

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

check if the input is valid JSON

Synopsis

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

Synopsis

[[__warn_unused_result__]]
static
basic_json
array(initializer_list_t init = {});

Synopsis

[[__warn_unused_result__]]
static
basic_json
binary(binary_t::container_type const& init);

Synopsis

[[__warn_unused_result__]]
static
basic_json
binary(binary_t::container_type&& init);

Synopsis

[[__warn_unused_result__]]
static
basic_json
binary(
    binary_t::container_type const& init,
    binary_t::subtype_type subtype);

Synopsis

[[__warn_unused_result__]]
static
basic_json
binary(
    binary_t::container_type&& init,
    binary_t::subtype_type subtype);

Synopsis

[[__warn_unused_result__]]
static
basic_json
diff(
    basic_json const& source,
    basic_json const& target,
    string_t const& path = "");

create a JSON value from an input in BJData format

Synopsis

template<typename InputType>
[[__warn_unused_result__]]
static
basic_json
from_bjdata(
    InputType&& i,
    bool const strict = true,
    bool const allow_exceptions = true);

Return Value

create a JSON value from an input in BJData format

Synopsis

template<typename IteratorType>
[[__warn_unused_result__]]
static
basic_json
from_bjdata(
    IteratorType first,
    IteratorType last,
    bool const strict = true,
    bool const allow_exceptions = true);

Return Value

Synopsis

[[__warn_unused_result__, __deprecated__]]
static
basic_json
from_bson(
    detail::span_input_adapter&& i,
    bool const strict = true,
    bool const allow_exceptions = true);

create a JSON value from an input in BSON format

Synopsis

template<typename InputType>
[[__warn_unused_result__]]
static
basic_json
from_bson(
    InputType&& i,
    bool const strict = true,
    bool const allow_exceptions = true);

Return Value

create a JSON value from an input in BSON format

Synopsis

template<typename IteratorType>
[[__warn_unused_result__]]
static
basic_json
from_bson(
    IteratorType first,
    IteratorType last,
    bool const strict = true,
    bool const allow_exceptions = true);

Return Value

Synopsis

template<typename T>
[[__warn_unused_result__, __deprecated__]]
static
basic_json
from_bson(
    T const* ptr,
    std::size_t len,
    bool const strict = true,
    bool const allow_exceptions = true);

Synopsis

[[__warn_unused_result__, __deprecated__]]
static
basic_json
from_cbor(
    detail::span_input_adapter&& i,
    bool const strict = true,
    bool const allow_exceptions = true,
    cbor_tag_handler_t const tag_handler = cbor_tag_handler_t::error);

create a JSON value from an input in CBOR format

Synopsis

template<typename InputType>
[[__warn_unused_result__]]
static
basic_json
from_cbor(
    InputType&& i,
    bool const strict = true,
    bool const allow_exceptions = true,
    cbor_tag_handler_t const tag_handler = cbor_tag_handler_t::error);

Return Value

Parameters

create a JSON value from an input in CBOR format

Synopsis

template<typename IteratorType>
[[__warn_unused_result__]]
static
basic_json
from_cbor(
    IteratorType first,
    IteratorType last,
    bool const strict = true,
    bool const allow_exceptions = true,
    cbor_tag_handler_t const tag_handler = cbor_tag_handler_t::error);

Return Value

Parameters

Synopsis

template<typename T>
[[__warn_unused_result__, __deprecated__]]
static
basic_json
from_cbor(
    T const* ptr,
    std::size_t len,
    bool const strict = true,
    bool const allow_exceptions = true,
    cbor_tag_handler_t const tag_handler = cbor_tag_handler_t::error);

Synopsis

[[__warn_unused_result__, __deprecated__]]
static
basic_json
from_msgpack(
    detail::span_input_adapter&& i,
    bool const strict = true,
    bool const allow_exceptions = true);

create a JSON value from an input in MessagePack format

Synopsis

template<typename InputType>
[[__warn_unused_result__]]
static
basic_json
from_msgpack(
    InputType&& i,
    bool const strict = true,
    bool const allow_exceptions = true);

Return Value

create a JSON value from an input in MessagePack format

Synopsis

template<typename IteratorType>
[[__warn_unused_result__]]
static
basic_json
from_msgpack(
    IteratorType first,
    IteratorType last,
    bool const strict = true,
    bool const allow_exceptions = true);

Return Value

Synopsis

template<typename T>
[[__warn_unused_result__, __deprecated__]]
static
basic_json
from_msgpack(
    T const* ptr,
    std::size_t len,
    bool const strict = true,
    bool const allow_exceptions = true);

Synopsis

[[__warn_unused_result__, __deprecated__]]
static
basic_json
from_ubjson(
    detail::span_input_adapter&& i,
    bool const strict = true,
    bool const allow_exceptions = true);

create a JSON value from an input in UBJSON format

Synopsis

template<typename InputType>
[[__warn_unused_result__]]
static
basic_json
from_ubjson(
    InputType&& i,
    bool const strict = true,
    bool const allow_exceptions = true);

Return Value

create a JSON value from an input in UBJSON format

Synopsis

template<typename IteratorType>
[[__warn_unused_result__]]
static
basic_json
from_ubjson(
    IteratorType first,
    IteratorType last,
    bool const strict = true,
    bool const allow_exceptions = true);

Return Value

Synopsis

template<typename T>
[[__warn_unused_result__, __deprecated__]]
static
basic_json
from_ubjson(
    T const* ptr,
    std::size_t len,
    bool const strict = true,
    bool const allow_exceptions = true);

Synopsis

static
allocator_type
get_allocator();

Synopsis

[[__deprecated__]]
static
iteration_proxy<const_iterator>
iterator_wrapper(const_reference ref) noexcept;

Synopsis

[[__deprecated__]]
static
iteration_proxy<iterator>
iterator_wrapper(reference ref) noexcept;

Synopsis

[[__warn_unused_result__]]
static
basic_json
meta();

Synopsis

[[__warn_unused_result__]]
static
basic_json
object(initializer_list_t init = {});

Synopsis

[[__warn_unused_result__, __deprecated__]]
static
basic_json
parse(
    detail::span_input_adapter&& i,
    parser_callback_t cb = nullptr,
    bool const allow_exceptions = true,
    bool const ignore_comments = false,
    bool const ignore_trailing_commas = false);

deserialize from a compatible input

Synopsis

template<typename InputType>
[[__warn_unused_result__]]
static
basic_json
parse(
    InputType&& i,
    parser_callback_t cb = nullptr,
    bool const allow_exceptions = true,
    bool const ignore_comments = false,
    bool const ignore_trailing_commas = false);

Return Value

Parameters

deserialize from a pair of character iterators

Synopsis

template<typename IteratorType>
[[__warn_unused_result__]]
static
basic_json
parse(
    IteratorType first,
    IteratorType last,
    parser_callback_t cb = nullptr,
    bool const allow_exceptions = true,
    bool const ignore_comments = false,
    bool const ignore_trailing_commas = false);

Return Value

Parameters

generate SAX events

Synopsis

template<typename SAX>
[[__deprecated__, __nonnull__]]
static
bool
sax_parse(
    detail::span_input_adapter&& i,
    SAX* sax,
    input_format_t format = input_format_t::json,
    bool const strict = true,
    bool const ignore_comments = false,
    bool const ignore_trailing_commas = false);

generate SAX events

Synopsis

template<
    typename InputType,
    typename SAX>
[[__nonnull__]]
static
bool
sax_parse(
    InputType&& i,
    SAX* sax,
    input_format_t format = input_format_t::json,
    bool const strict = true,
    bool const ignore_comments = false,
    bool const ignore_trailing_commas = false);

generate SAX events

Synopsis

template<
    class IteratorType,
    class SAX>
[[__nonnull__]]
static
bool
sax_parse(
    IteratorType first,
    IteratorType last,
    SAX* sax,
    input_format_t format = input_format_t::json,
    bool const strict = true,
    bool const ignore_comments = false,
    bool const ignore_trailing_commas = false);

Synopsis

static
std::vector<uint8_t>
to_bjdata(
    basic_json const& j,
    bool const use_size = false,
    bool const use_type = false,
    bjdata_version_t const version = bjdata_version_t::draft2);

Synopsis

static
void
to_bjdata(
    basic_json const& j,
    detail::output_adapter<uint8_t> o,
    bool const use_size = false,
    bool const use_type = false,
    bjdata_version_t const version = bjdata_version_t::draft2);

Synopsis

static
void
to_bjdata(
    basic_json const& j,
    detail::output_adapter<char> o,
    bool const use_size = false,
    bool const use_type = false,
    bjdata_version_t const version = bjdata_version_t::draft2);

Synopsis

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

Synopsis

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

Synopsis

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

Synopsis

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

Synopsis

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

Synopsis

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

Synopsis

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

Synopsis

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

Synopsis

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

Synopsis

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

Synopsis

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

Synopsis

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

a class to store JSON values

Synopsis

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

Base Classes

Friends

Non-Member Functions

Description

a class to store JSON values

the allocator type

Synopsis

using allocator_type = AllocatorType<basic_json>;

a type for an array

Synopsis

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

a type for a packed binary type

Synopsis

using binary_t = nlohmann::byte_container_with_subtype<BinaryType>;

how to encode BJData

Synopsis

using bjdata_version_t = detail::bjdata_version_t;

a type for a boolean

Synopsis

using boolean_t = BooleanType;

how to treat CBOR tags

Synopsis

using cbor_tag_handler_t = detail::cbor_tag_handler_t;

a const iterator for a basic_json container

Synopsis

using const_iterator = iter_impl<basic_json const>;

the type of an element const pointer

Synopsis

using const_pointer = std::allocator_traits<allocator_type>::const_pointer;

the type of an element const reference

Synopsis

using const_reference = value_type const&;

a const reverse iterator for a basic_json container

Synopsis

using const_reverse_iterator = json_reverse_iterator<basic_json::const_iterator>;

Synopsis

using default_object_comparator_t = std::less;

a type to represent differences between iterators

Synopsis

using difference_type = std::ptrdiff_t;

how to treat decoding errors

Synopsis

using error_handler_t = detail::error_handler_t;

Classes to implement user-defined exceptions. @{

Synopsis

using exception = detail::exception;

helper type for initializer lists of basic_json values

Synopsis

using initializer_list_t = std::initializer_list<detail::json_ref<basic_json>>;

Synopsis

using input_format_t = detail::input_format_t;

Synopsis

using invalid_iterator = detail::invalid_iterator;

an iterator for a basic_json container

Synopsis

using iterator = iter_impl<basic_json>;

JSON Pointer, see nlohmann::json_pointer

Synopsis

using json_pointer = nlohmann::json_pointer<StringType>;

SAX interface type, see nlohmann::json_sax

Synopsis

using json_sax_t = json_sax<basic_json>;

Synopsis

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

a type for a number (floating-point)

Synopsis

using number_float_t = NumberFloatType;

a type for a number (integer)

Synopsis

using number_integer_t = NumberIntegerType;

a type for a number (unsigned)

Synopsis

using number_unsigned_t = NumberUnsignedType;

object key comparator type

Synopsis

using object_comparator_t = detail::actual_object_comparator_t<basic_json>;

a type for an object

Synopsis

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

Synopsis

using other_error = detail::other_error;

Synopsis

using out_of_range = detail::out_of_range;

Synopsis

using parse_error = detail::parse_error;

parser event types

Synopsis

using parse_event_t = detail::parse_event_t;

per-element parser callback type

Synopsis

using parser_callback_t = detail::parser_callback_t<basic_json>;

the type of an element pointer

Synopsis

using pointer = std::allocator_traits<allocator_type>::pointer;

the type of an element reference

Synopsis

using reference = value_type&;

a reverse iterator for a basic_json container

Synopsis

using reverse_iterator = json_reverse_iterator<basic_json::iterator>;

a type to represent container sizes

Synopsis

using size_type = std::size_t;

a type for a string

Synopsis

using string_t = StringType;

Synopsis

using type_error = detail::type_error;

Synopsis

using value_t = detail::value_t;

the type of elements in a basic_json container

Synopsis

using value_type = basic_json;

copy constructor

Synopsis

basic_json(basic_json const& other);

Parameters

move constructor

Synopsis

basic_json(basic_json&& other) noexcept;

Parameters

create a null object

Synopsis

basic_json(std::nullptr_t value = nullptr) noexcept;

Parameters

create an empty value with a given type

Synopsis

basic_json(value_t const v);

Parameters

create a JSON value from an existing one

Synopsis

template<typename BasicJsonType>
requires detail::is_basic_json<BasicJsonType>::value&& !std::is_same<basic_json, BasicJsonType>::value
basic_json(BasicJsonType const& val);

Parameters

////////////////////////////////////

Synopsis

template<typename JsonRef>
requires detail::conjunction<detail::is_json_ref<JsonRef>,
                                 std::is_same<typename JsonRef::value_type, basic_json>>::value
basic_json(JsonRef const& ref);

Parameters

create a JSON value from compatible types

Synopsis

template<
    typename CompatibleType,
    typename U = detail::uncvref_t<CompatibleType>>
requires !detail::is_basic_json<U>::value && detail::is_compatible_type<basic_json_t, U>::value
basic_json(CompatibleType&& val) noexcept(noexcept(JSONSerializer<U, void>::to_json(std::declval<basic_json_t &>(), std::forward<CompatibleType>(val))));

Parameters

construct an array with count copies of given value

Synopsis

basic_json(
    size_type cnt,
    basic_json const& val);

Parameters

construct a JSON container given an iterator range

Synopsis

template<class InputIT>
requires std::is_same<InputIT, typename basic_json_t::iterator>::value ||
                   std::is_same<InputIT, typename basic_json_t::const_iterator>::value
basic_json(
    InputIT first,
    InputIT last);

Parameters

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

Synopsis

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

Parameters

destructor

Synopsis

~basic_json() noexcept;

copy assignment

Synopsis

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);

Return Value

Parameters

access specified array element with bounds checking

Synopsis

reference
at(size_type idx);

Return Value

Parameters

access specified array element with bounds checking

Synopsis

const_reference
at(size_type idx) const;

Return Value

Parameters

access specified element via JSON Pointer

Synopsis

reference
at(json_pointer const& ptr);

Return Value

Parameters

access specified element via JSON Pointer

Synopsis

const_reference
at(json_pointer const& ptr) const;

Return Value

Parameters

access specified object element with bounds checking

Synopsis

reference
at(object_t::key_type const& key);

Return Value

access specified object element with bounds checking

Synopsis

const_reference
at(object_t::key_type const& key) const;

Return Value

Synopsis

template<typename BasicJsonType>
requires detail::is_basic_json<BasicJsonType>::value
[[__deprecated__]]
reference
at(nlohmann::json_pointer<BasicJsonType> const& ptr);

Synopsis

template<typename BasicJsonType>
requires detail::is_basic_json<BasicJsonType>::value
[[__deprecated__]]
const_reference
at(nlohmann::json_pointer<BasicJsonType> const& ptr) const;

access specified object element with bounds checking

Synopsis

template<class KeyType>
requires detail::is_usable_as_basic_json_key_type<basic_json_t, KeyType>::value
reference
at(KeyType&& key);

Return Value

access specified object element with bounds checking

Synopsis

template<class KeyType>
requires detail::is_usable_as_basic_json_key_type<basic_json_t, KeyType>::value
const_reference
at(KeyType&& key) const;

Return Value

access the last element

Synopsis

reference
back();

Return Value

access the last element

Synopsis

const_reference
back() const;

Return Value

returns an iterator to the first element

Synopsis

iterator
begin() noexcept;

Return Value

returns an iterator to the first element

Synopsis

const_iterator
begin() const noexcept;

Return Value

returns a const iterator to the first element

Synopsis

const_iterator
cbegin() const noexcept;

Return Value

returns an iterator to one past the last element

Synopsis

const_iterator
cend() const noexcept;

Return Value

clears the contents

Synopsis

void
clear() noexcept;

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

Synopsis

bool
contains(json_pointer const& ptr) const;

Parameters

check the existence of an element in a JSON object

Synopsis

bool
contains(object_t::key_type const& key) const;

Synopsis

template<typename BasicJsonType>
requires detail::is_basic_json<BasicJsonType>::value
[[__deprecated__]]
bool
contains(nlohmann::json_pointer<BasicJsonType> const& ptr) const;

check the existence of an element in a JSON object

Synopsis

template<class KeyType>
requires detail::is_usable_as_basic_json_key_type<basic_json_t, KeyType>::value
bool
contains(KeyType&& key) const;

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

Synopsis

size_type
count(object_t::key_type const& key) const;

Return Value

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

Synopsis

template<class KeyType>
requires detail::is_usable_as_basic_json_key_type<basic_json_t, KeyType>::value
size_type
count(KeyType&& key) const;

Return Value

returns a const reverse iterator to the last element

Synopsis

const_reverse_iterator
crbegin() const noexcept;

Return Value

returns a const reverse iterator to one before the first

Synopsis

const_reverse_iterator
crend() const noexcept;

Return Value

serialization

Synopsis

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

Return Value

Parameters

add an object to an object if key does not exist

Synopsis

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

add an object to an array

Synopsis

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

Return Value

checks whether the container is empty.

Synopsis

bool
empty() const noexcept;

returns an iterator to one past the last element

Synopsis

iterator
end() noexcept;

Return Value

returns an iterator to one past the last element

Synopsis

const_iterator
end() const noexcept;

Return Value

remove element from a JSON array given an index

Synopsis

void
erase(size_type const idx);

Parameters

remove element from a JSON object given a key

Synopsis

size_type
erase(object_t::key_type const& key);

Return Value

remove element given an iterator

Synopsis

template<class IteratorType>
requires std::is_same<IteratorType, typename basic_json_t::iterator>::value ||
                   std::is_same<IteratorType, typename basic_json_t::const_iterator>::value
IteratorType
erase(IteratorType pos);

remove element from a JSON object given a key

Synopsis

template<class KeyType>
requires detail::is_usable_as_basic_json_key_type<basic_json_t, KeyType>::value
size_type
erase(KeyType&& key);

Return Value

remove elements given an iterator range

Synopsis

template<class IteratorType>
requires std::is_same<IteratorType, typename basic_json_t::iterator>::value ||
                   std::is_same<IteratorType, typename basic_json_t::const_iterator>::value
IteratorType
erase(
    IteratorType first,
    IteratorType last);

find an element in a JSON object

Synopsis

iterator
find(object_t::key_type const& key);

Return Value

find an element in a JSON object

Synopsis

const_iterator
find(object_t::key_type const& key) const;

Return Value

find an element in a JSON object

Synopsis

template<class KeyType>
requires detail::is_usable_as_basic_json_key_type<basic_json_t, KeyType>::value
iterator
find(KeyType&& key);

Return Value

find an element in a JSON object

Synopsis

template<class KeyType>
requires detail::is_usable_as_basic_json_key_type<basic_json_t, KeyType>::value
const_iterator
find(KeyType&& key) const;

Return Value

return flattened JSON value

Synopsis

basic_json
flatten() const;

Return Value

access the first element

Synopsis

reference
front();

Return Value

access the first element

Synopsis

const_reference
front() const;

Return Value

get a pointer value (explicit)

Synopsis

template<typename PointerType>
requires std::is_pointer<PointerType>::value
decltype(std::declval<basic_json_t&>().template get_ptr<PointerType>())
get() noexcept;

Description

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

Constant.

{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}

Return Value

Template Parameters

get a (pointer) value (explicit)

Synopsis

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

Description

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.

Exceptions

Return Value

Template Parameters

get a binary value

Synopsis

binary_t&
get_binary();

Return Value

get a binary value

Synopsis

binary_t const&
get_binary() const;

Return Value

get a pointer value (implicit)

Synopsis

template<typename PointerType>
requires std::is_pointer<PointerType>::value
decltype(std::declval<basic_json_t&>().get_impl_ptr(std::declval<PointerType>()))
get_ptr() noexcept;

get a pointer value (implicit)

Synopsis

template<typename PointerType>
requires std::is_pointer<PointerType>::value&&
                   std::is_const<typename std::remove_pointer<PointerType>::type>::value
constexpr
decltype(std::declval<const basic_json_t&>().get_impl_ptr(std::declval<PointerType>()))
get_ptr() const noexcept;

get a reference value (implicit)

Synopsis

template<typename ReferenceType>
requires std::is_reference<ReferenceType>::value
ReferenceType
get_ref();

get a reference value (implicit)

Synopsis

template<typename ReferenceType>
requires std::is_reference<ReferenceType>::value&&
                   std::is_const<typename std::remove_reference<ReferenceType>::type>::value
ReferenceType
get_ref() const;

get a value (explicit)

Synopsis

template<typename ValueType>
requires !detail::is_basic_json<ValueType>::value&&
                   detail::has_from_json<basic_json_t, ValueType>::value
ValueType&
get_to(ValueType& v) const noexcept(noexcept(JSONSerializer<ValueType, void>::from_json(std::declval<const basic_json_t &>(), v)));

Synopsis

template<typename ValueType>
requires detail::is_basic_json<ValueType>::value
ValueType&
get_to(ValueType& v) const;

Synopsis

template<
    typename T,
    std::size_t N,
    typename Array = T(&)[]>
requires detail::has_from_json<basic_json_t, Array>::value
Array
get_to(T(& v)[]) const noexcept(noexcept(JSONSerializer<Array, void>::from_json(std::declval<const basic_json_t &>(), v)));

inserts range of elements into object

Synopsis

void
insert(
    const_iterator first,
    const_iterator last);

Parameters

inserts elements from initializer list into array

Synopsis

iterator
insert(
    const_iterator pos,
    initializer_list_t ilist);

Return Value

Parameters

inserts element into array

Synopsis

iterator
insert(
    const_iterator pos,
    basic_json const& val);

Return Value

Parameters

inserts element into array

Synopsis

iterator
insert(
    const_iterator pos,
    basic_json&& val);

Return Value

Parameters

inserts range of elements into array

Synopsis

iterator
insert(
    const_iterator pos,
    const_iterator first,
    const_iterator last);

Return Value

Parameters

inserts copies of element into array

Synopsis

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

Return Value

Parameters

Helper for insertion of an iterator

Synopsis

template<typename... Args>
iterator
insert_iterator(
    const_iterator pos,
    Args...&&... args);

Description

Return Value

Parameters

return whether value is an array

Synopsis

constexpr
bool
is_array() const noexcept;

return whether value is a binary array

Synopsis

constexpr
bool
is_binary() const noexcept;

return whether value is a boolean

Synopsis

constexpr
bool
is_boolean() const noexcept;

return whether value is discarded

Synopsis

constexpr
bool
is_discarded() const noexcept;

return whether value is null

Synopsis

constexpr
bool
is_null() const noexcept;

return whether value is a number

Synopsis

constexpr
bool
is_number() const noexcept;

return whether value is a floating-point number

Synopsis

constexpr
bool
is_number_float() const noexcept;

return whether value is an integer number

Synopsis

constexpr
bool
is_number_integer() const noexcept;

return whether value is an unsigned integer number

Synopsis

constexpr
bool
is_number_unsigned() const noexcept;

return whether value is an object

Synopsis

constexpr
bool
is_object() const noexcept;

return whether type is primitive

Synopsis

constexpr
bool
is_primitive() const noexcept;

return whether value is a string

Synopsis

constexpr
bool
is_string() const noexcept;

return whether type is structured

Synopsis

constexpr
bool
is_structured() const noexcept;

helper to access iterator member functions in range-based for

Synopsis

iteration_proxy<iterator>
items() noexcept;

helper to access iterator member functions in range-based for

Synopsis

iteration_proxy<const_iterator>
items() const noexcept;

returns the maximum possible number of elements

Synopsis

size_type
max_size() const noexcept;

Return Value

applies a JSON Merge Patch

Synopsis

void
merge_patch(basic_json const& apply_patch);

Parameters

add an object to an object

Synopsis

reference
operator+=(initializer_list_t init);

Return Value

Parameters

add an object to an array

Synopsis

reference
operator+=(basic_json const& val);

Return Value

Parameters

add an object to an object

Synopsis

reference
operator+=(object_t::value_type const& val);

Return Value

Parameters

add an object to an array

Synopsis

reference
operator+=(basic_json&& val);

Return Value

Parameters

access specified object element

Synopsis

reference
operator[](object_t::key_type key);

Return Value

Parameters

access specified array element

Synopsis

reference
operator[](size_type idx);

Return Value

Parameters

access specified array element

Synopsis

const_reference
operator[](size_type idx) const;

Return Value

Parameters

access specified element via JSON Pointer

Synopsis

reference
operator[](json_pointer const& ptr);

Return Value

Parameters

access specified element via JSON Pointer

Synopsis

const_reference
operator[](json_pointer const& ptr) const;

Return Value

Parameters

access specified object element

Synopsis

const_reference
operator[](object_t::key_type const& key) const;

Return Value

Parameters

Subscript operator

Synopsis

template<typename BasicJsonType>
requires detail::is_basic_json<BasicJsonType>::value
[[__deprecated__]]
reference
operator[](nlohmann::json_pointer<BasicJsonType> const& ptr);

Return Value

Parameters

Subscript operator

Synopsis

template<typename BasicJsonType>
requires detail::is_basic_json<BasicJsonType>::value
[[__deprecated__]]
const_reference
operator[](nlohmann::json_pointer<BasicJsonType> const& ptr) const;

Return Value

Parameters

access specified object element

Synopsis

template<class KeyType>
requires detail::is_usable_as_basic_json_key_type<basic_json_t, KeyType>::value
reference
operator[](KeyType&& key);

Return Value

Parameters

access specified object element

Synopsis

template<class KeyType>
requires detail::is_usable_as_basic_json_key_type<basic_json_t, KeyType>::value
const_reference
operator[](KeyType&& key) const;

Return Value

Parameters

Subscript operator

Synopsis

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

Return Value

Parameters

Subscript operator

Synopsis

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

Return Value

Parameters

applies a JSON patch to a copy of the current object

Synopsis

basic_json
patch(basic_json const& json_patch) const;

Return Value

Parameters

applies a JSON patch in-place without copying the object

Synopsis

void
patch_inplace(basic_json const& json_patch);

Parameters

add an object to an object

Synopsis

void
push_back(initializer_list_t init);

Parameters

add an object to an array

Synopsis

void
push_back(basic_json const& val);

Parameters

add an object to an object

Synopsis

void
push_back(object_t::value_type const& val);

add an object to an array

Synopsis

void
push_back(basic_json&& val);

Parameters

returns an iterator to the reverse-beginning

Synopsis

reverse_iterator
rbegin() noexcept;

Return Value

returns an iterator to the reverse-beginning

Synopsis

const_reverse_iterator
rbegin() const noexcept;

Return Value

returns an iterator to the reverse-end

Synopsis

reverse_iterator
rend() noexcept;

Return Value

returns an iterator to the reverse-end

Synopsis

const_reverse_iterator
rend() const noexcept;

Return Value

returns the number of elements

Synopsis

size_type
size() const noexcept;

Return Value

exchanges the values

Synopsis

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 && std::is_nothrow_move_assignable<json_value>::value);

Parameters

exchanges the values

Synopsis

void
swap(array_t& other);

Parameters

exchanges the values

Synopsis

void
swap(binary_t& other);

Parameters

exchanges the values

Synopsis

void
swap(binary_t::container_type& other);

exchanges the values

Synopsis

void
swap(object_t& other);

Parameters

exchanges the values

Synopsis

void
swap(string_t& other);

Parameters

return the type of the JSON value (explicit)

Synopsis

constexpr
value_t
type() const noexcept;

return the type as string

Synopsis

[[__returns_nonnull__]]
char const*
type_name() const noexcept;

unflatten a previously flattened JSON value

Synopsis

basic_json
unflatten() const;

Return Value

updates a JSON object from another object, overwriting existing keys

Synopsis

void
update(
    const_reference j,
    bool merge_objects = false);

Parameters

updates a JSON object from another object, overwriting existing keys

Synopsis

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

Parameters

access specified object element via JSON Pointer with default value

Synopsis

template<class ValueType>
requires detail::is_getable<basic_json_t, ValueType>::value
                   && !std::is_same<value_t, detail::uncvref_t<ValueType>>::value
ValueType
value(
    json_pointer const& ptr,
    ValueType const& default_value) const;

Parameters

access specified object element with default value

Synopsis

template<class ValueType>
requires !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
ValueType
value(
    object_t::key_type const& key,
    ValueType const& default_value) const;

access specified object element via JSON Pointer with default value

Synopsis

template<
    class ValueType,
    class ReturnType = value_return_type<ValueType>::type>
requires detail::is_getable<basic_json_t, ReturnType>::value
                   && !std::is_same<value_t, detail::uncvref_t<ValueType>>::value
ReturnType
value(
    json_pointer const& ptr,
    ValueType&& default_value) const;

Parameters

access specified object element with default value

Synopsis

template<
    class ValueType,
    class ReturnType = value_return_type<ValueType>::type>
requires !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
ReturnType
value(
    object_t::key_type const& key,
    ValueType&& default_value) const;

Synopsis

template<
    class ValueType,
    class BasicJsonType>
requires detail::is_basic_json<BasicJsonType>::value
                   && detail::is_getable<basic_json_t, ValueType>::value
                   && !std::is_same<value_t, detail::uncvref_t<ValueType>>::value
[[__deprecated__]]
ValueType
value(
    nlohmann::json_pointer<BasicJsonType> const& ptr,
    ValueType const& default_value) const;

access specified object element with default value

Synopsis

template<
    class ValueType,
    class KeyType>
requires 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
ValueType
value(
    KeyType&& key,
    ValueType const& default_value) const;

Synopsis

template<
    class ValueType,
    class BasicJsonType,
    class ReturnType = value_return_type<ValueType>::type>
requires detail::is_basic_json<BasicJsonType>::value
                   && detail::is_getable<basic_json_t, ReturnType>::value
                   && !std::is_same<value_t, detail::uncvref_t<ValueType>>::value
[[__deprecated__]]
ReturnType
value(
    nlohmann::json_pointer<BasicJsonType> const& ptr,
    ValueType&& default_value) const;

access specified object element via JSON Pointer with default value

Synopsis

template<
    class ValueType,
    class KeyType,
    class ReturnType = value_return_type<ValueType>::type>
requires 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
ReturnType
value(
    KeyType&& key,
    ValueType&& default_value) const;

get a value (implicit)

Synopsis

template<typename ValueType>
requires 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>>>,
#if defined(JSON_HAS_CPP_17) && (defined(__GNUC__) || (defined(_MSC_VER) && _MSC_VER >= 1910 && _MSC_VER <= 1914))
                                                detail::negation<std::is_same<ValueType, std::string_view>>,
#endif
#if defined(JSON_HAS_CPP_17) && JSON_HAS_STATIC_RTTI
                                                detail::negation<std::is_same<ValueType, std::any>>,
#endif
                                                detail::is_detected_lazy<detail::get_template_function, const basic_json_t&, ValueType>
                                                >::value
operator ValueType() const;

Description

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

Linear in the size of the JSON value.

{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}

Exceptions

Return Value

Template Parameters

return the type of the JSON value (implicit)

Synopsis

constexpr
operator value_t() const noexcept;

Return Value

comparison: equal

Synopsis

template<typename ScalarType>
requires std::is_scalar_v<ScalarType>
bool
operator==(ScalarType rhs) const noexcept;

Return Value

Parameters

comparison: equal

Synopsis

bool
operator==(const_reference rhs) const noexcept;

Return Value

Parameters