a class to store JSON values More...

#include <json.hpp>

Classes
class	const_iterator
	a const random access iterator for the basic_json class More...
struct	internal_iterator
	an iterator value More...
class	iteration_proxy
	proxy class for the iterator_wrapper functions More...
class	iterator
	a mutable random access iterator for the basic_json class More...
class	json_pointer
	JSON Pointer. More...
class	json_reverse_iterator
	a template for a reverse iterator class More...
union	json_value
	a JSON value More...
class	lexer
	lexical analysis More...
class	parser
	syntax analysis More...
class	primitive_iterator_t
	an iterator for primitive JSON types More...
Public Types
enum	parse_event_t { object_start, object_end, array_start, array_end, key, value }
	JSON callback events. More...
enum	value_t { null, object, array, string, boolean, number_integer, number_unsigned, number_float, discarded }
	the JSON type enumeration More...
Static Public Member Functions
static allocator_type	get_allocator ()
	returns the allocator associated with the container
Private Member Functions
void	dump (std::ostream &o, const bool pretty_print, const unsigned int indent_step, const unsigned int current_indent=0) const
	internal implementation of the serialization function
template<class T , typename std::enable_if< std::is_convertible< typename object_t::key_type, typename T::key_type >::value andstd::is_convertible< basic_json_t, typename T::mapped_type >::value, int >::type = 0>
T	get_impl (T *) const
	get an object (explicit)
object_t	get_impl (object_t *) const
	get an object (explicit)
template<class T , typename std::enable_if< std::is_convertible< basic_json_t, typename T::value_type >::value andnot std::is_same< basic_json_t, typename T::value_type >::value andnot std::is_arithmetic< T >::value andnot std::is_convertible< std::string, T >::value andnot has_mapped_type< T >::value, int >::type = 0>
T	get_impl (T *) const
	get an array (explicit)
template<class T , typename std::enable_if< std::is_convertible< basic_json_t, T >::value andnot std::is_same< basic_json_t, T >::value, int >::type = 0>
std::vector< T >	get_impl (std::vector< T > *) const
	get an array (explicit)
template<class T , typename std::enable_if< std::is_same< basic_json, typename T::value_type >::value andnot has_mapped_type< T >::value, int >::type = 0>
T	get_impl (T *) const
	get an array (explicit)
array_t	get_impl (array_t *) const
	get an array (explicit)
template<typename T , typename std::enable_if< std::is_convertible< string_t, T >::value, int >::type = 0>
T	get_impl (T *) const
	get a string (explicit)
template<typename T , typename std::enable_if< std::is_arithmetic< T >::value, int >::type = 0>
T	get_impl (T *) const
	get a number (explicit)
constexpr boolean_t	get_impl (boolean_t *) const
	get a boolean (explicit)
object_t *	get_impl_ptr (object_t *) noexcept
	get a pointer to the value (object)
constexpr const object_t *	get_impl_ptr (const object_t *) const noexcept
	get a pointer to the value (object)
array_t *	get_impl_ptr (array_t *) noexcept
	get a pointer to the value (array)
constexpr const array_t *	get_impl_ptr (const array_t *) const noexcept
	get a pointer to the value (array)
string_t *	get_impl_ptr (string_t *) noexcept
	get a pointer to the value (string)
constexpr const string_t *	get_impl_ptr (const string_t *) const noexcept
	get a pointer to the value (string)
boolean_t *	get_impl_ptr (boolean_t *) noexcept
	get a pointer to the value (boolean)
constexpr const boolean_t *	get_impl_ptr (const boolean_t *) const noexcept
	get a pointer to the value (boolean)
number_integer_t *	get_impl_ptr (number_integer_t *) noexcept
	get a pointer to the value (integer number)
constexpr const number_integer_t *	get_impl_ptr (const number_integer_t *) const noexcept
	get a pointer to the value (integer number)
number_unsigned_t *	get_impl_ptr (number_unsigned_t *) noexcept
	get a pointer to the value (unsigned number)
constexpr const number_unsigned_t *	get_impl_ptr (const number_unsigned_t *) const noexcept
	get a pointer to the value (unsigned number)
number_float_t *	get_impl_ptr (number_float_t *) noexcept
	get a pointer to the value (floating-point number)
constexpr const number_float_t *	get_impl_ptr (const number_float_t *) const noexcept
	get a pointer to the value (floating-point number)
string_t	type_name () const noexcept
	return the type as string
Static Private Member Functions
template<typename T , typename... Args>
static T *	create (Args &&...args)
	helper for exception-safe object creation
static string_t	escape_string (const string_t &s)
	escape a string
static std::size_t	extra_space (const string_t &s) noexcept
	calculates the extra space to escape a JSON string
template<typename ReferenceType , typename ThisType >
static ReferenceType	get_ref_impl (ThisType &obj)
	helper function to implement get_ref()
Private Attributes
value_t	m_type = value_t::null
	the type of the current element
json_value	m_value = {}
	the value of the current element
constructors and destructors
static basic_json	array (std::initializer_list< basic_json > init=std::initializer_list< basic_json >())
	explicitly create an array from an initializer list
static basic_json	object (std::initializer_list< basic_json > init=std::initializer_list< basic_json >())
	explicitly create an object from an initializer list
	basic_json (const value_t value_type)
	create an empty value with a given type
	basic_json ()
	create a null object (implicitly)
	basic_json (std::nullptr_t) noexcept
	create a null object (explicitly)
	basic_json (const object_t &val)
	create an object (explicit)
template<class CompatibleObjectType , typename std::enable_if< std::is_constructible< typename object_t::key_type, typename CompatibleObjectType::key_type >::value andstd::is_constructible< basic_json, typename CompatibleObjectType::mapped_type >::value, int >::type = 0>
	basic_json (const CompatibleObjectType &val)
	create an object (implicit)
	basic_json (const array_t &val)
	create an array (explicit)
template<class CompatibleArrayType , typename std::enable_if< not std::is_same< CompatibleArrayType, typename basic_json_t::iterator >::value andnot std::is_same< CompatibleArrayType, typename basic_json_t::const_iterator >::value andnot std::is_same< CompatibleArrayType, typename basic_json_t::reverse_iterator >::value andnot std::is_same< CompatibleArrayType, typename basic_json_t::const_reverse_iterator >::value andnot std::is_same< CompatibleArrayType, typename array_t::iterator >::value andnot std::is_same< CompatibleArrayType, typename array_t::const_iterator >::value andstd::is_constructible< basic_json, typename CompatibleArrayType::value_type >::value, int >::type = 0>
	basic_json (const CompatibleArrayType &val)
	create an array (implicit)
	basic_json (const string_t &val)
	create a string (explicit)
	basic_json (const typename string_t::value_type *val)
	create a string (explicit)
template<class CompatibleStringType , typename std::enable_if< std::is_constructible< string_t, CompatibleStringType >::value, int >::type = 0>
	basic_json (const CompatibleStringType &val)
	create a string (implicit)
	basic_json (boolean_t val) noexcept
	create a boolean (explicit)
template<typename T , typename std::enable_if< not(std::is_same< T, int >::value) and std::is_same< T, number_integer_t >::value, int >::type = 0>
	basic_json (const number_integer_t val) noexcept
	create an integer number (explicit)
	basic_json (const int val) noexcept
	create an integer number from an enum type (explicit)
template<typename CompatibleNumberIntegerType , typename std::enable_if< std::is_constructible< number_integer_t, CompatibleNumberIntegerType >::value andstd::numeric_limits< CompatibleNumberIntegerType >::is_integer andstd::numeric_limits< CompatibleNumberIntegerType >::is_signed, CompatibleNumberIntegerType >::type = 0>
	basic_json (const CompatibleNumberIntegerType val) noexcept
	create an integer number (implicit)
template<typename T , typename std::enable_if< not(std::is_same< T, int >::value) and std::is_same< T, number_unsigned_t >::value, int >::type = 0>
	basic_json (const number_unsigned_t val) noexcept
	create an unsigned integer number (explicit)
template<typename CompatibleNumberUnsignedType , typename std::enable_if< std::is_constructible< number_unsigned_t, CompatibleNumberUnsignedType >::value andstd::numeric_limits< CompatibleNumberUnsignedType >::is_integer andnot std::numeric_limits< CompatibleNumberUnsignedType >::is_signed, CompatibleNumberUnsignedType >::type = 0>
	basic_json (const CompatibleNumberUnsignedType val) noexcept
	create an unsigned number (implicit)
	basic_json (const number_float_t val) noexcept
	create a floating-point number (explicit)
template<typename CompatibleNumberFloatType , typename = typename std::enable_if< std::is_constructible<number_float_t, CompatibleNumberFloatType>::value and std::is_floating_point<CompatibleNumberFloatType>::value>::type>
	basic_json (const CompatibleNumberFloatType val) noexcept
	create an floating-point number (implicit)
	basic_json (std::initializer_list< basic_json > init, bool type_deduction=true, value_t manual_type=value_t::array)
	create a container (array or object) from an initializer list
	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 orstd::is_same< InputIT, typename basic_json_t::const_iterator >::value, int >::type = 0>
	basic_json (InputIT first, InputIT last)
	construct a JSON container given an iterator range
	basic_json (std::istream &i, parser_callback_t cb=nullptr)
	construct a JSON value given an input stream
	basic_json (const basic_json &other)
	copy constructor
	basic_json (basic_json &&other) noexcept
	move constructor
reference &	operator= (basic_json other) noexcept(std
	copy assignment
	~basic_json ()
	destructor
object inspection
string_t	dump (const int indent=-1) const
	serialization
constexpr value_t	type () const noexcept
	return the type of the JSON value (explicit)
constexpr bool	is_primitive () const noexcept
	return whether type is primitive
constexpr bool	is_structured () const noexcept
	return whether type is structured
constexpr bool	is_null () const noexcept
	return whether value is null
constexpr bool	is_boolean () const noexcept
	return whether value is a boolean
constexpr bool	is_number () const noexcept
	return whether value is a number
constexpr bool	is_number_integer () const noexcept
	return whether value is an integer number
constexpr bool	is_number_unsigned () const noexcept
	return whether value is an unsigned integer number
constexpr bool	is_number_float () const noexcept
	return whether value is a floating-point number
constexpr bool	is_object () const noexcept
	return whether value is an object
constexpr bool	is_array () const noexcept
	return whether value is an array
constexpr bool	is_string () const noexcept
	return whether value is a string
constexpr bool	is_discarded () const noexcept
	return whether value is discarded
constexpr	operator value_t () const noexcept
	return the type of the JSON value (implicit)
value access
template<typename ValueType , typename std::enable_if< not std::is_pointer< ValueType >::value, int >::type = 0>
ValueType	get () const
	get a value (explicit)
template<typename PointerType , typename std::enable_if< std::is_pointer< PointerType >::value, int >::type = 0>
PointerType	get () noexcept
	get a pointer value (explicit)
template<typename PointerType , typename std::enable_if< std::is_pointer< PointerType >::value, int >::type = 0>
constexpr const PointerType	get () const noexcept
	get a pointer value (explicit)
template<typename PointerType , typename std::enable_if< std::is_pointer< PointerType >::value, int >::type = 0>
PointerType	get_ptr () noexcept
	get a pointer value (implicit)
template<typename PointerType , typename std::enable_if< std::is_pointer< PointerType >::valueand std::is_const< typename std::remove_pointer< PointerType >::type >::value, int >::type = 0>
constexpr const PointerType	get_ptr () const noexcept
	get a pointer value (implicit)
template<typename ReferenceType , typename std::enable_if< std::is_reference< ReferenceType >::value, int >::type = 0>
ReferenceType	get_ref ()
	get a reference value (implicit)
template<typename ReferenceType , typename std::enable_if< std::is_reference< ReferenceType >::valueand std::is_const< typename std::remove_reference< ReferenceType >::type >::value, int >::type = 0>
ReferenceType	get_ref () const
	get a reference value (implicit)
template<typename ValueType , typename std::enable_if< not std::is_pointer< ValueType >::valueand not std::is_same< ValueType, typename string_t::value_type >::valueand not std::is_same< ValueType, std::initializer_list< typename string_t::value_type >>::value, int >::type = 0>
	operator ValueType () const
	get a value (implicit)
element access
reference	at (size_type idx)
	access specified array element with bounds checking
const_reference	at (size_type idx) const
	access specified array element with bounds checking
reference	at (const typename object_t::key_type &key)
	access specified object element with bounds checking
const_reference	at (const typename object_t::key_type &key) const
	access specified object element with bounds checking
reference	operator[] (size_type idx)
	access specified array element
const_reference	operator[] (size_type idx) const
	access specified array element
reference	operator[] (const typename object_t::key_type &key)
	access specified object element
const_reference	operator[] (const typename object_t::key_type &key) const
	read-only access specified object element
template<typename T , std::size_t n>
reference	operator[] (T *(&key)[n])
	access specified object element
template<typename T , std::size_t n>
const_reference	operator[] (T *(&key)[n]) const
	read-only access specified object element
template<typename T >
reference	operator[] (T *key)
	access specified object element
template<typename T >
const_reference	operator[] (T *key) const
	read-only access specified object element
template<class ValueType , typename std::enable_if< std::is_convertible< basic_json_t, ValueType >::value, int >::type = 0>
ValueType	value (const typename object_t::key_type &key, ValueType default_value) const
	access specified object element with default value
string_t	value (const typename object_t::key_type &key, const char *default_value) const
	overload for a default value of type const char*
reference	front ()
	access the first element
const_reference	front () const
reference	back ()
	access the last element
const_reference	back () const
template<class InteratorType , typename std::enable_if< std::is_same< InteratorType, typename basic_json_t::iterator >::value orstd::is_same< InteratorType, typename basic_json_t::const_iterator >::value, int >::type = 0>
InteratorType	erase (InteratorType pos)
	remove element given an iterator
template<class InteratorType , typename std::enable_if< std::is_same< InteratorType, typename basic_json_t::iterator >::value orstd::is_same< InteratorType, typename basic_json_t::const_iterator >::value, int >::type = 0>
InteratorType	erase (InteratorType first, InteratorType last)
	remove elements given an iterator range
size_type	erase (const typename object_t::key_type &key)
	remove element from a JSON object given a key
void	erase (const size_type idx)
	remove element from a JSON array given an index
lookup
iterator	find (typename object_t::key_type key)
	find an element in a JSON object
const_iterator	find (typename object_t::key_type key) const
	find an element in a JSON object
size_type	count (typename object_t::key_type key) const
	returns the number of occurrences of a key in a JSON object
iterators
static iteration_proxy< iterator >	iterator_wrapper (reference cont)
	wrapper to access iterator member functions in range-based for
static iteration_proxy < const_iterator >	iterator_wrapper (const_reference cont)
iterator	begin () noexcept
	returns an iterator to the first element
const_iterator	begin () const noexcept
const_iterator	cbegin () const noexcept
	returns a const iterator to the first element
iterator	end () noexcept
	returns an iterator to one past the last element
const_iterator	end () const noexcept
const_iterator	cend () const noexcept
	returns a const iterator to one past the last element
reverse_iterator	rbegin () noexcept
	returns an iterator to the reverse-beginning
const_reverse_iterator	rbegin () const noexcept
reverse_iterator	rend () noexcept
	returns an iterator to the reverse-end
const_reverse_iterator	rend () const noexcept
const_reverse_iterator	crbegin () const noexcept
	returns a const reverse iterator to the last element
const_reverse_iterator	crend () const noexcept
	returns a const reverse iterator to one before the first
capacity
bool	empty () const noexcept
	checks whether the container is empty
size_type	size () const noexcept
	returns the number of elements
size_type	max_size () const noexcept
	returns the maximum possible number of elements
modifiers
void	clear () noexcept
	clears the contents
void	push_back (basic_json &&val)
	add an object to an array
reference	operator+= (basic_json &&val)
	add an object to an array
void	push_back (const basic_json &val)
	add an object to an array
reference	operator+= (const basic_json &val)
	add an object to an array
void	push_back (const typename object_t::value_type &val)
	add an object to an object
reference	operator+= (const typename object_t::value_type &val)
	add an object to an object
void	push_back (std::initializer_list< basic_json > init)
	add an object to an object
reference	operator+= (std::initializer_list< basic_json > init)
	add an object to an object
iterator	insert (const_iterator pos, const basic_json &val)
	inserts element
iterator	insert (const_iterator pos, basic_json &&val)
	inserts element
iterator	insert (const_iterator pos, size_type cnt, const basic_json &val)
	inserts elements
iterator	insert (const_iterator pos, const_iterator first, const_iterator last)
	inserts elements
iterator	insert (const_iterator pos, std::initializer_list< basic_json > ilist)
	inserts elements
void	swap (reference other) noexcept(std
	exchanges the values
void	swap (array_t &other)
	exchanges the values
void	swap (object_t &other)
	exchanges the values
void	swap (string_t &other)
	exchanges the values
lexicographical comparison operators
bool	operator< (const value_t lhs, const value_t rhs) noexcept
	comparison operator for JSON types
bool	operator== (const_reference lhs, const_reference rhs) noexcept
	comparison: equal
bool	operator== (const_reference v, std::nullptr_t) noexcept
	comparison: equal
bool	operator== (std::nullptr_t, const_reference v) noexcept
	comparison: equal
bool	operator!= (const_reference lhs, const_reference rhs) noexcept
	comparison: not equal
bool	operator!= (const_reference v, std::nullptr_t) noexcept
	comparison: not equal
bool	operator!= (std::nullptr_t, const_reference v) noexcept
	comparison: not equal
bool	operator< (const_reference lhs, const_reference rhs) noexcept
	comparison: less than
bool	operator<= (const_reference lhs, const_reference rhs) noexcept
	comparison: less than or equal
bool	operator> (const_reference lhs, const_reference rhs) noexcept
	comparison: greater than
bool	operator>= (const_reference lhs, const_reference rhs) noexcept
	comparison: greater than or equal
serialization
std::ostream &	operator<< (std::ostream &o, const basic_json &j)
	serialize to stream
std::ostream &	operator>> (const basic_json &j, std::ostream &o)
	serialize to stream
deserialization
static basic_json	parse (const string_t &s, parser_callback_t cb=nullptr)
	deserialize from string
static basic_json	parse (std::istream &i, parser_callback_t cb=nullptr)
	deserialize from stream
static basic_json	parse (std::istream &&i, parser_callback_t cb=nullptr)
std::istream &	operator<< (basic_json &j, std::istream &i)
	deserialize from stream
std::istream &	operator>> (std::istream &i, basic_json &j)
	deserialize from stream
JSON Pointer functions
reference	operator[] (const json_pointer &ptr)
	access specified element via JSON Pointer
const_reference	operator[] (const json_pointer &ptr) const
	access specified element via JSON Pointer
reference	at (const json_pointer &ptr)
	access specified element via JSON Pointer
const_reference	at (const json_pointer &ptr) const
	access specified element via JSON Pointer
basic_json	flatten () const
	return flattened JSON value
basic_json	unflatten () const
	unflatten a previously flattened JSON value
JSON Patch functions
static basic_json	diff (const basic_json &source, const basic_json &target, std::string path="")
	creates a diff as a JSON patch
basic_json	patch (const basic_json &json_patch) const
	applies a JSON patch

Detailed Description

template<template< typename U, typename V, typename...Args > class ObjectType = std::map, template< typename U, typename...Args > class ArrayType = std::vector, class StringType = std::string, class BooleanType = bool, class NumberIntegerType = std::int64_t, class NumberUnsignedType = std::uint64_t, class NumberFloatType = double, template< typename U > class AllocatorType = std::allocator>
class nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType >

a class to store JSON values

Template Parameters:

ObjectType	type for JSON objects (`std::map` by default; will be used in object_t)
ArrayType	type for JSON arrays (`std::vector` by default; will be used in array_t)
StringType	type for JSON strings and object keys (`std::string` by default; will be used in string_t)
BooleanType	type for JSON booleans (`bool` by default; will be used in boolean_t)
NumberIntegerType	type for JSON integer numbers (`int64_t` by default; will be used in number_integer_t)
NumberUnsignedType	type for JSON unsigned integer numbers (`uint64_t` by default; will be used in number_unsigned_t)
NumberFloatType	type for JSON floating-point numbers (`double` by default; will be used in number_float_t)
AllocatorType	type of the allocator to use (`std::allocator` by default)

The class satisfies the following concept requirements:

Basic
- [DefaultConstructible](http://en.cppreference.com/w/cpp/concept/DefaultConstructible): JSON values can be default constructed. The result will be a JSON null value.
- [MoveConstructible](http://en.cppreference.com/w/cpp/concept/MoveConstructible): A JSON value can be constructed from an rvalue argument.
- [CopyConstructible](http://en.cppreference.com/w/cpp/concept/CopyConstructible): A JSON value can be copy-constructed from an lvalue expression.
- [MoveAssignable](http://en.cppreference.com/w/cpp/concept/MoveAssignable): A JSON value van be assigned from an rvalue argument.
- [CopyAssignable](http://en.cppreference.com/w/cpp/concept/CopyAssignable): A JSON value can be copy-assigned from an lvalue expression.
- [Destructible](http://en.cppreference.com/w/cpp/concept/Destructible): JSON values can be destructed.
Layout
- [StandardLayoutType](http://en.cppreference.com/w/cpp/concept/StandardLayoutType): JSON values have [standard layout](http://en.cppreference.com/w/cpp/language/data_members#Standard_layout): All non-static data members are private and standard layout types, the class has no virtual functions or (virtual) base classes.
Library-wide
- [EqualityComparable](http://en.cppreference.com/w/cpp/concept/EqualityComparable): JSON values can be compared with `==`, see operator==(const_reference,const_reference).
- [LessThanComparable](http://en.cppreference.com/w/cpp/concept/LessThanComparable): JSON values can be compared with `<`, see operator<(const_reference,const_reference).
- [Swappable](http://en.cppreference.com/w/cpp/concept/Swappable): Any JSON lvalue or rvalue of can be swapped with any lvalue or rvalue of other compatible types, using unqualified function call swap().
- [NullablePointer](http://en.cppreference.com/w/cpp/concept/NullablePointer): JSON values can be compared against `std::nullptr_t` objects which are used to model the `null` value.
Container
- [Container](http://en.cppreference.com/w/cpp/concept/Container): JSON values can be used like STL containers and provide iterator access.
- [ReversibleContainer](http://en.cppreference.com/w/cpp/concept/ReversibleContainer); JSON values can be used like STL containers and provide reverse iterator access.

See also:: [RFC 7159: The JavaScript Object Notation (JSON) Data Interchange Format](http://rfc7159.net/rfc7159)

Since:: version 1.0.0

Definition at line 187 of file json.hpp.

Member Enumeration Documentation

template<template< typename U, typename V, typename...Args > class ObjectType = std::map, template< typename U, typename...Args > class ArrayType = std::vector, class StringType = std::string, class BooleanType = bool, class NumberIntegerType = std::int64_t, class NumberUnsignedType = std::uint64_t, class NumberFloatType = double, template< typename U > class AllocatorType = std::allocator>

enum nlohmann::basic_json::parse_event_t

JSON callback events.

This enumeration lists the parser events that can trigger calling a callback function of type parser_callback_t during parsing.

Since:: version 1.0.0

Enumerator:

object_start	the parser read `{` and started to process a JSON object
object_end	the parser read `}` and finished processing a JSON object
array_start	the parser read `[` and started to process a JSON array
array_end	the parser read `]` and finished processing a JSON array
key	the parser read a key of a value in an object
value	the parser finished reading a JSON value

Definition at line 853 of file json.hpp.

template<template< typename U, typename V, typename...Args > class ObjectType = std::map, template< typename U, typename...Args > class ArrayType = std::vector, class StringType = std::string, class BooleanType = bool, class NumberIntegerType = std::int64_t, class NumberUnsignedType = std::uint64_t, class NumberFloatType = double, template< typename U > class AllocatorType = std::allocator>

enum nlohmann::basic_json::value_t

the JSON type enumeration

This enumeration collects the different JSON types. It is internally used to distinguish the stored values, and the functions is_null(), is_object(), is_array(), is_string(), is_boolean(), is_number(), and is_discarded() rely on it.

Since:: version 1.0.0

Enumerator:

null	null value
object	object (unordered set of name/value pairs)
array	array (ordered collection of values)
string	string value
boolean	boolean value
number_integer	number value (integer)
number_unsigned	number value (unsigned integer)
number_float	number value (floating-point)
discarded	discarded by the the parser callback function

Definition at line 698 of file json.hpp.

Constructor & Destructor Documentation

template<template< typename U, typename V, typename...Args > class ObjectType = std::map, template< typename U, typename...Args > class ArrayType = std::vector, class StringType = std::string, class BooleanType = bool, class NumberIntegerType = std::int64_t, class NumberUnsignedType = std::uint64_t, class NumberFloatType = double, template< typename U > class AllocatorType = std::allocator>

nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType >::basic_json ( const value_t value_type ) [inline]

create an empty value with a given type

Create an empty JSON value with a given type. The value will be default initialized with an empty value which depends on the type:

Value type | initial value ----------- | ------------- null | `null` boolean | `false` string | `""` number | `0` object | `{}` array | `[]`

Parameters:

[in] value_type the type of the value to create

Constant.

Exceptions:

std::bad_alloc if allocation for object, array, or string value fails

{The following code shows the constructor for different value_t values,basic_json__value_t}

See also:: basic_json(std::nullptr_t) -- create a `null` value; basic_json(boolean_t value) -- create a boolean value; basic_json(const string_t&) -- create a string value; basic_json(const object_t&) -- create a object value; basic_json(const array_t&) -- create a array value; basic_json(const number_float_t) -- create a number (floating-point) value; basic_json(const number_integer_t) -- create a number (integer) value; basic_json(const number_unsigned_t) -- create a number (unsigned) value

Since:: version 1.0.0

Definition at line 967 of file json.hpp.

template<template< typename U, typename V, typename...Args > class ObjectType = std::map, template< typename U, typename...Args > class ArrayType = std::vector, class StringType = std::string, class BooleanType = bool, class NumberIntegerType = std::int64_t, class NumberUnsignedType = std::uint64_t, class NumberFloatType = double, template< typename U > class AllocatorType = std::allocator>

nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType >::basic_json ( )

create a null object (implicitly)

Create a `null` JSON value. This is the implicit version of the `null` value constructor as it takes no parameters.

Constant.

No-throw guarantee: this constructor never throws exceptions.

This function helps `basic_json` satisfying the [Container](http://en.cppreference.com/w/cpp/concept/Container) requirements:

The complexity is constant.
As postcondition, it holds: `basic_json().empty() == true`.

{The following code shows the constructor for a `null` JSON value.,basic_json}

See also:: basic_json(std::nullptr_t) -- create a `null` value

Since:: version 1.0.0

template<template< typename U, typename V, typename...Args > class ObjectType = std::map, template< typename U, typename...Args > class ArrayType = std::vector, class StringType = std::string, class BooleanType = bool, class NumberIntegerType = std::int64_t, class NumberUnsignedType = std::uint64_t, class NumberFloatType = double, template< typename U > class AllocatorType = std::allocator>

nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType >::basic_json ( std::nullptr_t ) [inline]

create a null object (explicitly)

Create a `null` JSON value. This is the explicitly version of the `null` value constructor as it takes a null pointer as parameter. It allows to create `null` values by explicitly assigning a `nullptr` to a JSON value. The passed null pointer itself is not read -- it is only used to choose the right constructor.

Constant.

No-throw guarantee: this constructor never throws exceptions.

{The following code shows the constructor with null pointer parameter.,basic_json__nullptr_t}

See also:: basic_json() -- default constructor (implicitly creating a `null` value)

Since:: version 1.0.0

Definition at line 1019 of file json.hpp.

template<template< typename U, typename V, typename...Args > class ObjectType = std::map, template< typename U, typename...Args > class ArrayType = std::vector, class StringType = std::string, class BooleanType = bool, class NumberIntegerType = std::int64_t, class NumberUnsignedType = std::uint64_t, class NumberFloatType = double, template< typename U > class AllocatorType = std::allocator>

nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType >::basic_json ( const object_t & val ) [inline]

create an object (explicit)

Create an object JSON value with a given content.

Parameters:

[in] val a value for the object

Linear in the size of the passed val.

Exceptions:

std::bad_alloc if allocation for object value fails

{The following code shows the constructor with an object_t parameter.,basic_json__object_t}

See also:: basic_json(const CompatibleObjectType&) -- create an object value from a compatible STL container

Since:: version 1.0.0

Definition at line 1042 of file json.hpp.

template<template< typename U, typename V, typename...Args > class ObjectType = std::map, template< typename U, typename...Args > class ArrayType = std::vector, class StringType = std::string, class BooleanType = bool, class NumberIntegerType = std::int64_t, class NumberUnsignedType = std::uint64_t, class NumberFloatType = double, template< typename U > class AllocatorType = std::allocator>

template<class CompatibleObjectType , typename std::enable_if< std::is_constructible< typename object_t::key_type, typename CompatibleObjectType::key_type >::value andstd::is_constructible< basic_json, typename CompatibleObjectType::mapped_type >::value, int >::type = 0>

nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType >::basic_json ( const CompatibleObjectType & val ) [inline]

create an object (implicit)

Create an object JSON value with a given content. This constructor allows any type CompatibleObjectType that can be used to construct values of type object_t.

Template Parameters:

CompatibleObjectType An object type whose `key_type` and `value_type` is compatible to object_t. Examples include `std::map`, `std::unordered_map`, `std::multimap`, and `std::unordered_multimap` with a `key_type` of `std::string`, and a `value_type` from which a basic_json value can be constructed.

Parameters:

[in] val a value for the object

Linear in the size of the passed val.

Exceptions:

std::bad_alloc if allocation for object value fails

{The following code shows the constructor with several compatible object type parameters.,basic_json__CompatibleObjectType}

See also:: basic_json(const object_t&) -- create an object value

Since:: version 1.0.0

Definition at line 1077 of file json.hpp.

template<template< typename U, typename V, typename...Args > class ObjectType = std::map, template< typename U, typename...Args > class ArrayType = std::vector, class StringType = std::string, class BooleanType = bool, class NumberIntegerType = std::int64_t, class NumberUnsignedType = std::uint64_t, class NumberFloatType = double, template< typename U > class AllocatorType = std::allocator>

nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType >::basic_json ( const array_t & val ) [inline]

create an array (explicit)

Create an array JSON value with a given content.

Parameters:

[in] val a value for the array

Linear in the size of the passed val.

Exceptions:

std::bad_alloc if allocation for array value fails

{The following code shows the constructor with an array_t parameter.,basic_json__array_t}

See also:: basic_json(const CompatibleArrayType&) -- create an array value from a compatible STL containers

Since:: version 1.0.0

Definition at line 1104 of file json.hpp.

template<template< typename U, typename V, typename...Args > class ObjectType = std::map, template< typename U, typename...Args > class ArrayType = std::vector, class StringType = std::string, class BooleanType = bool, class NumberIntegerType = std::int64_t, class NumberUnsignedType = std::uint64_t, class NumberFloatType = double, template< typename U > class AllocatorType = std::allocator>

template<class CompatibleArrayType , typename std::enable_if< not std::is_same< CompatibleArrayType, typename basic_json_t::iterator >::value andnot std::is_same< CompatibleArrayType, typename basic_json_t::const_iterator >::value andnot std::is_same< CompatibleArrayType, typename basic_json_t::reverse_iterator >::value andnot std::is_same< CompatibleArrayType, typename basic_json_t::const_reverse_iterator >::value andnot std::is_same< CompatibleArrayType, typename array_t::iterator >::value andnot std::is_same< CompatibleArrayType, typename array_t::const_iterator >::value andstd::is_constructible< basic_json, typename CompatibleArrayType::value_type >::value, int >::type = 0>

nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType >::basic_json ( const CompatibleArrayType & val ) [inline]

create an array (implicit)

Create an array JSON value with a given content. This constructor allows any type CompatibleArrayType that can be used to construct values of type array_t.

Template Parameters:

CompatibleArrayType An object type whose `value_type` is compatible to array_t. Examples include `std::vector`, `std::deque`, `std::list`, `std::forward_list`, `std::array`, `stdset`, `std::unordered_set`, `std::multiset`, and `unordered_multiset` with a `value_type` from which a basic_json value can be constructed.

Parameters:

[in] val a value for the array

Linear in the size of the passed val.

Exceptions:

std::bad_alloc if allocation for array value fails

{The following code shows the constructor with several compatible array type parameters.,basic_json__CompatibleArrayType}

See also:: basic_json(const array_t&) -- create an array value

Since:: version 1.0.0

Definition at line 1144 of file json.hpp.

template<template< typename U, typename V, typename...Args > class ObjectType = std::map, template< typename U, typename...Args > class ArrayType = std::vector, class StringType = std::string, class BooleanType = bool, class NumberIntegerType = std::int64_t, class NumberUnsignedType = std::uint64_t, class NumberFloatType = double, template< typename U > class AllocatorType = std::allocator>

nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType >::basic_json ( const string_t & val ) [inline]

create a string (explicit)

Create an string JSON value with a given content.

Parameters:

[in] val a value for the string

Linear in the size of the passed val.

Exceptions:

std::bad_alloc if allocation for string value fails

{The following code shows the constructor with an string_t parameter.,basic_json__string_t}

See also:: basic_json(const typename string_t::value_type*) -- create a string value from a character pointer; basic_json(const CompatibleStringType&) -- create a string value from a compatible string container

Since:: version 1.0.0

Definition at line 1173 of file json.hpp.

template<template< typename U, typename V, typename...Args > class ObjectType = std::map, template< typename U, typename...Args > class ArrayType = std::vector, class StringType = std::string, class BooleanType = bool, class NumberIntegerType = std::int64_t, class NumberUnsignedType = std::uint64_t, class NumberFloatType = double, template< typename U > class AllocatorType = std::allocator>

nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType >::basic_json ( const typename string_t::value_type * val ) [inline]

create a string (explicit)

Create a string JSON value with a given content.

Parameters:

[in] val a literal value for the string

Linear in the size of the passed val.

Exceptions:

std::bad_alloc if allocation for string value fails

{The following code shows the constructor with string literal parameter.,basic_json__string_t_value_type}

See also:: basic_json(const string_t&) -- create a string value; basic_json(const CompatibleStringType&) -- create a string value from a compatible string container

Since:: version 1.0.0

Definition at line 1197 of file json.hpp.

template<template< typename U, typename V, typename...Args > class ObjectType = std::map, template< typename U, typename...Args > class ArrayType = std::vector, class StringType = std::string, class BooleanType = bool, class NumberIntegerType = std::int64_t, class NumberUnsignedType = std::uint64_t, class NumberFloatType = double, template< typename U > class AllocatorType = std::allocator>

template<class CompatibleStringType , typename std::enable_if< std::is_constructible< string_t, CompatibleStringType >::value, int >::type = 0>

nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType >::basic_json ( const CompatibleStringType & val ) [inline]

create a string (implicit)

Create a string JSON value with a given content.

Parameters:

[in] val a value for the string

Template Parameters:

CompatibleStringType an string type which is compatible to string_t, for instance `std::string`.

Linear in the size of the passed val.

Exceptions:

std::bad_alloc if allocation for string value fails

{The following code shows the construction of a string value from a compatible type.,basic_json__CompatibleStringType}

See also:: basic_json(const string_t&) -- create a string value; basic_json(const typename string_t::value_type*) -- create a string value from a character pointer

Since:: version 1.0.0

Definition at line 1228 of file json.hpp.

template<template< typename U, typename V, typename...Args > class ObjectType = std::map, template< typename U, typename...Args > class ArrayType = std::vector, class StringType = std::string, class BooleanType = bool, class NumberIntegerType = std::int64_t, class NumberUnsignedType = std::uint64_t, class NumberFloatType = double, template< typename U > class AllocatorType = std::allocator>

nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType >::basic_json ( boolean_t val ) [inline]

create a boolean (explicit)

Creates a JSON boolean type from a given value.

Parameters:

[in] val a boolean value to store

Constant.

{The example below demonstrates boolean values.,basic_json__boolean_t}

Since:: version 1.0.0

Definition at line 1246 of file json.hpp.

template<template< typename U, typename V, typename...Args > class ObjectType = std::map, template< typename U, typename...Args > class ArrayType = std::vector, class StringType = std::string, class BooleanType = bool, class NumberIntegerType = std::int64_t, class NumberUnsignedType = std::uint64_t, class NumberFloatType = double, template< typename U > class AllocatorType = std::allocator>

template<typename T , typename std::enable_if< not(std::is_same< T, int >::value) and std::is_same< T, number_integer_t >::value, int >::type = 0>

nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType >::basic_json ( const number_integer_t val ) [inline]

create an integer number (explicit)

Create an integer number JSON value with a given content.

Template Parameters:

T	A helper type to remove this function via SFINAE in case number_integer_t is the same as `int`. In this case, this constructor would have the same signature as basic_json(const int value). Note the helper type T is not visible in this constructor's interface.

Parameters:

[in] val an integer to create a JSON number from

Constant.

{The example below shows the construction of an integer number value.,basic_json__number_integer_t}

See also:: basic_json(const int) -- create a number value (integer); basic_json(const CompatibleNumberIntegerType) -- create a number value (integer) from a compatible number type

Since:: version 1.0.0

Definition at line 1279 of file json.hpp.

template<template< typename U, typename V, typename...Args > class ObjectType = std::map, template< typename U, typename...Args > class ArrayType = std::vector, class StringType = std::string, class BooleanType = bool, class NumberIntegerType = std::int64_t, class NumberUnsignedType = std::uint64_t, class NumberFloatType = double, template< typename U > class AllocatorType = std::allocator>

nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType >::basic_json ( const int val ) [inline]

create an integer number from an enum type (explicit)

Create an integer number JSON value with a given content.

Parameters:

[in] val an integer to create a JSON number from

Note:: This constructor allows to pass enums directly to a constructor. As C++ has no way of specifying the type of an anonymous enum explicitly, we can only rely on the fact that such values implicitly convert to int. As int may already be the same type of number_integer_t, we may need to switch off the constructor basic_json(const number_integer_t).

Constant.

{The example below shows the construction of an integer number value from an anonymous enum.,basic_json__const_int}

See also:: basic_json(const number_integer_t) -- create a number value (integer); basic_json(const CompatibleNumberIntegerType) -- create a number value (integer) from a compatible number type

Since:: version 1.0.0

Definition at line 1308 of file json.hpp.

template<template< typename U, typename V, typename...Args > class ObjectType = std::map, template< typename U, typename...Args > class ArrayType = std::vector, class StringType = std::string, class BooleanType = bool, class NumberIntegerType = std::int64_t, class NumberUnsignedType = std::uint64_t, class NumberFloatType = double, template< typename U > class AllocatorType = std::allocator>

template<typename CompatibleNumberIntegerType , typename std::enable_if< std::is_constructible< number_integer_t, CompatibleNumberIntegerType >::value andstd::numeric_limits< CompatibleNumberIntegerType >::is_integer andstd::numeric_limits< CompatibleNumberIntegerType >::is_signed, CompatibleNumberIntegerType >::type = 0>

nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType >::basic_json ( const CompatibleNumberIntegerType val ) [inline]

create an integer number (implicit)

Create an integer number JSON value with a given content. This constructor allows any type CompatibleNumberIntegerType that can be used to construct values of type number_integer_t.

Template Parameters:

CompatibleNumberIntegerType An integer type which is compatible to number_integer_t. Examples include the types `int`, `int32_t`, `long`, and `short`.

Parameters:

[in] val an integer to create a JSON number from

Constant.

{The example below shows the construction of several integer number values from compatible types.,basic_json__CompatibleIntegerNumberType}

See also:: basic_json(const number_integer_t) -- create a number value (integer); basic_json(const int) -- create a number value (integer)

Since:: version 1.0.0

Definition at line 1345 of file json.hpp.

template<template< typename U, typename V, typename...Args > class ObjectType = std::map, template< typename U, typename...Args > class ArrayType = std::vector, class StringType = std::string, class BooleanType = bool, class NumberIntegerType = std::int64_t, class NumberUnsignedType = std::uint64_t, class NumberFloatType = double, template< typename U > class AllocatorType = std::allocator>

template<typename T , typename std::enable_if< not(std::is_same< T, int >::value) and std::is_same< T, number_unsigned_t >::value, int >::type = 0>

nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType >::basic_json ( const number_unsigned_t val ) [inline]

create an unsigned integer number (explicit)

Create an unsigned integer number JSON value with a given content.

Template Parameters:

T	helper type to compare number_unsigned_t and unsigned int (not visible in) the interface.

Parameters:

[in] val an integer to create a JSON number from

Constant.

See also:: basic_json(const CompatibleNumberUnsignedType) -- create a number value (unsigned integer) from a compatible number type

Since:: version 2.0.0

Definition at line 1373 of file json.hpp.

template<template< typename U, typename V, typename...Args > class ObjectType = std::map, template< typename U, typename...Args > class ArrayType = std::vector, class StringType = std::string, class BooleanType = bool, class NumberIntegerType = std::int64_t, class NumberUnsignedType = std::uint64_t, class NumberFloatType = double, template< typename U > class AllocatorType = std::allocator>

template<typename CompatibleNumberUnsignedType , typename std::enable_if< std::is_constructible< number_unsigned_t, CompatibleNumberUnsignedType >::value andstd::numeric_limits< CompatibleNumberUnsignedType >::is_integer andnot std::numeric_limits< CompatibleNumberUnsignedType >::is_signed, CompatibleNumberUnsignedType >::type = 0>

nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType >::basic_json ( const CompatibleNumberUnsignedType val ) [inline]

create an unsigned number (implicit)

Create an unsigned number JSON value with a given content. This constructor allows any type CompatibleNumberUnsignedType that can be used to construct values of type number_unsigned_t.

Template Parameters:

CompatibleNumberUnsignedType An integer type which is compatible to number_unsigned_t. Examples may include the types `unsigned int`, `uint32_t`, or `unsigned short`.

Parameters:

[in] val an unsigned integer to create a JSON number from

Constant.

See also:: basic_json(const number_unsigned_t) -- create a number value (unsigned)

Since:: version 2.0.0

Definition at line 1404 of file json.hpp.

template<template< typename U, typename V, typename...Args > class ObjectType = std::map, template< typename U, typename...Args > class ArrayType = std::vector, class StringType = std::string, class BooleanType = bool, class NumberIntegerType = std::int64_t, class NumberUnsignedType = std::uint64_t, class NumberFloatType = double, template< typename U > class AllocatorType = std::allocator>

nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType >::basic_json ( const number_float_t val ) [inline]

create a floating-point number (explicit)

Create a floating-point number JSON value with a given content.

Parameters:

[in] val a floating-point value to create a JSON number from

Note:: [RFC 7159](http://www.rfc-editor.org/rfc/rfc7159.txt), section 6 disallows NaN values: > Numeric values that cannot be represented in the grammar below (such as > Infinity and NaN) are not permitted. In case the parameter val is not a number, a JSON null value is created instead.

Constant.

{The following example creates several floating-point values.,basic_json__number_float_t}

See also:: basic_json(const CompatibleNumberFloatType) -- create a number value (floating-point) from a compatible number type

Since:: version 1.0.0

Definition at line 1433 of file json.hpp.

template<template< typename U, typename V, typename...Args > class ObjectType = std::map, template< typename U, typename...Args > class ArrayType = std::vector, class StringType = std::string, class BooleanType = bool, class NumberIntegerType = std::int64_t, class NumberUnsignedType = std::uint64_t, class NumberFloatType = double, template< typename U > class AllocatorType = std::allocator>

template<typename CompatibleNumberFloatType , typename = typename std::enable_if< std::is_constructible<number_float_t, CompatibleNumberFloatType>::value and std::is_floating_point<CompatibleNumberFloatType>::value>::type>

nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType >::basic_json ( const CompatibleNumberFloatType val ) [inline]

create an floating-point number (implicit)

Create an floating-point number JSON value with a given content. This constructor allows any type CompatibleNumberFloatType that can be used to construct values of type number_float_t.

Template Parameters:

CompatibleNumberFloatType A floating-point type which is compatible to number_float_t. Examples may include the types `float` or `double`.

Parameters:

[in] val a floating-point to create a JSON number from

Note:: [RFC 7159](http://www.rfc-editor.org/rfc/rfc7159.txt), section 6 disallows NaN values: > Numeric values that cannot be represented in the grammar below (such as > Infinity and NaN) are not permitted. In case the parameter val is not a number, a JSON null value is created instead.

Constant.

{The example below shows the construction of several floating-point number values from compatible types.,basic_json__CompatibleNumberFloatType}

See also:: basic_json(const number_float_t) -- create a number value (floating-point)

Since:: version 1.0.0

Definition at line 1480 of file json.hpp.

template<template< typename U, typename V, typename...Args > class ObjectType = std::map, template< typename U, typename...Args > class ArrayType = std::vector, class StringType = std::string, class BooleanType = bool, class NumberIntegerType = std::int64_t, class NumberUnsignedType = std::uint64_t, class NumberFloatType = double, template< typename U > class AllocatorType = std::allocator>

nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType >::basic_json	(	std::initializer_list< basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType > >	init,
		bool	type_deduction = `true`,
		value_t	manual_type = `value_t::array`
	)		`[inline]`

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

Creates a JSON value of type array or object from the passed initializer list init. In case type_deduction is `true` (default), the type of the JSON value to be created is deducted from the initializer list init according to the following rules:

1. If the list is empty, an empty JSON object value `{}` is created. 2. If the list consists of pairs whose first element is a string, a JSON object value is created where the first elements of the pairs are treated as keys and the second elements are as values. 3. In all other cases, an array is created.

The rules aim to create the best fit between a C++ initializer list and JSON values. The rationale is as follows:

1. The empty initializer list is written as `{}` which is exactly an empty JSON object. 2. C++ has now way of describing mapped types other than to list a list of pairs. As JSON requires that keys must be of type string, rule 2 is the weakest constraint one can pose on initializer lists to interpret them as an object. 3. In all other cases, the initializer list could not be interpreted as JSON object type, so interpreting it as JSON array type is safe.

With the rules described above, the following JSON values cannot be expressed by an initializer list:

the empty array (`[]`): use array(std::initializer_list<basic_json>) with an empty initializer list in this case
arrays whose elements satisfy rule 2: use array(std::initializer_list<basic_json>) with the same initializer list in this case

Note:: When used without parentheses around an empty initializer list, basic_json() is called instead of this function, yielding the JSON null value.

Parameters:

[in]	init	initializer list with JSON values
[in]	type_deduction	internal parameter; when set to `true`, the type of the JSON value is deducted from the initializer list init; when set to `false`, the type provided via manual_type is forced. This mode is used by the functions array(std::initializer_list<basic_json>) and object(std::initializer_list<basic_json>).
[in]	manual_type	internal parameter; when type_deduction is set to `false`, the created JSON value will use the provided type (only value_t::array and value_t::object are valid); when type_deduction is set to `true`, this parameter has no effect

Exceptions:

std::domain_error if type_deduction is `false`, manual_type is `value_t::object`, but init contains an element which is not a pair whose first element is a string; example: `"cannot create object from initializer list"`

Linear in the size of the initializer list init.

{The example below shows how JSON values are created from initializer lists.,basic_json__list_init_t}

See also:: array(std::initializer_list<basic_json>) -- create a JSON array value from an initializer list; object(std::initializer_list<basic_json>) -- create a JSON object value from an initializer list

Since:: version 1.0.0

Definition at line 1553 of file json.hpp.

template<template< typename U, typename V, typename...Args > class ObjectType = std::map, template< typename U, typename...Args > class ArrayType = std::vector, class StringType = std::string, class BooleanType = bool, class NumberIntegerType = std::int64_t, class NumberUnsignedType = std::uint64_t, class NumberFloatType = double, template< typename U > class AllocatorType = std::allocator>

nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType >::basic_json	(	size_type	cnt,
		const basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType > &	val
	)		`[inline]`

construct an array with count copies of given value

Constructs a JSON array value by creating cnt copies of a passed value. In case cnt is `0`, an empty array is created. As postcondition, `stddistance(begin(),end()) == cnt` holds.

Parameters:

[in]	cnt	the number of JSON copies of val to create
[in]	val	the JSON value to copy

Linear in cnt.

{The following code shows examples for the basic_json(size_type\, const basic_json&) constructor.,basic_json__size_type_basic_json}

Since:: version 1.0.0

Definition at line 1709 of file json.hpp.

template<template< typename U, typename V, typename...Args > class ObjectType = std::map, template< typename U, typename...Args > class ArrayType = std::vector, class StringType = std::string, class BooleanType = bool, class NumberIntegerType = std::int64_t, class NumberUnsignedType = std::uint64_t, class NumberFloatType = double, template< typename U > class AllocatorType = std::allocator>

template<class InputIT , typename std::enable_if< std::is_same< InputIT, typename basic_json_t::iterator >::value orstd::is_same< InputIT, typename basic_json_t::const_iterator >::value, int >::type = 0>

nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType >::basic_json	(	InputIT	first,
		InputIT	last
	)		`[inline]`

construct a JSON container given an iterator range

Constructs the JSON value with the contents of the range `[first, last)`. The semantics depends on the different types a JSON value can have:

In case of primitive types (number, boolean, or string), first must be `begin()` and last must be `end()`. In this case, the value is copied. Otherwise, std::out_of_range is thrown.
In case of structured types (array, object), the constructor behaves as similar versions for `std::vector`.
In case of a null type, std::domain_error is thrown.

Template Parameters:

InputIT an input iterator type (iterator or const_iterator)

Parameters:

[in]	first	begin of the range to copy from (included)
[in]	last	end of the range to copy from (excluded)

Exceptions:

std::domain_error	if iterators are not compatible; that is, do not belong to the same JSON value; example: `"iterators are not compatible"`
std::out_of_range	if iterators are for a primitive type (number, boolean, or string) where an out of range error can be detected easily; example: `"iterators out of range"`
std::bad_alloc	if allocation for object, array, or string fails
std::domain_error	if called with a null value; example: `"cannot use construct with iterators from null"`

Linear in distance between first and last.

{The example below shows several ways to create JSON values by specifying a subrange with iterators.,basic_json__InputIt_InputIt}

Since:: version 1.0.0

Definition at line 1755 of file json.hpp.

template<template< typename U, typename V, typename...Args > class ObjectType = std::map, template< typename U, typename...Args > class ArrayType = std::vector, class StringType = std::string, class BooleanType = bool, class NumberIntegerType = std::int64_t, class NumberUnsignedType = std::uint64_t, class NumberFloatType = double, template< typename U > class AllocatorType = std::allocator>

nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType >::basic_json	(	std::istream &	i,
		parser_callback_t	cb = `nullptr`
	)		`[inline, explicit]`

construct a JSON value given an input stream

Parameters:

[in,out]	i	stream to read a serialized JSON value from
[in]	cb	a parser callback function of type parser_callback_t which is used to control the deserialization by filtering unwanted values (optional)

Linear in the length of the input. The parser is a predictive LL(1) parser. The complexity can be higher if the parser callback function cb has a super-linear complexity.

Note:: A UTF-8 byte order mark is silently ignored.

{The example below demonstrates constructing a JSON value from a `std::stringstream` with and without callback function.,basic_json__istream}

Since:: version 2.0.0

Definition at line 1862 of file json.hpp.

template<template< typename U, typename V, typename...Args > class ObjectType = std::map, template< typename U, typename...Args > class ArrayType = std::vector, class StringType = std::string, class BooleanType = bool, class NumberIntegerType = std::int64_t, class NumberUnsignedType = std::uint64_t, class NumberFloatType = double, template< typename U > class AllocatorType = std::allocator>

nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType >::basic_json ( const basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType > & other ) [inline]

copy constructor

Creates a copy of a given JSON value.

Parameters:

[in] other the JSON value to copy

Linear in the size of other.

This function helps `basic_json` satisfying the [Container](http://en.cppreference.com/w/cpp/concept/Container) requirements:

The complexity is linear.
As postcondition, it holds: `other == basic_json(other)`.

Exceptions:

std::bad_alloc if allocation for object, array, or string fails.

{The following code shows an example for the copy constructor.,basic_json__basic_json}

Since:: version 1.0.0

Definition at line 1893 of file json.hpp.

template<template< typename U, typename V, typename...Args > class ObjectType = std::map, template< typename U, typename...Args > class ArrayType = std::vector, class StringType = std::string, class BooleanType = bool, class NumberIntegerType = std::int64_t, class NumberUnsignedType = std::uint64_t, class NumberFloatType = double, template< typename U > class AllocatorType = std::allocator>

nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType >::basic_json ( basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType > && other ) [inline]

move constructor

Move constructor. Constructs a JSON value with the contents of the given value other using move semantics. It "steals" the resources from other and leaves it as JSON null value.

Parameters:

[in,out] other value to move to this object

Postcondition:: other is a JSON null value

Constant.

{The code below shows the move constructor explicitly called via std::move.,basic_json__moveconstructor}

Since:: version 1.0.0

Definition at line 1968 of file json.hpp.

template<template< typename U, typename V, typename...Args > class ObjectType = std::map, template< typename U, typename...Args > class ArrayType = std::vector, class StringType = std::string, class BooleanType = bool, class NumberIntegerType = std::int64_t, class NumberUnsignedType = std::uint64_t, class NumberFloatType = double, template< typename U > class AllocatorType = std::allocator>

nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType >::~basic_json ( ) [inline]

destructor

Destroys the JSON value and frees all allocated memory.

Linear.

This function helps `basic_json` satisfying the [Container](http://en.cppreference.com/w/cpp/concept/Container) requirements:

The complexity is linear.
All stored elements are destroyed and all memory is freed.

Since:: version 1.0.0

Definition at line 2028 of file json.hpp.

Member Function Documentation

template<template< typename U, typename V, typename...Args > class ObjectType = std::map, template< typename U, typename...Args > class ArrayType = std::vector, class StringType = std::string, class BooleanType = bool, class NumberIntegerType = std::int64_t, class NumberUnsignedType = std::uint64_t, class NumberFloatType = double, template< typename U > class AllocatorType = std::allocator>

static basic_json nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType >::array ( std::initializer_list< basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType > > init = std::initializer_list<basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType >>() ) [inline, static]

explicitly create an array from an initializer list

Creates a JSON array value from a given initializer list. That is, given a list of values `a, b, c`, creates the JSON value `[a, b, c]`. If the initializer list is empty, the empty array `[]` is created.

Note:: This function is only needed to express two edge cases that cannot be realized with the initializer list constructor (basic_json(std::initializer_list<basic_json>, bool, value_t)). These cases are: 1. creating an array whose elements are all pairs whose first element is a string -- in this case, the initializer list constructor would create an object, taking the first elements as keys 2. creating an empty array -- passing the empty initializer list to the initializer list constructor yields an empty object

Parameters:

[in] init initializer list with JSON values to create an array from (optional)

Returns:: JSON array value

Linear in the size of init.

{The following code shows an example for the `array` function.,array}

See also:: basic_json(std::initializer_list<basic_json>, bool, value_t) -- create a JSON value from an initializer list; object(std::initializer_list<basic_json>) -- create a JSON object value from an initializer list

Since:: version 1.0.0

Definition at line 1645 of file json.hpp.

template<template< typename U, typename V, typename...Args > class ObjectType = std::map, template< typename U, typename...Args > class ArrayType = std::vector, class StringType = std::string, class BooleanType = bool, class NumberIntegerType = std::int64_t, class NumberUnsignedType = std::uint64_t, class NumberFloatType = double, template< typename U > class AllocatorType = std::allocator>

reference nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType >::at ( size_type idx ) [inline]

access specified array element with bounds checking

Returns a reference to the element at specified location idx, with bounds checking.

Parameters:

[in] idx index of the element to access

Returns:: reference to the element at index idx

Exceptions:

std::domain_error	if the JSON value is not an array; example: `"cannot use at() with string"`
std::out_of_range	if the index idx is out of range of the array; that is, `idx >= size()`; example: `"array index 7 is out of range"`

Constant.

{The example below shows how array elements can be read and written using `at()`.,at__size_type}

Since:: version 1.0.0

Definition at line 3037 of file json.hpp.

template<template< typename U, typename V, typename...Args > class ObjectType = std::map, template< typename U, typename...Args > class ArrayType = std::vector, class StringType = std::string, class BooleanType = bool, class NumberIntegerType = std::int64_t, class NumberUnsignedType = std::uint64_t, class NumberFloatType = double, template< typename U > class AllocatorType = std::allocator>

const_reference nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType >::at ( size_type idx ) const [inline]

access specified array element with bounds checking

Returns a const reference to the element at specified location idx, with bounds checking.

Parameters:

[in] idx index of the element to access

Returns:: const reference to the element at index idx

Exceptions:

std::domain_error	if the JSON value is not an array; example: `"cannot use at() with string"`
std::out_of_range	if the index idx is out of range of the array; that is, `idx >= size()`; example: `"array index 7 is out of range"`

Constant.

{The example below shows how array elements can be read using `at()`.,at__size_type_const}

Since:: version 1.0.0

Definition at line 3081 of file json.hpp.

template<template< typename U, typename V, typename...Args > class ObjectType = std::map, template< typename U, typename...Args > class ArrayType = std::vector, class StringType = std::string, class BooleanType = bool, class NumberIntegerType = std::int64_t, class NumberUnsignedType = std::uint64_t, class NumberFloatType = double, template< typename U > class AllocatorType = std::allocator>

reference nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType >::at ( const typename object_t::key_type & key ) [inline]

access specified object element with bounds checking

Returns a reference to the element at with specified key key, with bounds checking.

Parameters:

[in] key key of the element to access

Returns:: reference to the element at key key

Exceptions:

std::domain_error	if the JSON value is not an object; example: `"cannot use at() with boolean"`
std::out_of_range	if the key key is is not stored in the object; that is, `find(key) == end()`; example: `"key "the fast" not found"`

Logarithmic in the size of the container.

{The example below shows how object elements can be read and written using `at()`.,at__object_t_key_type}

See also:: operator[](const typename object_t::key_type&) for unchecked access by reference; value() for access by value with a default value

Since:: version 1.0.0

Definition at line 3129 of file json.hpp.

template<template< typename U, typename V, typename...Args > class ObjectType = std::map, template< typename U, typename...Args > class ArrayType = std::vector, class StringType = std::string, class BooleanType = bool, class NumberIntegerType = std::int64_t, class NumberUnsignedType = std::uint64_t, class NumberFloatType = double, template< typename U > class AllocatorType = std::allocator>

const_reference nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType >::at ( const typename object_t::key_type & key ) const [inline]

access specified object element with bounds checking

Returns a const reference to the element at with specified key key, with bounds checking.

Parameters:

[in] key key of the element to access

Returns:: const reference to the element at key key

Exceptions:

std::domain_error	if the JSON value is not an object; example: `"cannot use at() with boolean"`
std::out_of_range	if the key key is is not stored in the object; that is, `find(key) == end()`; example: `"key "the fast" not found"`

Logarithmic in the size of the container.

{The example below shows how object elements can be read using `at()`.,at__object_t_key_type_const}

See also:: operator[](const typename object_t::key_type&) for unchecked access by reference; value() for access by value with a default value

Since:: version 1.0.0

Definition at line 3177 of file json.hpp.

template<template< typename U, typename V, typename...Args > class ObjectType = std::map, template< typename U, typename...Args > class ArrayType = std::vector, class StringType = std::string, class BooleanType = bool, class NumberIntegerType = std::int64_t, class NumberUnsignedType = std::uint64_t, class NumberFloatType = double, template< typename U > class AllocatorType = std::allocator>

reference nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType >::at ( const json_pointer & ptr ) [inline]

access specified element via JSON Pointer

Returns a reference to the element at with specified JSON pointer ptr, with bounds checking.

Parameters:

[in] ptr JSON pointer to the desired element

Returns:: reference to the element pointed to by ptr

Constant.

Exceptions:

std::out_of_range	if the JSON pointer can not be resolved
std::domain_error	if an array index begins with '0'
std::invalid_argument	if an array index was not a number

{The behavior is shown in the example.,at_json_pointer}

Since:: version 2.0.0

Definition at line 9379 of file json.hpp.

template<template< typename U, typename V, typename...Args > class ObjectType = std::map, template< typename U, typename...Args > class ArrayType = std::vector, class StringType = std::string, class BooleanType = bool, class NumberIntegerType = std::int64_t, class NumberUnsignedType = std::uint64_t, class NumberFloatType = double, template< typename U > class AllocatorType = std::allocator>

const_reference nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType >::at ( const json_pointer & ptr ) const [inline]

access specified element via JSON Pointer

Returns a const reference to the element at with specified JSON pointer ptr, with bounds checking.

Parameters:

[in] ptr JSON pointer to the desired element

Returns:: reference to the element pointed to by ptr

Constant.

Exceptions:

std::out_of_range	if the JSON pointer can not be resolved
std::domain_error	if an array index begins with '0'
std::invalid_argument	if an array index was not a number

{The behavior is shown in the example.,at_json_pointer_const}

Since:: version 2.0.0

Definition at line 9404 of file json.hpp.

template<template< typename U, typename V, typename...Args > class ObjectType = std::map, template< typename U, typename...Args > class ArrayType = std::vector, class StringType = std::string, class BooleanType = bool, class NumberIntegerType = std::int64_t, class NumberUnsignedType = std::uint64_t, class NumberFloatType = double, template< typename U > class AllocatorType = std::allocator>

reference nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType >::back ( ) [inline]

access the last element

Returns a reference to the last element in the container. For a JSON container `c`, the expression `c.back()` is equivalent to

 {.cpp}
    auto tmp = c.end();
    --tmp;
    return *tmp;

Returns:: In case of a structured type (array or object), a reference to the last element is returned. In cast of number, string, or boolean values, a reference to the value is returned.

Constant.

Precondition:: The JSON value must not be `null` (would throw `std::out_of_range`) or an empty array or object (undefined behavior, guarded by assertions).

Postcondition:: The JSON value remains unchanged.

Exceptions:

std::out_of_range when called on `null` value.

{The following code shows an example for `back()`.,back}

See also:: front() -- access the first element

Since:: version 1.0.0

Definition at line 3683 of file json.hpp.

template<template< typename U, typename V, typename...Args > class ObjectType = std::map, template< typename U, typename...Args > class ArrayType = std::vector, class StringType = std::string, class BooleanType = bool, class NumberIntegerType = std::int64_t, class NumberUnsignedType = std::uint64_t, class NumberFloatType = double, template< typename U > class AllocatorType = std::allocator>

const_reference nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType >::back ( ) const [inline]

access the last element

Returns a reference to the last element in the container. For a JSON container `c`, the expression `c.back()` is equivalent to

 {.cpp}
    auto tmp = c.end();
    --tmp;
    return *tmp;

Returns:: In case of a structured type (array or object), a reference to the last element is returned. In cast of number, string, or boolean values, a reference to the value is returned.

Constant.

Precondition:: The JSON value must not be `null` (would throw `std::out_of_range`) or an empty array or object (undefined behavior, guarded by assertions).

Postcondition:: The JSON value remains unchanged.

Exceptions:

std::out_of_range when called on `null` value.

{The following code shows an example for `back()`.,back}

See also:: front() -- access the first element

Since:: version 1.0.0

Definition at line 3693 of file json.hpp.

template<template< typename U, typename V, typename...Args > class ObjectType = std::map, template< typename U, typename...Args > class ArrayType = std::vector, class StringType = std::string, class BooleanType = bool, class NumberIntegerType = std::int64_t, class NumberUnsignedType = std::uint64_t, class NumberFloatType = double, template< typename U > class AllocatorType = std::allocator>

iterator nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType >::begin ( ) [inline]

returns an iterator to the first element

Returns an iterator to the first element.

Illustration from cppreference.com

Returns:: iterator to the first element

Constant.

This function helps `basic_json` satisfying the [Container](http://en.cppreference.com/w/cpp/concept/Container) requirements:

The complexity is constant.

{The following code shows an example for `begin()`.,begin}

See also:: cbegin() -- returns a const iterator to the beginning; end() -- returns an iterator to the end; cend() -- returns a const iterator to the end

Since:: version 1.0.0

Definition at line 4120 of file json.hpp.

template<template< typename U, typename V, typename...Args > class ObjectType = std::map, template< typename U, typename...Args > class ArrayType = std::vector, class StringType = std::string, class BooleanType = bool, class NumberIntegerType = std::int64_t, class NumberUnsignedType = std::uint64_t, class NumberFloatType = double, template< typename U > class AllocatorType = std::allocator>

const_iterator nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType >::begin ( ) const [inline]

returns a const iterator to the first element

Returns a const iterator to the first element.

Illustration from cppreference.com

Returns:: const iterator to the first element

Constant.

This function helps `basic_json` satisfying the [Container](http://en.cppreference.com/w/cpp/concept/Container) requirements:

The complexity is constant.
Has the semantics of `const_cast<const basic_json&>(*this).begin()`.

{The following code shows an example for `cbegin()`.,cbegin}

See also:: begin() -- returns an iterator to the beginning; end() -- returns an iterator to the end; cend() -- returns a const iterator to the end

Since:: version 1.0.0

Definition at line 4130 of file json.hpp.

template<template< typename U, typename V, typename...Args > class ObjectType = std::map, template< typename U, typename...Args > class ArrayType = std::vector, class StringType = std::string, class BooleanType = bool, class NumberIntegerType = std::int64_t, class NumberUnsignedType = std::uint64_t, class NumberFloatType = double, template< typename U > class AllocatorType = std::allocator>

const_iterator nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType >::cbegin ( ) const [inline]

returns a const iterator to the first element

Returns a const iterator to the first element.

Illustration from cppreference.com

Returns:: const iterator to the first element

Constant.

This function helps `basic_json` satisfying the [Container](http://en.cppreference.com/w/cpp/concept/Container) requirements:

The complexity is constant.
Has the semantics of `const_cast<const basic_json&>(*this).begin()`.

{The following code shows an example for `cbegin()`.,cbegin}

See also:: begin() -- returns an iterator to the beginning; end() -- returns an iterator to the end; cend() -- returns a const iterator to the end

Since:: version 1.0.0

Definition at line 4160 of file json.hpp.

template<template< typename U, typename V, typename...Args > class ObjectType = std::map, template< typename U, typename...Args > class ArrayType = std::vector, class StringType = std::string, class BooleanType = bool, class NumberIntegerType = std::int64_t, class NumberUnsignedType = std::uint64_t, class NumberFloatType = double, template< typename U > class AllocatorType = std::allocator>

const_iterator nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType >::cend ( ) const [inline]

returns a const iterator to one past the last element

Returns a const iterator to one past the last element.

Illustration from cppreference.com

Returns:: const iterator one past the last element

Constant.

This function helps `basic_json` satisfying the [Container](http://en.cppreference.com/w/cpp/concept/Container) requirements:

The complexity is constant.
Has the semantics of `const_cast<const basic_json&>(*this).end()`.

{The following code shows an example for `cend()`.,cend}

See also:: end() -- returns an iterator to the end; begin() -- returns an iterator to the beginning; cbegin() -- returns a const iterator to the beginning

Since:: version 1.0.0

Definition at line 4231 of file json.hpp.

template<template< typename U, typename V, typename...Args > class ObjectType = std::map, template< typename U, typename...Args > class ArrayType = std::vector, class StringType = std::string, class BooleanType = bool, class NumberIntegerType = std::int64_t, class NumberUnsignedType = std::uint64_t, class NumberFloatType = double, template< typename U > class AllocatorType = std::allocator>

void nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType >::clear ( ) [inline]

clears the contents

Clears the content of a JSON value and resets it to the default value as if basic_json(value_t) would have been called:

Value type | initial value ----------- | ------------- null | `null` boolean | `false` string | `""` number | `0` object | `{}` array | `[]`

Note:: Floating-point numbers are set to `0.0` which will be serialized to `0`. The vale type remains number_float_t.

Linear in the size of the JSON value.

{The example below shows the effect of `clear()` to different JSON types.,clear}

Since:: version 1.0.0

Definition at line 4630 of file json.hpp.

template<template< typename U, typename V, typename...Args > class ObjectType = std::map, template< typename U, typename...Args > class ArrayType = std::vector, class StringType = std::string, class BooleanType = bool, class NumberIntegerType = std::int64_t, class NumberUnsignedType = std::uint64_t, class NumberFloatType = double, template< typename U > class AllocatorType = std::allocator>

size_type nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType >::count ( typename object_t::key_type key ) const [inline]

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

Returns the number of elements with key key. If ObjectType is the default `std::map` type, the return value will always be `0` (key was not found) or `1` (key was found).

Parameters:

[in] key key value of the element to count

Returns:: Number of elements with key key. If the JSON value is not an object, the return value will be `0`.

Logarithmic in the size of the JSON object.

{The example shows how `count()` is used.,count}

Since:: version 1.0.0

Definition at line 4079 of file json.hpp.

template<template< typename U, typename V, typename...Args > class ObjectType = std::map, template< typename U, typename...Args > class ArrayType = std::vector, class StringType = std::string, class BooleanType = bool, class NumberIntegerType = std::int64_t, class NumberUnsignedType = std::uint64_t, class NumberFloatType = double, template< typename U > class AllocatorType = std::allocator>

const_reverse_iterator nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType >::crbegin ( ) const [inline]

returns a const reverse iterator to the last element

Returns a const iterator to the reverse-beginning; that is, the last element.

Illustration from cppreference.com

Constant.

This function helps `basic_json` satisfying the [ReversibleContainer](http://en.cppreference.com/w/cpp/concept/ReversibleContainer) requirements:

The complexity is constant.
Has the semantics of `const_cast<const basic_json&>(*this).rbegin()`.

{The following code shows an example for `crbegin()`.,crbegin}

See also:: rbegin() -- returns a reverse iterator to the beginning; rend() -- returns a reverse iterator to the end; crend() -- returns a const reverse iterator to the end

Since:: version 1.0.0

Definition at line 4335 of file json.hpp.

template<template< typename U, typename V, typename...Args > class ObjectType = std::map, template< typename U, typename...Args > class ArrayType = std::vector, class StringType = std::string, class BooleanType = bool, class NumberIntegerType = std::int64_t, class NumberUnsignedType = std::uint64_t, class NumberFloatType = double, template< typename U > class AllocatorType = std::allocator>

template<typename T , typename... Args>

static T* nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType >::create ( Args &&... args ) [inline, static, private]

helper for exception-safe object creation

Definition at line 716 of file json.hpp.

template<template< typename U, typename V, typename...Args > class ObjectType = std::map, template< typename U, typename...Args > class ArrayType = std::vector, class StringType = std::string, class BooleanType = bool, class NumberIntegerType = std::int64_t, class NumberUnsignedType = std::uint64_t, class NumberFloatType = double, template< typename U > class AllocatorType = std::allocator>

const_reverse_iterator nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType >::crend ( ) const [inline]

returns a const reverse iterator to one before the first

Returns a const reverse iterator to the reverse-end; that is, one before the first element.

Illustration from cppreference.com

Constant.

This function helps `basic_json` satisfying the [ReversibleContainer](http://en.cppreference.com/w/cpp/concept/ReversibleContainer) requirements:

The complexity is constant.
Has the semantics of `const_cast<const basic_json&>(*this).rend()`.

{The following code shows an example for `crend()`.,crend}

See also:: rend() -- returns a reverse iterator to the end; rbegin() -- returns a reverse iterator to the beginning; crbegin() -- returns a const reverse iterator to the beginning

Since:: version 1.0.0

Definition at line 4364 of file json.hpp.

template<template< typename U, typename V, typename...Args > class ObjectType = std::map, template< typename U, typename...Args > class ArrayType = std::vector, class StringType = std::string, class BooleanType = bool, class NumberIntegerType = std::int64_t, class NumberUnsignedType = std::uint64_t, class NumberFloatType = double, template< typename U > class AllocatorType = std::allocator>

static basic_json nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType >::diff	(	const basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType > &	source,
		const basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType > &	target,
		std::string	path = `""`
	)		`[inline, static]`

creates a diff as a JSON patch

Creates a [JSON Patch](http://jsonpatch.com) so that value source can be changed into the value target by calling patch function.

Invariant:

For two JSON values source and target, the following code yields always `true`:

 {.cpp}
    source.patch(diff(source, target)) == target;

Note:: Currently, only `remove`, `add`, and `replace` operations are generated.

Parameters:

[in]	source	JSON value to copare from
[in]	target	JSON value to copare against
[in]	path	helper value to create JSON pointers

Returns:: a JSON patch to convert the source to target

Linear in the lengths of source and target.

{The following code shows how a JSON patch is created as a diff for two JSON values.,diff}

See also:: patch -- apply a JSON patch; [RFC 6902 (JSON Patch)](https://tools.ietf.org/html/rfc6902)

Since:: version 2.0.0

Definition at line 9808 of file json.hpp.

template<template< typename U, typename V, typename...Args > class ObjectType = std::map, template< typename U, typename...Args > class ArrayType = std::vector, class StringType = std::string, class BooleanType = bool, class NumberIntegerType = std::int64_t, class NumberUnsignedType = std::uint64_t, class NumberFloatType = double, template< typename U > class AllocatorType = std::allocator>

string_t nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType >::dump ( const int indent = -1 ) const [inline]

serialization

Serialization function for JSON values. The function tries to mimic Python's json.dumps() function, and currently supports its indent parameter.

Parameters:

[in] indent if indent is nonnegative, then array elements and object members will be pretty-printed with that indent level. An indent level of 0 will only insert newlines. -1 (the default) selects the most compact representation

Returns:: string containing the serialization of the JSON value

Linear.

{The following example shows the effect of different indent parameters to the result of the serialization.,dump}

See also:: https://docs.python.org/2/library/json.html#json.dump

Since:: version 1.0.0

Definition at line 2097 of file json.hpp.

template<template< typename U, typename V, typename...Args > class ObjectType = std::map, template< typename U, typename...Args > class ArrayType = std::vector, class StringType = std::string, class BooleanType = bool, class NumberIntegerType = std::int64_t, class NumberUnsignedType = std::uint64_t, class NumberFloatType = double, template< typename U > class AllocatorType = std::allocator>

void nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType >::dump	(	std::ostream &	o,
		const bool	pretty_print,
		const unsigned int	indent_step,
		const unsigned int	current_indent = `0`
	)		const `[inline, private]`

internal implementation of the serialization function

This function is called by the public member function dump and organizes the serialization internally. The indentation level is propagated as additional parameter. In case of arrays and objects, the function is called recursively. Note that

strings and object keys are escaped using `escape_string()`
integer numbers are converted implicitly via `operator<<`
floating-point numbers are converted to a string using `"%g"` format

Parameters:

[out]	o	stream to write to
[in]	pretty_print	whether the output shall be pretty-printed
[in]	indent_step	the indent level
[in]	current_indent	the current indent level (only used internally)

Definition at line 6000 of file json.hpp.

template<template< typename U, typename V, typename...Args > class ObjectType = std::map, template< typename U, typename...Args > class ArrayType = std::vector, class StringType = std::string, class BooleanType = bool, class NumberIntegerType = std::int64_t, class NumberUnsignedType = std::uint64_t, class NumberFloatType = double, template< typename U > class AllocatorType = std::allocator>

bool nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType >::empty ( ) const [inline]

checks whether the container is empty

Checks if a JSON value has no elements.

Returns:: The return value depends on the different types and is defined as follows: Value type | return value ----------- | ------------- null | `true` boolean | `false` string | `false` number | `false` object | result of function `object_t::empty()` array | result of function `array_t::empty()`

Constant, as long as array_t and object_t satisfy the Container concept; that is, their `empty()` functions have constant complexity.

This function helps `basic_json` satisfying the [Container](http://en.cppreference.com/w/cpp/concept/Container) requirements:

The complexity is constant.
Has the semantics of `begin() == end()`.

{The following code uses `empty()` to check if a JSON object contains any elements.,empty}

See also:: size() -- returns the number of elements

Since:: version 1.0.0

Definition at line 4441 of file json.hpp.

template<template< typename U, typename V, typename...Args > class ObjectType = std::map, template< typename U, typename...Args > class ArrayType = std::vector, class StringType = std::string, class BooleanType = bool, class NumberIntegerType = std::int64_t, class NumberUnsignedType = std::uint64_t, class NumberFloatType = double, template< typename U > class AllocatorType = std::allocator>

iterator nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType >::end ( ) [inline]

returns an iterator to one past the last element

Returns an iterator to one past the last element.

Illustration from cppreference.com

Returns:: iterator one past the last element

Constant.

This function helps `basic_json` satisfying the [Container](http://en.cppreference.com/w/cpp/concept/Container) requirements:

The complexity is constant.

{The following code shows an example for `end()`.,end}

See also:: cend() -- returns a const iterator to the end; begin() -- returns an iterator to the beginning; cbegin() -- returns a const iterator to the beginning

Since:: version 1.0.0

Definition at line 4191 of file json.hpp.

template<template< typename U, typename V, typename...Args > class ObjectType = std::map, template< typename U, typename...Args > class ArrayType = std::vector, class StringType = std::string, class BooleanType = bool, class NumberIntegerType = std::int64_t, class NumberUnsignedType = std::uint64_t, class NumberFloatType = double, template< typename U > class AllocatorType = std::allocator>

const_iterator nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType >::end ( ) const [inline]

returns a const iterator to one past the last element

Returns a const iterator to one past the last element.

Illustration from cppreference.com

Returns:: const iterator one past the last element

Constant.

This function helps `basic_json` satisfying the [Container](http://en.cppreference.com/w/cpp/concept/Container) requirements:

The complexity is constant.
Has the semantics of `const_cast<const basic_json&>(*this).end()`.

{The following code shows an example for `cend()`.,cend}

See also:: end() -- returns an iterator to the end; begin() -- returns an iterator to the beginning; cbegin() -- returns a const iterator to the beginning

Since:: version 1.0.0

Definition at line 4201 of file json.hpp.

template<template< typename U, typename V, typename...Args > class ObjectType = std::map, template< typename U, typename...Args > class ArrayType = std::vector, class StringType = std::string, class BooleanType = bool, class NumberIntegerType = std::int64_t, class NumberUnsignedType = std::uint64_t, class NumberFloatType = double, template< typename U > class AllocatorType = std::allocator>

template<class InteratorType , typename std::enable_if< std::is_same< InteratorType, typename basic_json_t::iterator >::value orstd::is_same< InteratorType, typename basic_json_t::const_iterator >::value, int >::type = 0>

InteratorType nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType >::erase ( InteratorType pos ) [inline]

remove element given an iterator

Removes the element specified by iterator pos. The iterator pos must be valid and dereferenceable. Thus the `end()` iterator (which is valid, but is not dereferenceable) cannot be used as a value for pos.

If called on a primitive type other than `null`, the resulting JSON value will be `null`.

Parameters:

[in] pos iterator to the element to remove

Returns:: Iterator following the last removed element. If the iterator pos refers to the last element, the `end()` iterator is returned.

Template Parameters:

InteratorType an iterator or const_iterator

Postcondition:: Invalidates iterators and references at or after the point of the erase, including the `end()` iterator.

Exceptions:

std::domain_error	if called on a `null` value; example: `"cannot use erase() with null"`
std::domain_error	if called on an iterator which does not belong to the current JSON value; example: `"iterator does not fit current value"`
std::out_of_range	if called on a primitive type with invalid iterator (i.e., any iterator which is not `begin()`); example: `"iterator out of range"`

The complexity depends on the type:

objects: amortized constant
arrays: linear in distance between pos and the end of the container
strings: linear in the length of the string
other types: constant

{The example shows the result of `erase()` for different JSON types.,erase__IteratorType}

See also:: erase(InteratorType, InteratorType) -- removes the elements in the given range; erase(const typename object_t::key_type&) -- removes the element from an object at the given key; erase(const size_type) -- removes the element from an array at the given index

Since:: version 1.0.0

Definition at line 3751 of file json.hpp.

template<template< typename U, typename V, typename...Args > class ObjectType = std::map, template< typename U, typename...Args > class ArrayType = std::vector, class StringType = std::string, class BooleanType = bool, class NumberIntegerType = std::int64_t, class NumberUnsignedType = std::uint64_t, class NumberFloatType = double, template< typename U > class AllocatorType = std::allocator>

template<class InteratorType , typename std::enable_if< std::is_same< InteratorType, typename basic_json_t::iterator >::value orstd::is_same< InteratorType, typename basic_json_t::const_iterator >::value, int >::type = 0>

InteratorType nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType >::erase	(	InteratorType	first,
		InteratorType	last
	)		`[inline]`

remove elements given an iterator range

Removes the element specified by the range `[first; last)`. The iterator first does not need to be dereferenceable if `first == last`: erasing an empty range is a no-op.

If called on a primitive type other than `null`, the resulting JSON value will be `null`.

Parameters:

[in]	first	iterator to the beginning of the range to remove
[in]	last	iterator past the end of the range to remove

Returns:: Iterator following the last removed element. If the iterator second refers to the last element, the `end()` iterator is returned.

Template Parameters:

InteratorType an iterator or const_iterator

Postcondition:: Invalidates iterators and references at or after the point of the erase, including the `end()` iterator.

Exceptions:

std::domain_error	if called on a `null` value; example: `"cannot use erase() with null"`
std::domain_error	if called on iterators which does not belong to the current JSON value; example: `"iterators do not fit current value"`
std::out_of_range	if called on a primitive type with invalid iterators (i.e., if `first != begin()` and `last != end()`); example: `"iterators out of range"`

The complexity depends on the type:

objects: `log(size()) + std::distance(first, last)`
arrays: linear in the distance between first and last, plus linear in the distance between last and end of the container
strings: linear in the length of the string
other types: constant

{The example shows the result of `erase()` for different JSON types.,erase__IteratorType_IteratorType}

See also:: erase(InteratorType) -- removes the element at a given position; erase(const typename object_t::key_type&) -- removes the element from an object at the given key; erase(const size_type) -- removes the element from an array at the given index

Since:: version 1.0.0

Definition at line 3859 of file json.hpp.

template<template< typename U, typename V, typename...Args > class ObjectType = std::map, template< typename U, typename...Args > class ArrayType = std::vector, class StringType = std::string, class BooleanType = bool, class NumberIntegerType = std::int64_t, class NumberUnsignedType = std::uint64_t, class NumberFloatType = double, template< typename U > class AllocatorType = std::allocator>

size_type nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType >::erase ( const typename object_t::key_type & key ) [inline]

remove element from a JSON object given a key

Removes elements from a JSON object with the key value key.

Parameters:

[in] key value of the elements to remove

Returns:: Number of elements removed. If ObjectType is the default `std::map` type, the return value will always be `0` (key was not found) or `1` (key was found).

Postcondition:: References and iterators to the erased elements are invalidated. Other references and iterators are not affected.

Exceptions:

std::domain_error when called on a type other than JSON object; example: `"cannot use erase() with null"`

`log(size()) + count(key)`

{The example shows the effect of `erase()`.,erase__key_type}

See also:: erase(InteratorType) -- removes the element at a given position; erase(InteratorType, InteratorType) -- removes the elements in the given range; erase(const size_type) -- removes the element from an array at the given index

Since:: version 1.0.0

Definition at line 3946 of file json.hpp.

template<template< typename U, typename V, typename...Args > class ObjectType = std::map, template< typename U, typename...Args > class ArrayType = std::vector, class StringType = std::string, class BooleanType = bool, class NumberIntegerType = std::int64_t, class NumberUnsignedType = std::uint64_t, class NumberFloatType = double, template< typename U > class AllocatorType = std::allocator>

void nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType >::erase ( const size_type idx ) [inline]

remove element from a JSON array given an index

Removes element from a JSON array at the index idx.

Parameters:

[in] idx index of the element to remove

Exceptions:

std::domain_error	when called on a type other than JSON array; example: `"cannot use erase() with null"`
std::out_of_range	when `idx >= size()`; example: `"array index 17 is out of range"`

Linear in distance between idx and the end of the container.

{The example shows the effect of `erase()`.,erase__size_type}

See also:: erase(InteratorType) -- removes the element at a given position; erase(InteratorType, InteratorType) -- removes the elements in the given range; erase(const typename object_t::key_type&) -- removes the element from an object at the given key

Since:: version 1.0.0

Definition at line 3984 of file json.hpp.

template<template< typename U, typename V, typename...Args > class ObjectType = std::map, template< typename U, typename...Args > class ArrayType = std::vector, class StringType = std::string, class BooleanType = bool, class NumberIntegerType = std::int64_t, class NumberUnsignedType = std::uint64_t, class NumberFloatType = double, template< typename U > class AllocatorType = std::allocator>

static string_t nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType >::escape_string ( const string_t & s ) [inline, static, private]

escape a string

Escape a string by replacing certain special characters by a sequence of an escape character (backslash) and another character and other control characters by a sequence of "\u" followed by a four-digit hex representation.

Parameters:

[in] s the string to escape

Returns:: the escaped string

Linear in the length of string s.

Definition at line 5875 of file json.hpp.

template<template< typename U, typename V, typename...Args > class ObjectType = std::map, template< typename U, typename...Args > class ArrayType = std::vector, class StringType = std::string, class BooleanType = bool, class NumberIntegerType = std::int64_t, class NumberUnsignedType = std::uint64_t, class NumberFloatType = double, template< typename U > class AllocatorType = std::allocator>

static std::size_t nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType >::extra_space ( const string_t & s ) [inline, static, private]

calculates the extra space to escape a JSON string

Parameters:

[in] s the string to escape

Returns:: the number of characters required to escape string s

Linear in the length of string s.

Definition at line 5826 of file json.hpp.

template<template< typename U, typename V, typename...Args > class ObjectType = std::map, template< typename U, typename...Args > class ArrayType = std::vector, class StringType = std::string, class BooleanType = bool, class NumberIntegerType = std::int64_t, class NumberUnsignedType = std::uint64_t, class NumberFloatType = double, template< typename U > class AllocatorType = std::allocator>

iterator nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType >::find ( typename object_t::key_type key ) [inline]

find an element in a JSON object

Finds an element in a JSON object with key equivalent to key. If the element is not found or the JSON value is not an object, end() is returned.

Parameters:

[in] key key value of the element to search for

Returns:: Iterator to an element with key equivalent to key. If no such element is found, past-the-end (see end()) iterator is returned.

Logarithmic in the size of the JSON object.

{The example shows how `find()` is used.,find__key_type}

Since:: version 1.0.0

Definition at line 4031 of file json.hpp.

template<template< typename U, typename V, typename...Args > class ObjectType = std::map, template< typename U, typename...Args > class ArrayType = std::vector, class StringType = std::string, class BooleanType = bool, class NumberIntegerType = std::int64_t, class NumberUnsignedType = std::uint64_t, class NumberFloatType = double, template< typename U > class AllocatorType = std::allocator>

const_iterator nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType >::find ( typename object_t::key_type key ) const [inline]

find an element in a JSON object

Finds an element in a JSON object with key equivalent to key. If the element is not found or the JSON value is not an object, end() is returned.

Parameters:

[in] key key value of the element to search for

Returns:: Iterator to an element with key equivalent to key. If no such element is found, past-the-end (see end()) iterator is returned.

Logarithmic in the size of the JSON object.

{The example shows how `find()` is used.,find__key_type}

Since:: version 1.0.0

Definition at line 4048 of file json.hpp.

template<template< typename U, typename V, typename...Args > class ObjectType = std::map, template< typename U, typename...Args > class ArrayType = std::vector, class StringType = std::string, class BooleanType = bool, class NumberIntegerType = std::int64_t, class NumberUnsignedType = std::uint64_t, class NumberFloatType = double, template< typename U > class AllocatorType = std::allocator>

basic_json nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType >::flatten ( ) const [inline]

return flattened JSON value

The function creates a JSON object whose keys are JSON pointers (see [RFC 6901](https://tools.ietf.org/html/rfc6901)) and whose values are all primitive. The original JSON value can be restored using the unflatten() function.

Returns:: an object that maps JSON pointers to primitve values

Note:: Empty objects and arrays are flattened to `null` and will not be reconstructed correctly by the unflatten() function.

Linear in the size the JSON value.

{The following code shows how a JSON object is flattened to an object whose keys consist of JSON pointers.,flatten}

See also:: unflatten() for the reverse function

Since:: version 2.0.0

Definition at line 9431 of file json.hpp.

template<template< typename U, typename V, typename...Args > class ObjectType = std::map, template< typename U, typename...Args > class ArrayType = std::vector, class StringType = std::string, class BooleanType = bool, class NumberIntegerType = std::int64_t, class NumberUnsignedType = std::uint64_t, class NumberFloatType = double, template< typename U > class AllocatorType = std::allocator>

reference nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType >::front ( ) [inline]

access the first element

Returns a reference to the first element in the container. For a JSON container `c`, the expression `c.front()` is equivalent to `*c.begin()`.

Returns:: In case of a structured type (array or object), a reference to the first element is returned. In cast of number, string, or boolean values, a reference to the value is returned.

Constant.

Precondition:: The JSON value must not be `null` (would throw `std::out_of_range`) or an empty array or object (undefined behavior, guarded by assertions).

Postcondition:: The JSON value remains unchanged.

Exceptions:

std::out_of_range when called on `null` value

{The following code shows an example for `front()`.,front}

See also:: back() -- access the last element

Since:: version 1.0.0

Definition at line 3641 of file json.hpp.

template<template< typename U, typename V, typename...Args > class ObjectType = std::map, template< typename U, typename...Args > class ArrayType = std::vector, class StringType = std::string, class BooleanType = bool, class NumberIntegerType = std::int64_t, class NumberUnsignedType = std::uint64_t, class NumberFloatType = double, template< typename U > class AllocatorType = std::allocator>

const_reference nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType >::front ( ) const [inline]

access the first element

Returns a reference to the first element in the container. For a JSON container `c`, the expression `c.front()` is equivalent to `*c.begin()`.

Returns:: In case of a structured type (array or object), a reference to the first element is returned. In cast of number, string, or boolean values, a reference to the value is returned.

Constant.

Precondition:: The JSON value must not be `null` (would throw `std::out_of_range`) or an empty array or object (undefined behavior, guarded by assertions).

Postcondition:: The JSON value remains unchanged.

Exceptions:

std::out_of_range when called on `null` value

{The following code shows an example for `front()`.,front}

See also:: back() -- access the last element

Since:: version 1.0.0

Definition at line 3649 of file json.hpp.

template<template< typename U, typename V, typename...Args > class ObjectType = std::map, template< typename U, typename...Args > class ArrayType = std::vector, class StringType = std::string, class BooleanType = bool, class NumberIntegerType = std::int64_t, class NumberUnsignedType = std::uint64_t, class NumberFloatType = double, template< typename U > class AllocatorType = std::allocator>

template<typename ValueType , typename std::enable_if< not std::is_pointer< ValueType >::value, int >::type = 0>

ValueType nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType >::get ( ) const [inline]

get a value (explicit)

Explicit type conversion between the JSON value and a compatible value.

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

Returns:: copy of the JSON value, converted to type ValueType

Exceptions:

std::domain_error in case passed type ValueType is incompatible to JSON; example: `"type must be object, but is null"`

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>`.,get__ValueType_const}

See also:: operator ValueType() const for implicit conversion; get() for pointer-member access

Since:: version 1.0.0

Definition at line 2807 of file json.hpp.

template<template< typename U, typename V, typename...Args > class ObjectType = std::map, template< typename U, typename...Args > class ArrayType = std::vector, class StringType = std::string, class BooleanType = bool, class NumberIntegerType = std::int64_t, class NumberUnsignedType = std::uint64_t, class NumberFloatType = double, template< typename U > class AllocatorType = std::allocator>

template<typename PointerType , typename std::enable_if< std::is_pointer< PointerType >::value, int >::type = 0>

PointerType nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType >::get ( ) [inline]

get a pointer value (explicit)

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

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

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}

See also:: get_ptr() for explicit pointer-member access

Since:: version 1.0.0

Definition at line 2842 of file json.hpp.

template<template< typename U, typename V, typename...Args > class ObjectType = std::map, template< typename U, typename...Args > class ArrayType = std::vector, class StringType = std::string, class BooleanType = bool, class NumberIntegerType = std::int64_t, class NumberUnsignedType = std::uint64_t, class NumberFloatType = double, template< typename U > class AllocatorType = std::allocator>

template<typename PointerType , typename std::enable_if< std::is_pointer< PointerType >::value, int >::type = 0>

constexpr const PointerType nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType >::get ( ) const [inline]

get a pointer value (explicit)

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

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

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}

See also:: get_ptr() for explicit pointer-member access

Since:: version 1.0.0

Definition at line 2856 of file json.hpp.

template<template< typename U, typename V, typename...Args > class ObjectType = std::map, template< typename U, typename...Args > class ArrayType = std::vector, class StringType = std::string, class BooleanType = bool, class NumberIntegerType = std::int64_t, class NumberUnsignedType = std::uint64_t, class NumberFloatType = double, template< typename U > class AllocatorType = std::allocator>

static allocator_type nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType >::get_allocator ( ) [inline, static]

returns the allocator associated with the container

Definition at line 248 of file json.hpp.

template<template< typename U, typename V, typename...Args > class ObjectType = std::map, template< typename U, typename...Args > class ArrayType = std::vector, class StringType = std::string, class BooleanType = bool, class NumberIntegerType = std::int64_t, class NumberUnsignedType = std::uint64_t, class NumberFloatType = double, template< typename U > class AllocatorType = std::allocator>

template<class T , typename std::enable_if< std::is_convertible< typename object_t::key_type, typename T::key_type >::value andstd::is_convertible< basic_json_t, typename T::mapped_type >::value, int >::type = 0>

T nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType >::get_impl ( T * ) const [inline, private]

get an object (explicit)

Definition at line 2481 of file json.hpp.

template<template< typename U, typename V, typename...Args > class ObjectType = std::map, template< typename U, typename...Args > class ArrayType = std::vector, class StringType = std::string, class BooleanType = bool, class NumberIntegerType = std::int64_t, class NumberUnsignedType = std::uint64_t, class NumberFloatType = double, template< typename U > class AllocatorType = std::allocator>

object_t nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType >::get_impl ( object_t * ) const [inline, private]

get an object (explicit)

Definition at line 2495 of file json.hpp.

template<template< typename U, typename V, typename...Args > class ObjectType = std::map, template< typename U, typename...Args > class ArrayType = std::vector, class StringType = std::string, class BooleanType = bool, class NumberIntegerType = std::int64_t, class NumberUnsignedType = std::uint64_t, class NumberFloatType = double, template< typename U > class AllocatorType = std::allocator>

template<class T , typename std::enable_if< std::is_convertible< basic_json_t, typename T::value_type >::value andnot std::is_same< basic_json_t, typename T::value_type >::value andnot std::is_arithmetic< T >::value andnot std::is_convertible< std::string, T >::value andnot has_mapped_type< T >::value, int >::type = 0>

T nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType >::get_impl ( T * ) const [inline, private]

get an array (explicit)

Definition at line 2517 of file json.hpp.

template<template< typename U, typename V, typename...Args > class ObjectType = std::map, template< typename U, typename...Args > class ArrayType = std::vector, class StringType = std::string, class BooleanType = bool, class NumberIntegerType = std::int64_t, class NumberUnsignedType = std::uint64_t, class NumberFloatType = double, template< typename U > class AllocatorType = std::allocator>

template<class T , typename std::enable_if< std::is_convertible< basic_json_t, T >::value andnot std::is_same< basic_json_t, T >::value, int >::type = 0>

std::vector<T> nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType >::get_impl ( std::vector< T > * ) const [inline, private]

get an array (explicit)

Definition at line 2542 of file json.hpp.

template<template< typename U, typename V, typename...Args > class ObjectType = std::map, template< typename U, typename...Args > class ArrayType = std::vector, class StringType = std::string, class BooleanType = bool, class NumberIntegerType = std::int64_t, class NumberUnsignedType = std::uint64_t, class NumberFloatType = double, template< typename U > class AllocatorType = std::allocator>

template<class T , typename std::enable_if< std::is_same< basic_json, typename T::value_type >::value andnot has_mapped_type< T >::value, int >::type = 0>

T nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType >::get_impl ( T * ) const [inline, private]

get an array (explicit)

Definition at line 2568 of file json.hpp.

template<template< typename U, typename V, typename...Args > class ObjectType = std::map, template< typename U, typename...Args > class ArrayType = std::vector, class StringType = std::string, class BooleanType = bool, class NumberIntegerType = std::int64_t, class NumberUnsignedType = std::uint64_t, class NumberFloatType = double, template< typename U > class AllocatorType = std::allocator>

array_t nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType >::get_impl ( array_t * ) const [inline, private]

get an array (explicit)

Definition at line 2582 of file json.hpp.

template<template< typename U, typename V, typename...Args > class ObjectType = std::map, template< typename U, typename...Args > class ArrayType = std::vector, class StringType = std::string, class BooleanType = bool, class NumberIntegerType = std::int64_t, class NumberUnsignedType = std::uint64_t, class NumberFloatType = double, template< typename U > class AllocatorType = std::allocator>

template<typename T , typename std::enable_if< std::is_convertible< string_t, T >::value, int >::type = 0>

T nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType >::get_impl ( T * ) const [inline, private]

get a string (explicit)

Definition at line 2600 of file json.hpp.

template<template< typename U, typename V, typename...Args > class ObjectType = std::map, template< typename U, typename...Args > class ArrayType = std::vector, class StringType = std::string, class BooleanType = bool, class NumberIntegerType = std::int64_t, class NumberUnsignedType = std::uint64_t, class NumberFloatType = double, template< typename U > class AllocatorType = std::allocator>

template<typename T , typename std::enable_if< std::is_arithmetic< T >::value, int >::type = 0>

T nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType >::get_impl ( T * ) const [inline, private]

get a number (explicit)

Definition at line 2618 of file json.hpp.

template<template< typename U, typename V, typename...Args > class ObjectType = std::map, template< typename U, typename...Args > class ArrayType = std::vector, class StringType = std::string, class BooleanType = bool, class NumberIntegerType = std::int64_t, class NumberUnsignedType = std::uint64_t, class NumberFloatType = double, template< typename U > class AllocatorType = std::allocator>

constexpr boolean_t nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType >::get_impl ( boolean_t * ) const [inline, private]

get a boolean (explicit)

Definition at line 2645 of file json.hpp.

template<template< typename U, typename V, typename...Args > class ObjectType = std::map, template< typename U, typename...Args > class ArrayType = std::vector, class StringType = std::string, class BooleanType = bool, class NumberIntegerType = std::int64_t, class NumberUnsignedType = std::uint64_t, class NumberFloatType = double, template< typename U > class AllocatorType = std::allocator>

object_t* nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType >::get_impl_ptr ( object_t * ) [inline, private]

get a pointer to the value (object)

Definition at line 2653 of file json.hpp.

template<template< typename U, typename V, typename...Args > class ObjectType = std::map, template< typename U, typename...Args > class ArrayType = std::vector, class StringType = std::string, class BooleanType = bool, class NumberIntegerType = std::int64_t, class NumberUnsignedType = std::uint64_t, class NumberFloatType = double, template< typename U > class AllocatorType = std::allocator>

constexpr const object_t* nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType >::get_impl_ptr ( const object_t * ) const [inline, private]

get a pointer to the value (object)

Definition at line 2659 of file json.hpp.

template<template< typename U, typename V, typename...Args > class ObjectType = std::map, template< typename U, typename...Args > class ArrayType = std::vector, class StringType = std::string, class BooleanType = bool, class NumberIntegerType = std::int64_t, class NumberUnsignedType = std::uint64_t, class NumberFloatType = double, template< typename U > class AllocatorType = std::allocator>

array_t* nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType >::get_impl_ptr ( array_t * ) [inline, private]

get a pointer to the value (array)

Definition at line 2665 of file json.hpp.

template<template< typename U, typename V, typename...Args > class ObjectType = std::map, template< typename U, typename...Args > class ArrayType = std::vector, class StringType = std::string, class BooleanType = bool, class NumberIntegerType = std::int64_t, class NumberUnsignedType = std::uint64_t, class NumberFloatType = double, template< typename U > class AllocatorType = std::allocator>

constexpr const array_t* nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType >::get_impl_ptr ( const array_t * ) const [inline, private]

get a pointer to the value (array)

Definition at line 2671 of file json.hpp.

template<template< typename U, typename V, typename...Args > class ObjectType = std::map, template< typename U, typename...Args > class ArrayType = std::vector, class StringType = std::string, class BooleanType = bool, class NumberIntegerType = std::int64_t, class NumberUnsignedType = std::uint64_t, class NumberFloatType = double, template< typename U > class AllocatorType = std::allocator>

string_t* nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType >::get_impl_ptr ( string_t * ) [inline, private]

get a pointer to the value (string)

Definition at line 2677 of file json.hpp.

template<template< typename U, typename V, typename...Args > class ObjectType = std::map, template< typename U, typename...Args > class ArrayType = std::vector, class StringType = std::string, class BooleanType = bool, class NumberIntegerType = std::int64_t, class NumberUnsignedType = std::uint64_t, class NumberFloatType = double, template< typename U > class AllocatorType = std::allocator>

constexpr const string_t* nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType >::get_impl_ptr ( const string_t * ) const [inline, private]

get a pointer to the value (string)

Definition at line 2683 of file json.hpp.

template<template< typename U, typename V, typename...Args > class ObjectType = std::map, template< typename U, typename...Args > class ArrayType = std::vector, class StringType = std::string, class BooleanType = bool, class NumberIntegerType = std::int64_t, class NumberUnsignedType = std::uint64_t, class NumberFloatType = double, template< typename U > class AllocatorType = std::allocator>

boolean_t* nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType >::get_impl_ptr ( boolean_t * ) [inline, private]

get a pointer to the value (boolean)

Definition at line 2689 of file json.hpp.

template<template< typename U, typename V, typename...Args > class ObjectType = std::map, template< typename U, typename...Args > class ArrayType = std::vector, class StringType = std::string, class BooleanType = bool, class NumberIntegerType = std::int64_t, class NumberUnsignedType = std::uint64_t, class NumberFloatType = double, template< typename U > class AllocatorType = std::allocator>

constexpr const boolean_t* nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType >::get_impl_ptr ( const boolean_t * ) const [inline, private]

get a pointer to the value (boolean)

Definition at line 2695 of file json.hpp.

template<template< typename U, typename V, typename...Args > class ObjectType = std::map, template< typename U, typename...Args > class ArrayType = std::vector, class StringType = std::string, class BooleanType = bool, class NumberIntegerType = std::int64_t, class NumberUnsignedType = std::uint64_t, class NumberFloatType = double, template< typename U > class AllocatorType = std::allocator>

number_integer_t* nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType >::get_impl_ptr ( number_integer_t * ) [inline, private]

get a pointer to the value (integer number)

Definition at line 2701 of file json.hpp.

template<template< typename U, typename V, typename...Args > class ObjectType = std::map, template< typename U, typename...Args > class ArrayType = std::vector, class StringType = std::string, class BooleanType = bool, class NumberIntegerType = std::int64_t, class NumberUnsignedType = std::uint64_t, class NumberFloatType = double, template< typename U > class AllocatorType = std::allocator>

constexpr const number_integer_t* nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType >::get_impl_ptr ( const number_integer_t * ) const [inline, private]

get a pointer to the value (integer number)

Definition at line 2707 of file json.hpp.

template<template< typename U, typename V, typename...Args > class ObjectType = std::map, template< typename U, typename...Args > class ArrayType = std::vector, class StringType = std::string, class BooleanType = bool, class NumberIntegerType = std::int64_t, class NumberUnsignedType = std::uint64_t, class NumberFloatType = double, template< typename U > class AllocatorType = std::allocator>

number_unsigned_t* nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType >::get_impl_ptr ( number_unsigned_t * ) [inline, private]

get a pointer to the value (unsigned number)

Definition at line 2713 of file json.hpp.

template<template< typename U, typename V, typename...Args > class ObjectType = std::map, template< typename U, typename...Args > class ArrayType = std::vector, class StringType = std::string, class BooleanType = bool, class NumberIntegerType = std::int64_t, class NumberUnsignedType = std::uint64_t, class NumberFloatType = double, template< typename U > class AllocatorType = std::allocator>

constexpr const number_unsigned_t* nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType >::get_impl_ptr ( const number_unsigned_t * ) const [inline, private]

get a pointer to the value (unsigned number)

Definition at line 2719 of file json.hpp.

template<template< typename U, typename V, typename...Args > class ObjectType = std::map, template< typename U, typename...Args > class ArrayType = std::vector, class StringType = std::string, class BooleanType = bool, class NumberIntegerType = std::int64_t, class NumberUnsignedType = std::uint64_t, class NumberFloatType = double, template< typename U > class AllocatorType = std::allocator>

number_float_t* nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType >::get_impl_ptr ( number_float_t * ) [inline, private]

get a pointer to the value (floating-point number)

Definition at line 2725 of file json.hpp.

template<template< typename U, typename V, typename...Args > class ObjectType = std::map, template< typename U, typename...Args > class ArrayType = std::vector, class StringType = std::string, class BooleanType = bool, class NumberIntegerType = std::int64_t, class NumberUnsignedType = std::uint64_t, class NumberFloatType = double, template< typename U > class AllocatorType = std::allocator>

constexpr const number_float_t* nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType >::get_impl_ptr ( const number_float_t * ) const [inline, private]

get a pointer to the value (floating-point number)

Definition at line 2731 of file json.hpp.

template<template< typename U, typename V, typename...Args > class ObjectType = std::map, template< typename U, typename...Args > class ArrayType = std::vector, class StringType = std::string, class BooleanType = bool, class NumberIntegerType = std::int64_t, class NumberUnsignedType = std::uint64_t, class NumberFloatType = double, template< typename U > class AllocatorType = std::allocator>

template<typename PointerType , typename std::enable_if< std::is_pointer< PointerType >::value, int >::type = 0>

PointerType nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType >::get_ptr ( ) [inline]

get a pointer value (implicit)

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

Warning:: Writing data to the pointee of the result yields an undefined state.

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

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

Since:: version 1.0.0

Definition at line 2891 of file json.hpp.

template<template< typename U, typename V, typename...Args > class ObjectType = std::map, template< typename U, typename...Args > class ArrayType = std::vector, class StringType = std::string, class BooleanType = bool, class NumberIntegerType = std::int64_t, class NumberUnsignedType = std::uint64_t, class NumberFloatType = double, template< typename U > class AllocatorType = std::allocator>

template<typename PointerType , typename std::enable_if< std::is_pointer< PointerType >::valueand std::is_const< typename std::remove_pointer< PointerType >::type >::value, int >::type = 0>

constexpr const PointerType nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType >::get_ptr ( ) const [inline]

get a pointer value (implicit)

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

Warning:: Writing data to the pointee of the result yields an undefined state.

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

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

Since:: version 1.0.0

Definition at line 2906 of file json.hpp.

template<template< typename U, typename V, typename...Args > class ObjectType = std::map, template< typename U, typename...Args > class ArrayType = std::vector, class StringType = std::string, class BooleanType = bool, class NumberIntegerType = std::int64_t, class NumberUnsignedType = std::uint64_t, class NumberFloatType = double, template< typename U > class AllocatorType = std::allocator>

template<typename ReferenceType , typename std::enable_if< std::is_reference< ReferenceType >::value, int >::type = 0>

ReferenceType nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType >::get_ref ( ) [inline]

get a reference value (implicit)

Implict reference access to the internally stored JSON value. No copies are made.

Warning:: Writing data to the referee of the result yields an undefined state.

Template Parameters:

ReferenceType reference type; must be a reference to array_t, object_t, string_t, boolean_t, number_integer_t, or number_float_t.

Returns:: reference to the internally stored JSON value if the requested reference type ReferenceType fits to the JSON value; throws std::domain_error otherwise

Exceptions:

std::domain_error in case passed type ReferenceType is incompatible with the stored JSON value

Constant.

{The example shows several calls to `get_ref()`.,get_ref}

Since:: version 1.1.0

Definition at line 2942 of file json.hpp.

template<template< typename U, typename V, typename...Args > class ObjectType = std::map, template< typename U, typename...Args > class ArrayType = std::vector, class StringType = std::string, class BooleanType = bool, class NumberIntegerType = std::int64_t, class NumberUnsignedType = std::uint64_t, class NumberFloatType = double, template< typename U > class AllocatorType = std::allocator>

template<typename ReferenceType , typename std::enable_if< std::is_reference< ReferenceType >::valueand std::is_const< typename std::remove_reference< ReferenceType >::type >::value, int >::type = 0>

ReferenceType nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType >::get_ref ( ) const [inline]

get a reference value (implicit)

Implict reference access to the internally stored JSON value. No copies are made.

Warning:: Writing data to the referee of the result yields an undefined state.

Template Parameters:

ReferenceType reference type; must be a reference to array_t, object_t, string_t, boolean_t, number_integer_t, or number_float_t.

Returns:: reference to the internally stored JSON value if the requested reference type ReferenceType fits to the JSON value; throws std::domain_error otherwise

Exceptions:

std::domain_error in case passed type ReferenceType is incompatible with the stored JSON value

Constant.

{The example shows several calls to `get_ref()`.,get_ref}

Since:: version 1.1.0

Definition at line 2957 of file json.hpp.

template<template< typename U, typename V, typename...Args > class ObjectType = std::map, template< typename U, typename...Args > class ArrayType = std::vector, class StringType = std::string, class BooleanType = bool, class NumberIntegerType = std::int64_t, class NumberUnsignedType = std::uint64_t, class NumberFloatType = double, template< typename U > class AllocatorType = std::allocator>

template<typename ReferenceType , typename ThisType >

static ReferenceType nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType >::get_ref_impl ( ThisType & obj ) [inline, static, private]

helper function to implement get_ref()

This funcion helps to implement get_ref() without code duplication for const and non-const overloads

Template Parameters:

ThisType will be deduced as `basic_json` or `const basic_json`

Exceptions:

std::domain_error if ReferenceType does not match underlying value type of the current JSON

Definition at line 2748 of file json.hpp.

template<template< typename U, typename V, typename...Args > class ObjectType = std::map, template< typename U, typename...Args > class ArrayType = std::vector, class StringType = std::string, class BooleanType = bool, class NumberIntegerType = std::int64_t, class NumberUnsignedType = std::uint64_t, class NumberFloatType = double, template< typename U > class AllocatorType = std::allocator>

iterator nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType >::insert	(	const_iterator	pos,
		const basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType > &	val
	)		`[inline]`

inserts element

Inserts element val before iterator pos.

Parameters:

[in]	pos	iterator before which the content will be inserted; may be the end() iterator
[in]	val	element to insert

Returns:: iterator pointing to the inserted val.

Exceptions:

std::domain_error	if called on JSON values other than arrays; example: `"cannot use insert() with string"`
std::domain_error	if pos is not an iterator of *this; example: `"iterator does not fit current value"`

Constant plus linear in the distance between pos and end of the container.

{The example shows how `insert()` is used.,insert}

Since:: version 1.0.0

Definition at line 4892 of file json.hpp.

template<template< typename U, typename V, typename...Args > class ObjectType = std::map, template< typename U, typename...Args > class ArrayType = std::vector, class StringType = std::string, class BooleanType = bool, class NumberIntegerType = std::int64_t, class NumberUnsignedType = std::uint64_t, class NumberFloatType = double, template< typename U > class AllocatorType = std::allocator>

iterator nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType >::insert	(	const_iterator	pos,
		basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType > &&	val
	)		`[inline]`

inserts element

Inserts element val before iterator pos.

Parameters:

[in]	pos	iterator before which the content will be inserted; may be the end() iterator
[in]	val	element to insert

Returns:: iterator pointing to the inserted val.

Exceptions:

std::domain_error	if called on JSON values other than arrays; example: `"cannot use insert() with string"`
std::domain_error	if pos is not an iterator of *this; example: `"iterator does not fit current value"`

Constant plus linear in the distance between pos and end of the container.

{The example shows how `insert()` is used.,insert}

Since:: version 1.0.0

Definition at line 4919 of file json.hpp.

template<template< typename U, typename V, typename...Args > class ObjectType = std::map, template< typename U, typename...Args > class ArrayType = std::vector, class StringType = std::string, class BooleanType = bool, class NumberIntegerType = std::int64_t, class NumberUnsignedType = std::uint64_t, class NumberFloatType = double, template< typename U > class AllocatorType = std::allocator>

iterator nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType >::insert	(	const_iterator	pos,
		size_type	cnt,
		const basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType > &	val
	)		`[inline]`

inserts elements

Inserts cnt copies of val before iterator pos.

Parameters:

[in]	pos	iterator before which the content will be inserted; may be the end() iterator
[in]	cnt	number of copies of val to insert
[in]	val	element to insert

Returns:: iterator pointing to the first element inserted, or pos if `cnt==0`

Exceptions:

std::domain_error	if called on JSON values other than arrays; example: `"cannot use insert() with string"`
std::domain_error	if pos is not an iterator of *this; example: `"iterator does not fit current value"`

Linear in cnt plus linear in the distance between pos and end of the container.

{The example shows how `insert()` is used.,insert__count}

Since:: version 1.0.0

Definition at line 4948 of file json.hpp.

template<template< typename U, typename V, typename...Args > class ObjectType = std::map, template< typename U, typename...Args > class ArrayType = std::vector, class StringType = std::string, class BooleanType = bool, class NumberIntegerType = std::int64_t, class NumberUnsignedType = std::uint64_t, class NumberFloatType = double, template< typename U > class AllocatorType = std::allocator>

iterator nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType >::insert	(	const_iterator	pos,
		const_iterator	first,
		const_iterator	last
	)		`[inline]`

inserts elements

Inserts elements from range `[first, last)` before iterator pos.

Parameters:

[in]	pos	iterator before which the content will be inserted; may be the end() iterator
[in]	first	begin of the range of elements to insert
[in]	last	end of the range of elements to insert

Exceptions:

std::domain_error	if called on JSON values other than arrays; example: `"cannot use insert() with string"`
std::domain_error	if pos is not an iterator of *this; example: `"iterator does not fit current value"`
std::domain_error	if first and last do not belong to the same JSON value; example: `"iterators do not fit"`
std::domain_error	if first or last are iterators into container for which insert is called; example: `"passed iterators may not belong to container"`

Returns:: iterator pointing to the first element inserted, or pos if `first==last`

Linear in `std::distance(first, last)` plus linear in the distance between pos and end of the container.

{The example shows how `insert()` is used.,insert__range}

Since:: version 1.0.0

Definition at line 5001 of file json.hpp.

template<template< typename U, typename V, typename...Args > class ObjectType = std::map, template< typename U, typename...Args > class ArrayType = std::vector, class StringType = std::string, class BooleanType = bool, class NumberIntegerType = std::int64_t, class NumberUnsignedType = std::uint64_t, class NumberFloatType = double, template< typename U > class AllocatorType = std::allocator>

iterator nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType >::insert	(	const_iterator	pos,
		std::initializer_list< basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType > >	ilist
	)		`[inline]`

inserts elements

Inserts elements from initializer list ilist before iterator pos.

Parameters:

[in]	pos	iterator before which the content will be inserted; may be the end() iterator
[in]	ilist	initializer list to insert the values from

Exceptions:

std::domain_error	if called on JSON values other than arrays; example: `"cannot use insert() with string"`
std::domain_error	if pos is not an iterator of *this; example: `"iterator does not fit current value"`

Returns:: iterator pointing to the first element inserted, or pos if `ilist` is empty

Linear in `ilist.size()` plus linear in the distance between pos and end of the container.

{The example shows how `insert()` is used.,insert__ilist}

Since:: version 1.0.0

Definition at line 5060 of file json.hpp.

template<template< typename U, typename V, typename...Args > class ObjectType = std::map, template< typename U, typename...Args > class ArrayType = std::vector, class StringType = std::string, class BooleanType = bool, class NumberIntegerType = std::int64_t, class NumberUnsignedType = std::uint64_t, class NumberFloatType = double, template< typename U > class AllocatorType = std::allocator>

constexpr bool nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType >::is_array ( ) const [inline]

return whether value is an array

This function returns true iff the JSON value is an array.

Returns:: `true` if type is array, `false` otherwise.

Constant.

No-throw guarantee: this member function never throws exceptions.

{The following code exemplifies `is_array()` for all JSON types.,is_array}

Since:: version 1.0.0

Definition at line 2391 of file json.hpp.

template<template< typename U, typename V, typename...Args > class ObjectType = std::map, template< typename U, typename...Args > class ArrayType = std::vector, class StringType = std::string, class BooleanType = bool, class NumberIntegerType = std::int64_t, class NumberUnsignedType = std::uint64_t, class NumberFloatType = double, template< typename U > class AllocatorType = std::allocator>

constexpr bool nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType >::is_boolean ( ) const [inline]

return whether value is a boolean

This function returns true iff the JSON value is a boolean.

Returns:: `true` if type is boolean, `false` otherwise.

Constant.

No-throw guarantee: this member function never throws exceptions.

{The following code exemplifies `is_boolean()` for all JSON types.,is_boolean}

Since:: version 1.0.0

Definition at line 2232 of file json.hpp.

template<template< typename U, typename V, typename...Args > class ObjectType = std::map, template< typename U, typename...Args > class ArrayType = std::vector, class StringType = std::string, class BooleanType = bool, class NumberIntegerType = std::int64_t, class NumberUnsignedType = std::uint64_t, class NumberFloatType = double, template< typename U > class AllocatorType = std::allocator>

constexpr bool nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType >::is_discarded ( ) const [inline]

return whether value is discarded

This function returns true iff the JSON value was discarded during parsing with a callback function (see parser_callback_t).

Note:: This function will always be `false` for JSON values after parsing. That is, discarded values can only occur during parsing, but will be removed when inside a structured value or replaced by null in other cases.

Returns:: `true` if type is discarded, `false` otherwise.

Constant.

No-throw guarantee: this member function never throws exceptions.

{The following code exemplifies `is_discarded()` for all JSON types.,is_discarded}

Since:: version 1.0.0

Definition at line 2440 of file json.hpp.

template<template< typename U, typename V, typename...Args > class ObjectType = std::map, template< typename U, typename...Args > class ArrayType = std::vector, class StringType = std::string, class BooleanType = bool, class NumberIntegerType = std::int64_t, class NumberUnsignedType = std::uint64_t, class NumberFloatType = double, template< typename U > class AllocatorType = std::allocator>

constexpr bool nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType >::is_null ( ) const [inline]

return whether value is null

This function returns true iff the JSON value is null.

Returns:: `true` if type is null, `false` otherwise.

Constant.

No-throw guarantee: this member function never throws exceptions.

{The following code exemplifies `is_null()` for all JSON types.,is_null}

Since:: version 1.0.0

Definition at line 2210 of file json.hpp.

template<template< typename U, typename V, typename...Args > class ObjectType = std::map, template< typename U, typename...Args > class ArrayType = std::vector, class StringType = std::string, class BooleanType = bool, class NumberIntegerType = std::int64_t, class NumberUnsignedType = std::uint64_t, class NumberFloatType = double, template< typename U > class AllocatorType = std::allocator>

constexpr bool nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType >::is_number ( ) const [inline]

return whether value is a number

This function returns true iff the JSON value is a number. This includes both integer and floating-point values.

Returns:: `true` if type is number (regardless whether integer, unsigned integer or floating-type), `false` otherwise.

Constant.

No-throw guarantee: this member function never throws exceptions.

{The following code exemplifies `is_number()` for all JSON types.,is_number}

See also:: is_number_integer() -- check if value is an integer or unsigned integer number; is_number_unsigned() -- check if value is an unsigned integer number; is_number_float() -- check if value is a floating-point number

Since:: version 1.0.0

Definition at line 2262 of file json.hpp.

template<template< typename U, typename V, typename...Args > class ObjectType = std::map, template< typename U, typename...Args > class ArrayType = std::vector, class StringType = std::string, class BooleanType = bool, class NumberIntegerType = std::int64_t, class NumberUnsignedType = std::uint64_t, class NumberFloatType = double, template< typename U > class AllocatorType = std::allocator>

constexpr bool nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType >::is_number_float ( ) const [inline]

return whether value is a floating-point number

This function returns true iff the JSON value is a floating-point number. This excludes integer and unsigned integer values.

Returns:: `true` if type is a floating-point number, `false` otherwise.

Constant.

No-throw guarantee: this member function never throws exceptions.

{The following code exemplifies `is_number_float()` for all JSON types.,is_number_float}

See also:: is_number() -- check if value is number; is_number_integer() -- check if value is an integer number; is_number_unsigned() -- check if value is an unsigned integer number

Since:: version 1.0.0

Definition at line 2347 of file json.hpp.

template<template< typename U, typename V, typename...Args > class ObjectType = std::map, template< typename U, typename...Args > class ArrayType = std::vector, class StringType = std::string, class BooleanType = bool, class NumberIntegerType = std::int64_t, class NumberUnsignedType = std::uint64_t, class NumberFloatType = double, template< typename U > class AllocatorType = std::allocator>

constexpr bool nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType >::is_number_integer ( ) const [inline]

return whether value is an integer number

This function returns true iff the JSON value is an integer or unsigned integer number. This excludes floating-point values.

Returns:: `true` if type is an integer or unsigned integer number, `false` otherwise.

Constant.

No-throw guarantee: this member function never throws exceptions.

{The following code exemplifies `is_number_integer()` for all JSON types.,is_number_integer}

See also:: is_number() -- check if value is a number; is_number_unsigned() -- check if value is an unsigned integer number; is_number_float() -- check if value is a floating-point number

Since:: version 1.0.0

Definition at line 2291 of file json.hpp.

template<template< typename U, typename V, typename...Args > class ObjectType = std::map, template< typename U, typename...Args > class ArrayType = std::vector, class StringType = std::string, class BooleanType = bool, class NumberIntegerType = std::int64_t, class NumberUnsignedType = std::uint64_t, class NumberFloatType = double, template< typename U > class AllocatorType = std::allocator>

constexpr bool nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType >::is_number_unsigned ( ) const [inline]

return whether value is an unsigned integer number

This function returns true iff the JSON value is an unsigned integer number. This excludes floating-point and (signed) integer values.

Returns:: `true` if type is an unsigned integer number, `false` otherwise.

Constant.

No-throw guarantee: this member function never throws exceptions.

{The following code exemplifies `is_number_unsigned()` for all JSON types.,is_number_unsigned}

See also:: is_number() -- check if value is a number; is_number_integer() -- check if value is an integer or unsigned integer number; is_number_float() -- check if value is a floating-point number

Since:: version 2.0.0

Definition at line 2319 of file json.hpp.

template<template< typename U, typename V, typename...Args > class ObjectType = std::map, template< typename U, typename...Args > class ArrayType = std::vector, class StringType = std::string, class BooleanType = bool, class NumberIntegerType = std::int64_t, class NumberUnsignedType = std::uint64_t, class NumberFloatType = double, template< typename U > class AllocatorType = std::allocator>

constexpr bool nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType >::is_object ( ) const [inline]

return whether value is an object

This function returns true iff the JSON value is an object.

Returns:: `true` if type is object, `false` otherwise.

Constant.

No-throw guarantee: this member function never throws exceptions.

{The following code exemplifies `is_object()` for all JSON types.,is_object}

Since:: version 1.0.0

Definition at line 2369 of file json.hpp.

template<template< typename U, typename V, typename...Args > class ObjectType = std::map, template< typename U, typename...Args > class ArrayType = std::vector, class StringType = std::string, class BooleanType = bool, class NumberIntegerType = std::int64_t, class NumberUnsignedType = std::uint64_t, class NumberFloatType = double, template< typename U > class AllocatorType = std::allocator>

constexpr bool nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType >::is_primitive ( ) const [inline]

return whether type is primitive

This function returns true iff the JSON type is primitive (string, number, boolean, or null).

Returns:: `true` if type is primitive (string, number, boolean, or null), `false` otherwise.

Constant.

No-throw guarantee: this member function never throws exceptions.

{The following code exemplifies `is_primitive()` for all JSON types.,is_primitive}

See also:: is_structured() -- returns whether JSON value is structured; is_null() -- returns whether JSON value is `null`; is_string() -- returns whether JSON value is a string; is_boolean() -- returns whether JSON value is a boolean; is_number() -- returns whether JSON value is a number

Since:: version 1.0.0

Definition at line 2161 of file json.hpp.

template<template< typename U, typename V, typename...Args > class ObjectType = std::map, template< typename U, typename...Args > class ArrayType = std::vector, class StringType = std::string, class BooleanType = bool, class NumberIntegerType = std::int64_t, class NumberUnsignedType = std::uint64_t, class NumberFloatType = double, template< typename U > class AllocatorType = std::allocator>

constexpr bool nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType >::is_string ( ) const [inline]

return whether value is a string

This function returns true iff the JSON value is a string.

Returns:: `true` if type is string, `false` otherwise.

Constant.

No-throw guarantee: this member function never throws exceptions.

{The following code exemplifies `is_string()` for all JSON types.,is_string}

Since:: version 1.0.0

Definition at line 2413 of file json.hpp.

template<template< typename U, typename V, typename...Args > class ObjectType = std::map, template< typename U, typename...Args > class ArrayType = std::vector, class StringType = std::string, class BooleanType = bool, class NumberIntegerType = std::int64_t, class NumberUnsignedType = std::uint64_t, class NumberFloatType = double, template< typename U > class AllocatorType = std::allocator>

constexpr bool nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType >::is_structured ( ) const [inline]

return whether type is structured

This function returns true iff the JSON type is structured (array or object).

Returns:: `true` if type is structured (array or object), `false` otherwise.

Constant.

No-throw guarantee: this member function never throws exceptions.

{The following code exemplifies `is_structured()` for all JSON types.,is_structured}

See also:: is_primitive() -- returns whether value is primitive; is_array() -- returns whether value is an array; is_object() -- returns whether value is an object

Since:: version 1.0.0

Definition at line 2188 of file json.hpp.

template<template< typename U, typename V, typename...Args > class ObjectType = std::map, template< typename U, typename...Args > class ArrayType = std::vector, class StringType = std::string, class BooleanType = bool, class NumberIntegerType = std::int64_t, class NumberUnsignedType = std::uint64_t, class NumberFloatType = double, template< typename U > class AllocatorType = std::allocator>

static iteration_proxy<iterator> nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType >::iterator_wrapper ( reference cont ) [inline, static]

wrapper to access iterator member functions in range-based for

This function allows to access iterator::key() and iterator::value() during range-based for loops. In these loops, a reference to the JSON values is returned, so there is no access to the underlying iterator.

Note:: The name of this function is not yet final and may change in the future.

Definition at line 4385 of file json.hpp.

template<template< typename U, typename V, typename...Args > class ObjectType = std::map, template< typename U, typename...Args > class ArrayType = std::vector, class StringType = std::string, class BooleanType = bool, class NumberIntegerType = std::int64_t, class NumberUnsignedType = std::uint64_t, class NumberFloatType = double, template< typename U > class AllocatorType = std::allocator>

static iteration_proxy<const_iterator> nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType >::iterator_wrapper ( const_reference cont ) [inline, static]

wrapper to access iterator member functions in range-based for

This function allows to access iterator::key() and iterator::value() during range-based for loops. In these loops, a reference to the JSON values is returned, so there is no access to the underlying iterator.

Note:: The name of this function is not yet final and may change in the future.

Definition at line 4393 of file json.hpp.

template<template< typename U, typename V, typename...Args > class ObjectType = std::map, template< typename U, typename...Args > class ArrayType = std::vector, class StringType = std::string, class BooleanType = bool, class NumberIntegerType = std::int64_t, class NumberUnsignedType = std::uint64_t, class NumberFloatType = double, template< typename U > class AllocatorType = std::allocator>

size_type nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType >::max_size ( ) const [inline]

returns the maximum possible number of elements

Returns the maximum number of elements a JSON value is able to hold due to system or library implementation limitations, i.e. `stddistance(begin(), end())` for the JSON value.

Returns:: The return value depends on the different types and is defined as follows: Value type | return value ----------- | ------------- null | `0` (same as `size()`) boolean | `1` (same as `size()`) string | `1` (same as `size()`) number | `1` (same as `size()`) object | result of function `object_t::max_size()` array | result of function `array_t::max_size()`

Constant, as long as array_t and object_t satisfy the Container concept; that is, their `max_size()` functions have constant complexity.

This function helps `basic_json` satisfying the [Container](http://en.cppreference.com/w/cpp/concept/Container) requirements:

The complexity is constant.
Has the semantics of returning `b.size()` where `b` is the largest possible JSON value.

{The following code calls `max_size()` on the different value types. Note the output is implementation specific.,max_size}

See also:: size() -- returns the number of elements

Since:: version 1.0.0

Definition at line 4571 of file json.hpp.

template<template< typename U, typename V, typename...Args > class ObjectType = std::map, template< typename U, typename...Args > class ArrayType = std::vector, class StringType = std::string, class BooleanType = bool, class NumberIntegerType = std::int64_t, class NumberUnsignedType = std::uint64_t, class NumberFloatType = double, template< typename U > class AllocatorType = std::allocator>

static basic_json nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType >::object ( std::initializer_list< basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType > > init = std::initializer_list<basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType >>() ) [inline, static]

explicitly create an object from an initializer list

Creates a JSON object value from a given initializer list. The initializer lists elements must be pairs, and their first elements must be strings. If the initializer list is empty, the empty object `{}` is created.

Note:: This function is only added for symmetry reasons. In contrast to the related function array(std::initializer_list<basic_json>), there are no cases which can only be expressed by this function. That is, any initializer list init can also be passed to the initializer list constructor basic_json(std::initializer_list<basic_json>, bool, value_t).

Parameters:

[in] init initializer list to create an object from (optional)

Returns:: JSON object value

Exceptions:

std::domain_error if init is not a pair whose first elements are strings; thrown by basic_json(std::initializer_list<basic_json>, bool, value_t)

Linear in the size of init.

{The following code shows an example for the `object` function.,object}

See also:: basic_json(std::initializer_list<basic_json>, bool, value_t) -- create a JSON value from an initializer list; array(std::initializer_list<basic_json>) -- create a JSON array value from an initializer list

Since:: version 1.0.0

Definition at line 1685 of file json.hpp.

template<template< typename U, typename V, typename...Args > class ObjectType = std::map, template< typename U, typename...Args > class ArrayType = std::vector, class StringType = std::string, class BooleanType = bool, class NumberIntegerType = std::int64_t, class NumberUnsignedType = std::uint64_t, class NumberFloatType = double, template< typename U > class AllocatorType = std::allocator>

constexpr nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType >::operator value_t ( ) const [inline]

return the type of the JSON value (implicit)

Implicitly return the type of the JSON value as a value from the value_t enumeration.

Returns:: the type of the JSON value

Constant.

No-throw guarantee: this member function never throws exceptions.

{The following code exemplifies the value_t operator for all JSON types.,operator__value_t}

Since:: version 1.0.0

Definition at line 2463 of file json.hpp.

template<template< typename U, typename V, typename...Args > class ObjectType = std::map, template< typename U, typename...Args > class ArrayType = std::vector, class StringType = std::string, class BooleanType = bool, class NumberIntegerType = std::int64_t, class NumberUnsignedType = std::uint64_t, class NumberFloatType = double, template< typename U > class AllocatorType = std::allocator>

template<typename ValueType , typename std::enable_if< not std::is_pointer< ValueType >::valueand not std::is_same< ValueType, typename string_t::value_type >::valueand not std::is_same< ValueType, std::initializer_list< typename string_t::value_type >>::value, int >::type = 0>

nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType >::operator ValueType ( ) const [inline]

get a value (implicit)

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

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`.

Returns:: copy of the JSON value, converted to type ValueType

Exceptions:

std::domain_error in case passed type ValueType is incompatible to JSON, thrown by 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}

Since:: version 1.0.0

Definition at line 2999 of file json.hpp.

template<template< typename U, typename V, typename...Args > class ObjectType = std::map, template< typename U, typename...Args > class ArrayType = std::vector, class StringType = std::string, class BooleanType = bool, class NumberIntegerType = std::int64_t, class NumberUnsignedType = std::uint64_t, class NumberFloatType = double, template< typename U > class AllocatorType = std::allocator>

reference nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType >::operator+= ( basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType > && val ) [inline]

add an object to an array

Appends the given element val to the end of the JSON value. If the function is called on a JSON null value, an empty array is created before appending val.

Parameters:

[in] val the value to add to the JSON array

Exceptions:

std::domain_error when called on a type other than JSON array or null; example: `"cannot use push_back() with number"`

Amortized constant.

{The example shows how `push_back()` and `+=` can be used to add elements to a JSON array. Note how the `null` value was silently converted to a JSON array.,push_back}

Since:: version 1.0.0

Definition at line 4732 of file json.hpp.

template<template< typename U, typename V, typename...Args > class ObjectType = std::map, template< typename U, typename...Args > class ArrayType = std::vector, class StringType = std::string, class BooleanType = bool, class NumberIntegerType = std::int64_t, class NumberUnsignedType = std::uint64_t, class NumberFloatType = double, template< typename U > class AllocatorType = std::allocator>

reference nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType >::operator+= ( const basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType > & val ) [inline]

add an object to an array

Appends the given element val to the end of the JSON value. If the function is called on a JSON null value, an empty array is created before appending val.

Parameters:

[in] val the value to add to the JSON array

Exceptions:

std::domain_error when called on a type other than JSON array or null; example: `"cannot use push_back() with number"`

Amortized constant.

{The example shows how `push_back()` and `+=` can be used to add elements to a JSON array. Note how the `null` value was silently converted to a JSON array.,push_back}

Since:: version 1.0.0

Definition at line 4766 of file json.hpp.

template<template< typename U, typename V, typename...Args > class ObjectType = std::map, template< typename U, typename...Args > class ArrayType = std::vector, class StringType = std::string, class BooleanType = bool, class NumberIntegerType = std::int64_t, class NumberUnsignedType = std::uint64_t, class NumberFloatType = double, template< typename U > class AllocatorType = std::allocator>

reference nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType >::operator+= ( const typename object_t::value_type & val ) [inline]

add an object to an object

Inserts the given element val to the JSON object. If the function is called on a JSON null value, an empty object is created before inserting val.

Parameters:

[in] val the value to add to the JSON object

Exceptions:

std::domain_error when called on a type other than JSON object or null; example: `"cannot use push_back() with number"`

Logarithmic in the size of the container, O(log(`size()`)).

{The example shows how `push_back()` and `+=` can be used to add elements to a JSON object. Note how the `null` value was silently converted to a JSON object.,push_back__object_t__value}

Since:: version 1.0.0

Definition at line 4816 of file json.hpp.

template<template< typename U, typename V, typename...Args > class ObjectType = std::map, template< typename U, typename...Args > class ArrayType = std::vector, class StringType = std::string, class BooleanType = bool, class NumberIntegerType = std::int64_t, class NumberUnsignedType = std::uint64_t, class NumberFloatType = double, template< typename U > class AllocatorType = std::allocator>

reference nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType >::operator+= ( std::initializer_list< basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType > > init ) [inline]

add an object to an object

This function allows to use `push_back` with an initializer list. In case

1. the current value is an object, 2. the initializer list init contains only two elements, and 3. the first element of init is a string,

init is converted into an object element and added using push_back(const typename object_t::value_type&). Otherwise, init is converted to a JSON value and added using push_back(basic_json&&).

Parameters:

init	an initializer list

Linear in the size of the initializer list init.

Note:: This function is required to resolve an ambiguous overload error, because pairs like `{"key", "value"}` can be both interpreted as `object_t::value_type` or `std::initializer_list<basic_json>`, see https://github.com/nlohmann/json/issues/235 for more information.

{The example shows how initializer lists are treated as objects when possible.,push_back__initializer_list}

Definition at line 4864 of file json.hpp.

template<template< typename U, typename V, typename...Args > class ObjectType = std::map, template< typename U, typename...Args > class ArrayType = std::vector, class StringType = std::string, class BooleanType = bool, class NumberIntegerType = std::int64_t, class NumberUnsignedType = std::uint64_t, class NumberFloatType = double, template< typename U > class AllocatorType = std::allocator>

reference& nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType >::operator= ( basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType > other ) [inline]

copy assignment

Copy assignment operator. Copies a JSON value via the "copy and swap" strategy: It is expressed in terms of the copy constructor, destructor, and the swap() member function.

Parameters:

[in] other value to copy from

Linear.

This function helps `basic_json` satisfying the [Container](http://en.cppreference.com/w/cpp/concept/Container) requirements:

The complexity is linear.

{The code below shows and example for the copy assignment. It creates a copy of value `a` which is then swapped with `b`. Finally\, the copy of `a` (which is the null value after the swap) is destroyed.,basic_json__copyassignment}

Since:: version 1.0.0

Definition at line 2000 of file json.hpp.

template<template< typename U, typename V, typename...Args > class ObjectType = std::map, template< typename U, typename...Args > class ArrayType = std::vector, class StringType = std::string, class BooleanType = bool, class NumberIntegerType = std::int64_t, class NumberUnsignedType = std::uint64_t, class NumberFloatType = double, template< typename U > class AllocatorType = std::allocator>

reference nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType >::operator[] ( size_type idx ) [inline]

access specified array element

Returns a reference to the element at specified location idx.

Note:: If idx is beyond the range of the array (i.e., `idx >= size()`), then the array is silently filled up with `null` values to make `idx` a valid reference to the last stored element.

Parameters:

[in] idx index of the element to access

Returns:: reference to the element at index idx

Exceptions:

std::domain_error if JSON is not an array or null; example: `"cannot use operator[] with string"`

Constant if idx is in the range of the array. Otherwise linear in `idx - size()`.

{The example below shows how array elements can be read and written using `[]` operator. Note the addition of `null` values.,operatorarray__size_type}

Since:: version 1.0.0

Definition at line 3224 of file json.hpp.

template<template< typename U, typename V, typename...Args > class ObjectType = std::map, template< typename U, typename...Args > class ArrayType = std::vector, class StringType = std::string, class BooleanType = bool, class NumberIntegerType = std::int64_t, class NumberUnsignedType = std::uint64_t, class NumberFloatType = double, template< typename U > class AllocatorType = std::allocator>

const_reference nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType >::operator[] ( size_type idx ) const [inline]

access specified array element

Returns a const reference to the element at specified location idx.

Parameters:

[in] idx index of the element to access

Returns:: const reference to the element at index idx

Exceptions:

std::domain_error if JSON is not an array; example: `"cannot use operator[] with null"`

Constant.

{The example below shows how array elements can be read using the `[]` operator.,operatorarray__size_type_const}

Since:: version 1.0.0

Definition at line 3270 of file json.hpp.

template<template< typename U, typename V, typename...Args > class ObjectType = std::map, template< typename U, typename...Args > class ArrayType = std::vector, class StringType = std::string, class BooleanType = bool, class NumberIntegerType = std::int64_t, class NumberUnsignedType = std::uint64_t, class NumberFloatType = double, template< typename U > class AllocatorType = std::allocator>

reference nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType >::operator[] ( const typename object_t::key_type & key ) [inline]

access specified object element

Returns a reference to the element at with specified key key.

Note:: If key is not found in the object, then it is silently added to the object and filled with a `null` value to make `key` a valid reference. In case the value was `null` before, it is converted to an object.

Parameters:

[in] key key of the element to access

Returns:: reference to the element at key key

Exceptions:

std::domain_error if JSON is not an object or null; example: `"cannot use operator[] with string"`

Logarithmic in the size of the container.

{The example below shows how object elements can be read and written using the `[]` operator.,operatorarray__key_type}

See also:: at(const typename object_t::key_type&) for access by reference with range checking; value() for access by value with a default value

Since:: version 1.0.0

Definition at line 3311 of file json.hpp.

template<template< typename U, typename V, typename...Args > class ObjectType = std::map, template< typename U, typename...Args > class ArrayType = std::vector, class StringType = std::string, class BooleanType = bool, class NumberIntegerType = std::int64_t, class NumberUnsignedType = std::uint64_t, class NumberFloatType = double, template< typename U > class AllocatorType = std::allocator>

const_reference nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType >::operator[] ( const typename object_t::key_type & key ) const [inline]

read-only access specified object element

Returns a const reference to the element at with specified key key. No bounds checking is performed.

Warning:: If the element with key key does not exist, the behavior is undefined.

Parameters:

[in] key key of the element to access

Returns:: const reference to the element at key key

Exceptions:

std::domain_error if JSON is not an object; example: `"cannot use operator[] with null"`

Logarithmic in the size of the container.

{The example below shows how object elements can be read using the `[]` operator.,operatorarray__key_type_const}

See also:: at(const typename object_t::key_type&) for access by reference with range checking; value() for access by value with a default value

Since:: version 1.0.0

Definition at line 3359 of file json.hpp.

template<template< typename U, typename V, typename...Args > class ObjectType = std::map, template< typename U, typename...Args > class ArrayType = std::vector, class StringType = std::string, class BooleanType = bool, class NumberIntegerType = std::int64_t, class NumberUnsignedType = std::uint64_t, class NumberFloatType = double, template< typename U > class AllocatorType = std::allocator>

template<typename T , std::size_t n>

reference nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType >::operator[] ( T *(&) key[n] ) [inline]

access specified object element

Returns a reference to the element at with specified key key.

Note:: If key is not found in the object, then it is silently added to the object and filled with a `null` value to make `key` a valid reference. In case the value was `null` before, it is converted to an object.

Parameters:

[in] key key of the element to access

Returns:: reference to the element at key key

Exceptions:

std::domain_error if JSON is not an object or null; example: `"cannot use operator[] with string"`

Logarithmic in the size of the container.

{The example below shows how object elements can be read and written using the `[]` operator.,operatorarray__key_type}

See also:: at(const typename object_t::key_type&) for access by reference with range checking; value() for access by value with a default value

Since:: version 1.0.0

Definition at line 3402 of file json.hpp.

template<template< typename U, typename V, typename...Args > class ObjectType = std::map, template< typename U, typename...Args > class ArrayType = std::vector, class StringType = std::string, class BooleanType = bool, class NumberIntegerType = std::int64_t, class NumberUnsignedType = std::uint64_t, class NumberFloatType = double, template< typename U > class AllocatorType = std::allocator>

template<typename T , std::size_t n>

const_reference nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType >::operator[] ( T *(&) key[n] ) const [inline]

read-only access specified object element

Returns a const reference to the element at with specified key key. No bounds checking is performed.

Warning:: If the element with key key does not exist, the behavior is undefined.

Note:: This function is required for compatibility reasons with Clang.

Parameters:

[in] key key of the element to access

Returns:: const reference to the element at key key

Exceptions:

std::domain_error if JSON is not an object; example: `"cannot use operator[] with null"`

Logarithmic in the size of the container.

{The example below shows how object elements can be read using the `[]` operator.,operatorarray__key_type_const}

See also:: at(const typename object_t::key_type&) for access by reference with range checking; value() for access by value with a default value

Since:: version 1.0.0

Definition at line 3437 of file json.hpp.

template<template< typename U, typename V, typename...Args > class ObjectType = std::map, template< typename U, typename...Args > class ArrayType = std::vector, class StringType = std::string, class BooleanType = bool, class NumberIntegerType = std::int64_t, class NumberUnsignedType = std::uint64_t, class NumberFloatType = double, template< typename U > class AllocatorType = std::allocator>

template<typename T >

reference nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType >::operator[] ( T * key ) [inline]

access specified object element

Returns a reference to the element at with specified key key.

Note:: If key is not found in the object, then it is silently added to the object and filled with a `null` value to make `key` a valid reference. In case the value was `null` before, it is converted to an object.

Parameters:

[in] key key of the element to access

Returns:: reference to the element at key key

Exceptions:

std::domain_error if JSON is not an object or null; example: `"cannot use operator[] with string"`

Logarithmic in the size of the container.

{The example below shows how object elements can be read and written using the `[]` operator.,operatorarray__key_type}

See also:: at(const typename object_t::key_type&) for access by reference with range checking; value() for access by value with a default value

Since:: version 1.1.0

Definition at line 3470 of file json.hpp.

template<template< typename U, typename V, typename...Args > class ObjectType = std::map, template< typename U, typename...Args > class ArrayType = std::vector, class StringType = std::string, class BooleanType = bool, class NumberIntegerType = std::int64_t, class NumberUnsignedType = std::uint64_t, class NumberFloatType = double, template< typename U > class AllocatorType = std::allocator>

template<typename T >

const_reference nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType >::operator[] ( T * key ) const [inline]

read-only access specified object element

Returns a const reference to the element at with specified key key. No bounds checking is performed.

Warning:: If the element with key key does not exist, the behavior is undefined.

Parameters:

[in] key key of the element to access

Returns:: const reference to the element at key key

Exceptions:

std::domain_error if JSON is not an object; example: `"cannot use operator[] with null"`

Logarithmic in the size of the container.

{The example below shows how object elements can be read using the `[]` operator.,operatorarray__key_type_const}

See also:: at(const typename object_t::key_type&) for access by reference with range checking; value() for access by value with a default value

Since:: version 1.1.0

Definition at line 3519 of file json.hpp.

template<template< typename U, typename V, typename...Args > class ObjectType = std::map, template< typename U, typename...Args > class ArrayType = std::vector, class StringType = std::string, class BooleanType = bool, class NumberIntegerType = std::int64_t, class NumberUnsignedType = std::uint64_t, class NumberFloatType = double, template< typename U > class AllocatorType = std::allocator>

reference nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType >::operator[] ( const json_pointer & ptr ) [inline]

access specified element via JSON Pointer

Uses a JSON pointer to retrieve a reference to the respective JSON value. No bound checking is performed. Similar to operator[](const typename object_t::key_type&), `null` values are created in arrays and objects if necessary.

In particular:

If the JSON pointer points to an object key that does not exist, it is created an filled with a `null` value before a reference to it is returned.
If the JSON pointer points to an array index that does not exist, it is created an filled with a `null` value before a reference to it is returned. All indices between the current maximum and the given index are also filled with `null`.
The special value `-` is treated as a synonym for the index past the end.

Parameters:

[in] ptr a JSON pointer

Returns:: reference to the element pointed to by ptr

Constant.

Exceptions:

std::out_of_range	if the JSON pointer can not be resolved
std::domain_error	if an array index begins with '0'
std::invalid_argument	if an array index was not a number

{The behavior is shown in the example.,operatorjson_pointer}

Since:: version 2.0.0

Definition at line 9327 of file json.hpp.

template<template< typename U, typename V, typename...Args > class ObjectType = std::map, template< typename U, typename...Args > class ArrayType = std::vector, class StringType = std::string, class BooleanType = bool, class NumberIntegerType = std::int64_t, class NumberUnsignedType = std::uint64_t, class NumberFloatType = double, template< typename U > class AllocatorType = std::allocator>

const_reference nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType >::operator[] ( const json_pointer & ptr ) const [inline]

access specified element via JSON Pointer

Uses a JSON pointer to retrieve a reference to the respective JSON value. No bound checking is performed. The function does not change the JSON value; no `null` values are created. In particular, the the special value `-` yields an exception.

Parameters:

[in] ptr JSON pointer to the desired element

Returns:: const reference to the element pointed to by ptr

Constant.

Exceptions:

std::out_of_range	if the JSON pointer can not be resolved
std::domain_error	if an array index begins with '0'
std::invalid_argument	if an array index was not a number

{The behavior is shown in the example.,operatorjson_pointer_const}

Since:: version 2.0.0

Definition at line 9354 of file json.hpp.

template<template< typename U, typename V, typename...Args > class ObjectType = std::map, template< typename U, typename...Args > class ArrayType = std::vector, class StringType = std::string, class BooleanType = bool, class NumberIntegerType = std::int64_t, class NumberUnsignedType = std::uint64_t, class NumberFloatType = double, template< typename U > class AllocatorType = std::allocator>

static basic_json nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType >::parse	(	const string_t &	s,
		parser_callback_t	cb = `nullptr`
	)		`[inline, static]`

deserialize from string

Parameters:

[in]	s	string to read a serialized JSON value from
[in]	cb	a parser callback function of type parser_callback_t which is used to control the deserialization by filtering unwanted values (optional)

Returns:: result of the deserialization

Linear in the length of the input. The parser is a predictive LL(1) parser. The complexity can be higher if the parser callback function cb has a super-linear complexity.

Note:: A UTF-8 byte order mark is silently ignored.

{The example below demonstrates the `parse()` function with and without callback function.,parse__string__parser_callback_t}

See also:: parse(std::istream&, parser_callback_t) for a version that reads from an input stream

Since:: version 1.0.0

Definition at line 5707 of file json.hpp.

template<template< typename U, typename V, typename...Args > class ObjectType = std::map, template< typename U, typename...Args > class ArrayType = std::vector, class StringType = std::string, class BooleanType = bool, class NumberIntegerType = std::int64_t, class NumberUnsignedType = std::uint64_t, class NumberFloatType = double, template< typename U > class AllocatorType = std::allocator>

static basic_json nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType >::parse	(	std::istream &	i,
		parser_callback_t	cb = `nullptr`
	)		`[inline, static]`

deserialize from stream

Parameters:

[in,out]	i	stream to read a serialized JSON value from
[in]	cb	a parser callback function of type parser_callback_t which is used to control the deserialization by filtering unwanted values (optional)

Returns:: result of the deserialization

Linear in the length of the input. The parser is a predictive LL(1) parser. The complexity can be higher if the parser callback function cb has a super-linear complexity.

Note:: A UTF-8 byte order mark is silently ignored.

{The example below demonstrates the `parse()` function with and without callback function.,parse__istream__parser_callback_t}

See also:: parse(const string_t&, parser_callback_t) for a version that reads from a string

Since:: version 1.0.0

Definition at line 5736 of file json.hpp.

template<template< typename U, typename V, typename...Args > class ObjectType = std::map, template< typename U, typename...Args > class ArrayType = std::vector, class StringType = std::string, class BooleanType = bool, class NumberIntegerType = std::int64_t, class NumberUnsignedType = std::uint64_t, class NumberFloatType = double, template< typename U > class AllocatorType = std::allocator>

static basic_json nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType >::parse	(	std::istream &&	i,
		parser_callback_t	cb = `nullptr`
	)		`[inline, static]`

deserialize from stream

Parameters:

[in,out]	i	stream to read a serialized JSON value from
[in]	cb	a parser callback function of type parser_callback_t which is used to control the deserialization by filtering unwanted values (optional)

Returns:: result of the deserialization

Linear in the length of the input. The parser is a predictive LL(1) parser. The complexity can be higher if the parser callback function cb has a super-linear complexity.

Note:: A UTF-8 byte order mark is silently ignored.

{The example below demonstrates the `parse()` function with and without callback function.,parse__istream__parser_callback_t}

See also:: parse(const string_t&, parser_callback_t) for a version that reads from a string

Since:: version 1.0.0

Definition at line 5744 of file json.hpp.

template<template< typename U, typename V, typename...Args > class ObjectType = std::map, template< typename U, typename...Args > class ArrayType = std::vector, class StringType = std::string, class BooleanType = bool, class NumberIntegerType = std::int64_t, class NumberUnsignedType = std::uint64_t, class NumberFloatType = double, template< typename U > class AllocatorType = std::allocator>

basic_json nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType >::patch ( const basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType > & json_patch ) const [inline]

applies a JSON patch

[JSON Patch](http://jsonpatch.com) defines a JSON document structure for expressing a sequence of operations to apply to a JSON) document. With this funcion, a JSON Patch is applied to the current JSON value by executing all operations from the patch.

Parameters:

[in] json_patch JSON patch document

Returns:: patched document

Note:: The application of a patch is atomic: Either all operations succeed and the patched document is returned or an exception is thrown. In any case, the original value is not changed: the patch is applied to a copy of the value.

Exceptions:

std::out_of_range	if a JSON pointer inside the patch could not be resolved successfully in the current JSON value; example: `"key baz not found"`
invalid_argument	if the JSON patch is malformed (e.g., mandatory attributes are missing); example: `"operation add must have member path"`

Linear in the size of the JSON value and the length of the JSON patch. As usually only a fraction of the JSON value is affected by the patch, the complexity can usually be neglected.

{The following code shows how a JSON patch is applied to a value.,patch}

See also:: diff -- create a JSON patch by comparing two JSON values; [RFC 6902 (JSON Patch)](https://tools.ietf.org/html/rfc6902); [RFC 6901 (JSON Pointer)](https://tools.ietf.org/html/rfc6901)

Since:: version 2.0.0

Definition at line 9515 of file json.hpp.

template<template< typename U, typename V, typename...Args > class ObjectType = std::map, template< typename U, typename...Args > class ArrayType = std::vector, class StringType = std::string, class BooleanType = bool, class NumberIntegerType = std::int64_t, class NumberUnsignedType = std::uint64_t, class NumberFloatType = double, template< typename U > class AllocatorType = std::allocator>

void nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType >::push_back ( basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType > && val ) [inline]

add an object to an array

Appends the given element val to the end of the JSON value. If the function is called on a JSON null value, an empty array is created before appending val.

Parameters:

[in] val the value to add to the JSON array

Exceptions:

std::domain_error when called on a type other than JSON array or null; example: `"cannot use push_back() with number"`

Amortized constant.

{The example shows how `push_back()` and `+=` can be used to add elements to a JSON array. Note how the `null` value was silently converted to a JSON array.,push_back}

Since:: version 1.0.0

Definition at line 4706 of file json.hpp.

template<template< typename U, typename V, typename...Args > class ObjectType = std::map, template< typename U, typename...Args > class ArrayType = std::vector, class StringType = std::string, class BooleanType = bool, class NumberIntegerType = std::int64_t, class NumberUnsignedType = std::uint64_t, class NumberFloatType = double, template< typename U > class AllocatorType = std::allocator>

void nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType >::push_back ( const basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType > & val ) [inline]

add an object to an array

Appends the given element val to the end of the JSON value. If the function is called on a JSON null value, an empty array is created before appending val.

Parameters:

[in] val the value to add to the JSON array

Exceptions:

std::domain_error when called on a type other than JSON array or null; example: `"cannot use push_back() with number"`

Amortized constant.

{The example shows how `push_back()` and `+=` can be used to add elements to a JSON array. Note how the `null` value was silently converted to a JSON array.,push_back}

Since:: version 1.0.0

Definition at line 4742 of file json.hpp.

template<template< typename U, typename V, typename...Args > class ObjectType = std::map, template< typename U, typename...Args > class ArrayType = std::vector, class StringType = std::string, class BooleanType = bool, class NumberIntegerType = std::int64_t, class NumberUnsignedType = std::uint64_t, class NumberFloatType = double, template< typename U > class AllocatorType = std::allocator>

void nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType >::push_back ( const typename object_t::value_type & val ) [inline]

add an object to an object

Inserts the given element val to the JSON object. If the function is called on a JSON null value, an empty object is created before inserting val.

Parameters:

[in] val the value to add to the JSON object

Exceptions:

std::domain_error when called on a type other than JSON object or null; example: `"cannot use push_back() with number"`

Logarithmic in the size of the container, O(log(`size()`)).

{The example shows how `push_back()` and `+=` can be used to add elements to a JSON object. Note how the `null` value was silently converted to a JSON object.,push_back__object_t__value}

Since:: version 1.0.0

Definition at line 4792 of file json.hpp.

template<template< typename U, typename V, typename...Args > class ObjectType = std::map, template< typename U, typename...Args > class ArrayType = std::vector, class StringType = std::string, class BooleanType = bool, class NumberIntegerType = std::int64_t, class NumberUnsignedType = std::uint64_t, class NumberFloatType = double, template< typename U > class AllocatorType = std::allocator>

void nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType >::push_back ( std::initializer_list< basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType > > init ) [inline]

add an object to an object

This function allows to use `push_back` with an initializer list. In case

1. the current value is an object, 2. the initializer list init contains only two elements, and 3. the first element of init is a string,

init is converted into an object element and added using push_back(const typename object_t::value_type&). Otherwise, init is converted to a JSON value and added using push_back(basic_json&&).

Parameters:

init	an initializer list

Linear in the size of the initializer list init.

Note:: This function is required to resolve an ambiguous overload error, because pairs like `{"key", "value"}` can be both interpreted as `object_t::value_type` or `std::initializer_list<basic_json>`, see https://github.com/nlohmann/json/issues/235 for more information.

{The example shows how initializer lists are treated as objects when possible.,push_back__initializer_list}

Definition at line 4847 of file json.hpp.

template<template< typename U, typename V, typename...Args > class ObjectType = std::map, template< typename U, typename...Args > class ArrayType = std::vector, class StringType = std::string, class BooleanType = bool, class NumberIntegerType = std::int64_t, class NumberUnsignedType = std::uint64_t, class NumberFloatType = double, template< typename U > class AllocatorType = std::allocator>

reverse_iterator nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType >::rbegin ( ) [inline]

returns an iterator to the reverse-beginning

Returns an iterator to the reverse-beginning; that is, the last element.

Illustration from cppreference.com

Constant.

This function helps `basic_json` satisfying the [ReversibleContainer](http://en.cppreference.com/w/cpp/concept/ReversibleContainer) requirements:

The complexity is constant.
Has the semantics of `reverse_iterator(end())`.

{The following code shows an example for `rbegin()`.,rbegin}

See also:: crbegin() -- returns a const reverse iterator to the beginning; rend() -- returns a reverse iterator to the end; crend() -- returns a const reverse iterator to the end

Since:: version 1.0.0

Definition at line 4261 of file json.hpp.

template<template< typename U, typename V, typename...Args > class ObjectType = std::map, template< typename U, typename...Args > class ArrayType = std::vector, class StringType = std::string, class BooleanType = bool, class NumberIntegerType = std::int64_t, class NumberUnsignedType = std::uint64_t, class NumberFloatType = double, template< typename U > class AllocatorType = std::allocator>

const_reverse_iterator nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType >::rbegin ( ) const [inline]

returns a const reverse iterator to the last element

Returns a const iterator to the reverse-beginning; that is, the last element.

Illustration from cppreference.com

Constant.

This function helps `basic_json` satisfying the [ReversibleContainer](http://en.cppreference.com/w/cpp/concept/ReversibleContainer) requirements:

The complexity is constant.
Has the semantics of `const_cast<const basic_json&>(*this).rbegin()`.

{The following code shows an example for `crbegin()`.,crbegin}

See also:: rbegin() -- returns a reverse iterator to the beginning; rend() -- returns a reverse iterator to the end; crend() -- returns a const reverse iterator to the end

Since:: version 1.0.0

Definition at line 4269 of file json.hpp.

template<template< typename U, typename V, typename...Args > class ObjectType = std::map, template< typename U, typename...Args > class ArrayType = std::vector, class StringType = std::string, class BooleanType = bool, class NumberIntegerType = std::int64_t, class NumberUnsignedType = std::uint64_t, class NumberFloatType = double, template< typename U > class AllocatorType = std::allocator>

reverse_iterator nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType >::rend ( ) [inline]

returns an iterator to the reverse-end

Returns an iterator to the reverse-end; that is, one before the first element.

Illustration from cppreference.com

Constant.

This function helps `basic_json` satisfying the [ReversibleContainer](http://en.cppreference.com/w/cpp/concept/ReversibleContainer) requirements:

The complexity is constant.
Has the semantics of `reverse_iterator(begin())`.

{The following code shows an example for `rend()`.,rend}

See also:: crend() -- returns a const reverse iterator to the end; rbegin() -- returns a reverse iterator to the beginning; crbegin() -- returns a const reverse iterator to the beginning

Since:: version 1.0.0

Definition at line 4298 of file json.hpp.

template<template< typename U, typename V, typename...Args > class ObjectType = std::map, template< typename U, typename...Args > class ArrayType = std::vector, class StringType = std::string, class BooleanType = bool, class NumberIntegerType = std::int64_t, class NumberUnsignedType = std::uint64_t, class NumberFloatType = double, template< typename U > class AllocatorType = std::allocator>

const_reverse_iterator nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType >::rend ( ) const [inline]

returns a const reverse iterator to one before the first

Returns a const reverse iterator to the reverse-end; that is, one before the first element.

Illustration from cppreference.com

Constant.

This function helps `basic_json` satisfying the [ReversibleContainer](http://en.cppreference.com/w/cpp/concept/ReversibleContainer) requirements:

The complexity is constant.
Has the semantics of `const_cast<const basic_json&>(*this).rend()`.

{The following code shows an example for `crend()`.,crend}

See also:: rend() -- returns a reverse iterator to the end; rbegin() -- returns a reverse iterator to the beginning; crbegin() -- returns a const reverse iterator to the beginning

Since:: version 1.0.0

Definition at line 4306 of file json.hpp.

template<template< typename U, typename V, typename...Args > class ObjectType = std::map, template< typename U, typename...Args > class ArrayType = std::vector, class StringType = std::string, class BooleanType = bool, class NumberIntegerType = std::int64_t, class NumberUnsignedType = std::uint64_t, class NumberFloatType = double, template< typename U > class AllocatorType = std::allocator>

size_type nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType >::size ( ) const [inline]

returns the number of elements

Returns the number of elements in a JSON value.

Returns:: The return value depends on the different types and is defined as follows: Value type | return value ----------- | ------------- null | `0` boolean | `1` string | `1` number | `1` object | result of function object_t::size() array | result of function array_t::size()

Constant, as long as array_t and object_t satisfy the Container concept; that is, their size() functions have constant complexity.

This function helps `basic_json` satisfying the [Container](http://en.cppreference.com/w/cpp/concept/Container) requirements:

The complexity is constant.
Has the semantics of `stddistance(begin(), end())`.

{The following code calls `size()` on the different value types.,size}

See also:: empty() -- checks whether the container is empty; max_size() -- returns the maximal number of elements

Since:: version 1.0.0

Definition at line 4505 of file json.hpp.

template<template< typename U, typename V, typename...Args > class ObjectType = std::map, template< typename U, typename...Args > class ArrayType = std::vector, class StringType = std::string, class BooleanType = bool, class NumberIntegerType = std::int64_t, class NumberUnsignedType = std::uint64_t, class NumberFloatType = double, template< typename U > class AllocatorType = std::allocator>

void nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType >::swap ( reference other ) [inline]

exchanges the values

Exchanges the contents of the JSON value with those of other. Does not invoke any move, copy, or swap operations on individual elements. All iterators and references remain valid. The past-the-end iterator is invalidated.

Parameters:

[in,out] other JSON value to exchange the contents with

Constant.

{The example below shows how JSON values can be swapped with `swap()`.,swap__reference}

Since:: version 1.0.0

Definition at line 5098 of file json.hpp.

template<template< typename U, typename V, typename...Args > class ObjectType = std::map, template< typename U, typename...Args > class ArrayType = std::vector, class StringType = std::string, class BooleanType = bool, class NumberIntegerType = std::int64_t, class NumberUnsignedType = std::uint64_t, class NumberFloatType = double, template< typename U > class AllocatorType = std::allocator>

void nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType >::swap ( array_t & other ) [inline]

exchanges the values

Exchanges the contents of a JSON array with those of other. Does not invoke any move, copy, or swap operations on individual elements. All iterators and references remain valid. The past-the-end iterator is invalidated.

Parameters:

[in,out] other array to exchange the contents with

Exceptions:

std::domain_error when JSON value is not an array; example: `"cannot use swap() with string"`

Constant.

{The example below shows how arrays can be swapped with `swap()`.,swap__array_t}

Since:: version 1.0.0

Definition at line 5129 of file json.hpp.

template<template< typename U, typename V, typename...Args > class ObjectType = std::map, template< typename U, typename...Args > class ArrayType = std::vector, class StringType = std::string, class BooleanType = bool, class NumberIntegerType = std::int64_t, class NumberUnsignedType = std::uint64_t, class NumberFloatType = double, template< typename U > class AllocatorType = std::allocator>

void nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType >::swap ( object_t & other ) [inline]

exchanges the values

Exchanges the contents of a JSON object with those of other. Does not invoke any move, copy, or swap operations on individual elements. All iterators and references remain valid. The past-the-end iterator is invalidated.

Parameters:

[in,out] other object to exchange the contents with

Exceptions:

std::domain_error when JSON value is not an object; example: `"cannot use swap() with string"`

Constant.

{The example below shows how objects can be swapped with `swap()`.,swap__object_t}

Since:: version 1.0.0

Definition at line 5163 of file json.hpp.

template<template< typename U, typename V, typename...Args > class ObjectType = std::map, template< typename U, typename...Args > class ArrayType = std::vector, class StringType = std::string, class BooleanType = bool, class NumberIntegerType = std::int64_t, class NumberUnsignedType = std::uint64_t, class NumberFloatType = double, template< typename U > class AllocatorType = std::allocator>

void nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType >::swap ( string_t & other ) [inline]

exchanges the values

Exchanges the contents of a JSON string with those of other. Does not invoke any move, copy, or swap operations on individual elements. All iterators and references remain valid. The past-the-end iterator is invalidated.

Parameters:

[in,out] other string to exchange the contents with

Exceptions:

std::domain_error when JSON value is not a string; example: `"cannot use swap() with boolean"`

Constant.

{The example below shows how strings can be swapped with `swap()`.,swap__string_t}

Since:: version 1.0.0

Definition at line 5197 of file json.hpp.

template<template< typename U, typename V, typename...Args > class ObjectType = std::map, template< typename U, typename...Args > class ArrayType = std::vector, class StringType = std::string, class BooleanType = bool, class NumberIntegerType = std::int64_t, class NumberUnsignedType = std::uint64_t, class NumberFloatType = double, template< typename U > class AllocatorType = std::allocator>

constexpr value_t nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType >::type ( ) const [inline]

return the type of the JSON value (explicit)

Return the type of the JSON value as a value from the value_t enumeration.

Returns:: the type of the JSON value

Constant.

No-throw guarantee: this member function never throws exceptions.

{The following code exemplifies `type()` for all JSON types.,type}

Since:: version 1.0.0

Definition at line 2131 of file json.hpp.

template<template< typename U, typename V, typename...Args > class ObjectType = std::map, template< typename U, typename...Args > class ArrayType = std::vector, class StringType = std::string, class BooleanType = bool, class NumberIntegerType = std::int64_t, class NumberUnsignedType = std::uint64_t, class NumberFloatType = double, template< typename U > class AllocatorType = std::allocator>

string_t nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType >::type_name ( ) const [inline, private]

return the type as string

Definition at line 5797 of file json.hpp.

template<template< typename U, typename V, typename...Args > class ObjectType = std::map, template< typename U, typename...Args > class ArrayType = std::vector, class StringType = std::string, class BooleanType = bool, class NumberIntegerType = std::int64_t, class NumberUnsignedType = std::uint64_t, class NumberFloatType = double, template< typename U > class AllocatorType = std::allocator>

basic_json nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType >::unflatten ( ) const [inline]

unflatten a previously flattened JSON value

The function restores the arbitrary nesting of a JSON value that has been flattened before using the flatten() function. The JSON value must meet certain constraints: 1. The value must be an object. 2. The keys must be JSON pointers (see [RFC 6901](https://tools.ietf.org/html/rfc6901)) 3. The mapped values must be primitive JSON types.

Returns:: the original JSON from a flattened version

Note:: Empty objects and arrays are flattened by flatten() to `null` values and can not unflattened to their original type. Apart from this example, for a JSON value `j`, the following is always true: `j == j.flatten().unflatten()`.

Linear in the size the JSON value.

{The following code shows how a flattened JSON object is unflattened into the original nested JSON object.,unflatten}

See also:: flatten() for the reverse function

Since:: version 2.0.0

Definition at line 9465 of file json.hpp.

template<template< typename U, typename V, typename...Args > class ObjectType = std::map, template< typename U, typename...Args > class ArrayType = std::vector, class StringType = std::string, class BooleanType = bool, class NumberIntegerType = std::int64_t, class NumberUnsignedType = std::uint64_t, class NumberFloatType = double, template< typename U > class AllocatorType = std::allocator>

template<class ValueType , typename std::enable_if< std::is_convertible< basic_json_t, ValueType >::value, int >::type = 0>

ValueType nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType >::value	(	const typename object_t::key_type &	key,
		ValueType	default_value
	)		const `[inline]`

access specified object element with default value

Returns either a copy of an object's element at the specified key key or a given default value if no element with key key exists.

The function is basically equivalent to executing

 {.cpp}
    try {
        return at(key);
    } catch(std::out_of_range) {
        return default_value;
    }

Note:: Unlike at(const typename object_t::key_type&), this function does not throw if the given key key was not found.; Unlike operator[](const typename object_t::key_type& key), this function does not implicitly add an element to the position defined by key. This function is furthermore also applicable to const objects.

Parameters:

[in]	key	key of the element to access
[in]	default_value	the value to return if key is not found

Template Parameters:

ValueType type compatible to JSON values, for instance `int` for JSON integer numbers, `bool` for JSON booleans, or `std::vector` types for JSON arrays. Note the type of the expected value at key and the default value default_value must be compatible.

Returns:: copy of the element at key key or default_value if key is not found

Exceptions:

std::domain_error if JSON is not an object; example: `"cannot use value() with null"`

Logarithmic in the size of the container.

{The example below shows how object elements can be queried with a default value.,basic_json__value}

See also:: at(const typename object_t::key_type&) for access by reference with range checking; operator[](const typename object_t::key_type&) for unchecked access by reference

Since:: version 1.0.0

Definition at line 3586 of file json.hpp.

template<template< typename U, typename V, typename...Args > class ObjectType = std::map, template< typename U, typename...Args > class ArrayType = std::vector, class StringType = std::string, class BooleanType = bool, class NumberIntegerType = std::int64_t, class NumberUnsignedType = std::uint64_t, class NumberFloatType = double, template< typename U > class AllocatorType = std::allocator>

string_t nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType >::value	(	const typename object_t::key_type &	key,
		const char *	default_value
	)		const `[inline]`

overload for a default value of type const char*

the parser finished reading a JSON value

Definition at line 3612 of file json.hpp.

Friends And Related Function Documentation

template<template< typename U, typename V, typename...Args > class ObjectType = std::map, template< typename U, typename...Args > class ArrayType = std::vector, class StringType = std::string, class BooleanType = bool, class NumberIntegerType = std::int64_t, class NumberUnsignedType = std::uint64_t, class NumberFloatType = double, template< typename U > class AllocatorType = std::allocator>

bool operator!=	(	const_reference	lhs,
		const_reference	rhs
	)		`[friend]`

comparison: not equal

Compares two JSON values for inequality by calculating `not (lhs == rhs)`.

Parameters:

[in]	lhs	first JSON value to consider
[in]	rhs	second JSON value to consider

Returns:: whether the values lhs and rhs are not equal

Linear.

{The example demonstrates comparing several JSON types.,operator__notequal}

Since:: version 1.0.0

Definition at line 5407 of file json.hpp.

template<template< typename U, typename V, typename...Args > class ObjectType = std::map, template< typename U, typename...Args > class ArrayType = std::vector, class StringType = std::string, class BooleanType = bool, class NumberIntegerType = std::int64_t, class NumberUnsignedType = std::uint64_t, class NumberFloatType = double, template< typename U > class AllocatorType = std::allocator>

bool operator!=	(	const_reference	v,
		std::nullptr_t
	)		`[friend]`

comparison: not equal

The functions compares the given JSON value against a null pointer. As the null pointer can be used to initialize a JSON value to null, a comparison of JSON value v with a null pointer should be equivalent to call `not v.is_null()`.

Parameters:

[in] v JSON value to consider

Returns:: whether v is not null

Constant.

{The example compares several JSON types to the null pointer. ,operator__notequal__nullptr_t}

Since:: version 1.0.0

Definition at line 5430 of file json.hpp.

template<template< typename U, typename V, typename...Args > class ObjectType = std::map, template< typename U, typename...Args > class ArrayType = std::vector, class StringType = std::string, class BooleanType = bool, class NumberIntegerType = std::int64_t, class NumberUnsignedType = std::uint64_t, class NumberFloatType = double, template< typename U > class AllocatorType = std::allocator>

bool operator!=	(	std::nullptr_t	,
		const_reference	v
	)		`[friend]`

comparison: not equal

The functions compares the given JSON value against a null pointer. As the null pointer can be used to initialize a JSON value to null, a comparison of JSON value v with a null pointer should be equivalent to call `not v.is_null()`.

Parameters:

[in] v JSON value to consider

Returns:: whether v is not null

Constant.

{The example compares several JSON types to the null pointer. ,operator__notequal__nullptr_t}

Since:: version 1.0.0

Definition at line 5439 of file json.hpp.

template<template< typename U, typename V, typename...Args > class ObjectType = std::map, template< typename U, typename...Args > class ArrayType = std::vector, class StringType = std::string, class BooleanType = bool, class NumberIntegerType = std::int64_t, class NumberUnsignedType = std::uint64_t, class NumberFloatType = double, template< typename U > class AllocatorType = std::allocator>

bool operator<	(	const value_t	lhs,
		const value_t	rhs
	)		`[friend]`

comparison operator for JSON types

Returns an ordering that is similar to Python:

order: null < boolean < number < object < array < string
furthermore, each type is not smaller than itself

Since:: version 1.0.0

Definition at line 5231 of file json.hpp.

template<template< typename U, typename V, typename...Args > class ObjectType = std::map, template< typename U, typename...Args > class ArrayType = std::vector, class StringType = std::string, class BooleanType = bool, class NumberIntegerType = std::int64_t, class NumberUnsignedType = std::uint64_t, class NumberFloatType = double, template< typename U > class AllocatorType = std::allocator>

bool operator<	(	const_reference	lhs,
		const_reference	rhs
	)		`[friend]`

comparison: less than

Compares whether one JSON value lhs is less than another JSON value rhs according to the following rules:

If lhs and rhs have the same type, the values are compared using the default `<` operator.
Integer and floating-point numbers are automatically converted before comparison
In case lhs and rhs have different types, the values are ignored and the order of the types is considered, see operator<(const value_t, const value_t).

Parameters:

[in]	lhs	first JSON value to consider
[in]	rhs	second JSON value to consider

Returns:: whether lhs is less than rhs

Linear.

{The example demonstrates comparing several JSON types.,operator__less}

Since:: version 1.0.0

Definition at line 5468 of file json.hpp.

template<template< typename U, typename V, typename...Args > class ObjectType = std::map, template< typename U, typename...Args > class ArrayType = std::vector, class StringType = std::string, class BooleanType = bool, class NumberIntegerType = std::int64_t, class NumberUnsignedType = std::uint64_t, class NumberFloatType = double, template< typename U > class AllocatorType = std::allocator>

std::ostream& operator<<	(	std::ostream &	o,
		const basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType > &	j
	)		`[friend]`

serialize to stream

Serialize the given JSON value j to the output stream o. The JSON value will be serialized using the dump member function. The indentation of the output can be controlled with the member variable `width` of the output stream o. For instance, using the manipulator `std::setw(4)` on o sets the indentation level to `4` and the serialization result is the same as calling `dump(4)`.

Parameters:

[in,out]	o	stream to serialize to
[in]	j	JSON value to serialize

Returns:: the stream o

Linear.

{The example below shows the serialization with different parameters to `width` to adjust the indentation level.,operator_serialize}

Since:: version 1.0.0

Definition at line 5650 of file json.hpp.

template<template< typename U, typename V, typename...Args > class ObjectType = std::map, template< typename U, typename...Args > class ArrayType = std::vector, class StringType = std::string, class BooleanType = bool, class NumberIntegerType = std::int64_t, class NumberUnsignedType = std::uint64_t, class NumberFloatType = double, template< typename U > class AllocatorType = std::allocator>

std::istream& operator<<	(	basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType > &	j,
		std::istream &	i
	)		`[friend]`

deserialize from stream

Deserializes an input stream to a JSON value.

Parameters:

[in,out]	i	input stream to read a serialized JSON value from
[in,out]	j	JSON value to write the deserialized input to

Exceptions:

std::invalid_argument in case of parse errors

Linear in the length of the input. The parser is a predictive LL(1) parser.

Note:: A UTF-8 byte order mark is silently ignored.

{The example below shows how a JSON value is constructed by reading a serialization from a stream.,operator_deserialize}

See also:: parse(std::istream&, parser_callback_t) for a variant with a parser callback function to filter values while parsing

Since:: version 1.0.0

Definition at line 5772 of file json.hpp.

template<template< typename U, typename V, typename...Args > class ObjectType = std::map, template< typename U, typename...Args > class ArrayType = std::vector, class StringType = std::string, class BooleanType = bool, class NumberIntegerType = std::int64_t, class NumberUnsignedType = std::uint64_t, class NumberFloatType = double, template< typename U > class AllocatorType = std::allocator>

bool operator<=	(	const_reference	lhs,
		const_reference	rhs
	)		`[friend]`

comparison: less than or equal

Compares whether one JSON value lhs is less than or equal to another JSON value by calculating `not (rhs < lhs)`.

Parameters:

[in]	lhs	first JSON value to consider
[in]	rhs	second JSON value to consider

Returns:: whether lhs is less than or equal to rhs

Linear.

{The example demonstrates comparing several JSON types.,operator__greater}

Since:: version 1.0.0

Definition at line 5569 of file json.hpp.

template<template< typename U, typename V, typename...Args > class ObjectType = std::map, template< typename U, typename...Args > class ArrayType = std::vector, class StringType = std::string, class BooleanType = bool, class NumberIntegerType = std::int64_t, class NumberUnsignedType = std::uint64_t, class NumberFloatType = double, template< typename U > class AllocatorType = std::allocator>

bool operator==	(	const_reference	lhs,
		const_reference	rhs
	)		`[friend]`

comparison: equal

Compares two JSON values for equality according to the following rules:

Two JSON values are equal if (1) they are from the same type and (2) their stored values are the same.
Integer and floating-point numbers are automatically converted before comparison. Floating-point numbers are compared indirectly: two floating-point numbers `f1` and `f2` are considered equal if neither `f1 > f2` nor `f2 > f1` holds.
Two JSON null values are equal.

Parameters:

[in]	lhs	first JSON value to consider
[in]	rhs	second JSON value to consider

Returns:: whether the values lhs and rhs are equal

Linear.

{The example demonstrates comparing several JSON types.,operator__equal}

Since:: version 1.0.0

Definition at line 5278 of file json.hpp.

template<template< typename U, typename V, typename...Args > class ObjectType = std::map, template< typename U, typename...Args > class ArrayType = std::vector, class StringType = std::string, class BooleanType = bool, class NumberIntegerType = std::int64_t, class NumberUnsignedType = std::uint64_t, class NumberFloatType = double, template< typename U > class AllocatorType = std::allocator>

bool operator==	(	const_reference	v,
		std::nullptr_t
	)		`[friend]`

comparison: equal

The functions compares the given JSON value against a null pointer. As the null pointer can be used to initialize a JSON value to null, a comparison of JSON value v with a null pointer should be equivalent to call `v.is_null()`.

Parameters:

[in] v JSON value to consider

Returns:: whether v is null

Constant.

{The example compares several JSON types to the null pointer. ,operator__equal__nullptr_t}

Since:: version 1.0.0

Definition at line 5377 of file json.hpp.

template<template< typename U, typename V, typename...Args > class ObjectType = std::map, template< typename U, typename...Args > class ArrayType = std::vector, class StringType = std::string, class BooleanType = bool, class NumberIntegerType = std::int64_t, class NumberUnsignedType = std::uint64_t, class NumberFloatType = double, template< typename U > class AllocatorType = std::allocator>

bool operator==	(	std::nullptr_t	,
		const_reference	v
	)		`[friend]`

comparison: equal

The functions compares the given JSON value against a null pointer. As the null pointer can be used to initialize a JSON value to null, a comparison of JSON value v with a null pointer should be equivalent to call `v.is_null()`.

Parameters:

[in] v JSON value to consider

Returns:: whether v is null

Constant.

{The example compares several JSON types to the null pointer. ,operator__equal__nullptr_t}

Since:: version 1.0.0

Definition at line 5386 of file json.hpp.

template<template< typename U, typename V, typename...Args > class ObjectType = std::map, template< typename U, typename...Args > class ArrayType = std::vector, class StringType = std::string, class BooleanType = bool, class NumberIntegerType = std::int64_t, class NumberUnsignedType = std::uint64_t, class NumberFloatType = double, template< typename U > class AllocatorType = std::allocator>

bool operator>	(	const_reference	lhs,
		const_reference	rhs
	)		`[friend]`

comparison: greater than

Compares whether one JSON value lhs is greater than another JSON value by calculating `not (lhs <= rhs)`.

Parameters:

[in]	lhs	first JSON value to consider
[in]	rhs	second JSON value to consider

Returns:: whether lhs is greater than to rhs

Linear.

{The example demonstrates comparing several JSON types.,operator__lessequal}

Since:: version 1.0.0

Definition at line 5591 of file json.hpp.

template<template< typename U, typename V, typename...Args > class ObjectType = std::map, template< typename U, typename...Args > class ArrayType = std::vector, class StringType = std::string, class BooleanType = bool, class NumberIntegerType = std::int64_t, class NumberUnsignedType = std::uint64_t, class NumberFloatType = double, template< typename U > class AllocatorType = std::allocator>

bool operator>=	(	const_reference	lhs,
		const_reference	rhs
	)		`[friend]`

comparison: greater than or equal

Compares whether one JSON value lhs is greater than or equal to another JSON value by calculating `not (lhs < rhs)`.

Parameters:

[in]	lhs	first JSON value to consider
[in]	rhs	second JSON value to consider

Returns:: whether lhs is greater than or equal to rhs

Linear.

{The example demonstrates comparing several JSON types.,operator__greaterequal}

Since:: version 1.0.0

Definition at line 5613 of file json.hpp.

template<template< typename U, typename V, typename...Args > class ObjectType = std::map, template< typename U, typename...Args > class ArrayType = std::vector, class StringType = std::string, class BooleanType = bool, class NumberIntegerType = std::int64_t, class NumberUnsignedType = std::uint64_t, class NumberFloatType = double, template< typename U > class AllocatorType = std::allocator>

std::ostream& operator>>	(	const basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType > &	j,
		std::ostream &	o
	)		`[friend]`

serialize to stream

Serialize the given JSON value j to the output stream o. The JSON value will be serialized using the dump member function. The indentation of the output can be controlled with the member variable `width` of the output stream o. For instance, using the manipulator `std::setw(4)` on o sets the indentation level to `4` and the serialization result is the same as calling `dump(4)`.

Parameters:

[in,out]	o	stream to serialize to
[in]	j	JSON value to serialize

Returns:: the stream o

Linear.

{The example below shows the serialization with different parameters to `width` to adjust the indentation level.,operator_serialize}

Since:: version 1.0.0

Definition at line 5668 of file json.hpp.

template<template< typename U, typename V, typename...Args > class ObjectType = std::map, template< typename U, typename...Args > class ArrayType = std::vector, class StringType = std::string, class BooleanType = bool, class NumberIntegerType = std::int64_t, class NumberUnsignedType = std::uint64_t, class NumberFloatType = double, template< typename U > class AllocatorType = std::allocator>

std::istream& operator>>	(	std::istream &	i,
		basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType > &	j
	)		`[friend]`

deserialize from stream

Deserializes an input stream to a JSON value.

Parameters:

[in,out]	i	input stream to read a serialized JSON value from
[in,out]	j	JSON value to write the deserialized input to

Exceptions:

std::invalid_argument in case of parse errors

Linear in the length of the input. The parser is a predictive LL(1) parser.

Note:: A UTF-8 byte order mark is silently ignored.

{The example below shows how a JSON value is constructed by reading a serialization from a stream.,operator_deserialize}

See also:: parse(std::istream&, parser_callback_t) for a variant with a parser callback function to filter values while parsing

Since:: version 1.0.0

Definition at line 5782 of file json.hpp.

Member Data Documentation

template<template< typename U, typename V, typename...Args > class ObjectType = std::map, template< typename U, typename...Args > class ArrayType = std::vector, class StringType = std::string, class BooleanType = bool, class NumberIntegerType = std::int64_t, class NumberUnsignedType = std::uint64_t, class NumberFloatType = double, template< typename U > class AllocatorType = std::allocator>

value_t nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType >::m_type = value_t::null [private]

the type of the current element

Definition at line 6160 of file json.hpp.

template<template< typename U, typename V, typename...Args > class ObjectType = std::map, template< typename U, typename...Args > class ArrayType = std::vector, class StringType = std::string, class BooleanType = bool, class NumberIntegerType = std::int64_t, class NumberUnsignedType = std::uint64_t, class NumberFloatType = double, template< typename U > class AllocatorType = std::allocator>

json_value nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType >::m_value = {} [private]

the value of the current element

Definition at line 6163 of file json.hpp.

The documentation for this class was generated from the following file:

json.hpp

Classes

Public Types

Static Public Member Functions

Private Member Functions

Static Private Member Functions

Private Attributes

constructors and destructors

object inspection

value access

element access

lookup

iterators

capacity

modifiers

lexicographical comparison operators

serialization

deserialization

JSON Pointer functions

JSON Patch functions

Detailed Description

Member Enumeration Documentation

Constructor & Destructor Documentation

Member Function Documentation

Friends And Related Function Documentation

Member Data Documentation