nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType, JSONSerializer > Class Template Reference

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

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)
JSONSerializer	the serializer to resolve internal calls to to_json() and from_json() (adl_serializer by default)

@requirement The class satisfies the following concept requirements:

• Basic
  • DefaultConstructible: JSON values can be default constructed. The result will be a JSON null value.
  • MoveConstructible: A JSON value can be constructed from an rvalue argument.
  • CopyConstructible: A JSON value can be copy-constructed from an lvalue expression.
  • MoveAssignable: A JSON value van be assigned from an rvalue argument.
  • CopyAssignable: A JSON value can be copy-assigned from an lvalue expression.
  • Destructible: JSON values can be destructed.
• Layout
  • StandardLayoutType: JSON values have 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: JSON values can be compared with ==, see operator==(const_reference,const_reference).
  • LessThanComparable: JSON values can be compared with <, see operator<(const_reference,const_reference).
  • 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: JSON values can be compared against std::nullptr_t objects which are used to model the null value.
• Container
  • Container: JSON values can be used like STL containers and provide iterator access.
  • ReversibleContainer; JSON values can be used like STL containers and provide reverse iterator access.

Invariant

The member variables m_value and m_type have the following relationship:

• If m_type == value_t::object, then m_value.object != nullptr.
• If m_type == value_t::array, then m_value.array != nullptr.
• If m_type == value_t::string, then m_value.string != nullptr. The invariants are checked by member function assert_invariant().

See also

RFC 7159: The JavaScript Object Notation (JSON) Data Interchange Format

Since

version 1.0.0

Definition at line 1039 of file json.hpp.

Classes
struct	internal_iterator
	an iterator value More...
class	iter_impl
	a template for a random access iterator for the basic_json class More...
class	iteration_proxy
	proxy class for the iterator_wrapper functions 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...
struct	numtostr
	locale-independent serialization for built-in arithmetic types More...
class	parser
	syntax analysis More...
class	primitive_iterator_t
	an iterator for primitive JSON types More...

Public Types
template<typename T , typename SFINAE >
using	json_serializer = JSONSerializer< T, SFINAE >
enum class	parse_event_t : uint8_t {   object_start , object_end , array_start , array_end ,   key , value }
	JSON callback events. More...
using	parser_callback_t = std::function< bool(int depth, parse_event_t event, basic_json &parsed)>
	per-element parser callback type More...
using	value_t = detail::value_t

Public Member Functions
std::string	type_name () const
	return the type as string More...

Static Public Member Functions
static allocator_type	get_allocator ()
	returns the allocator associated with the container More...
static basic_json	meta ()
	returns version information on the library More...

Private Types
using	basic_json_t = basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType, JSONSerializer >
	workaround type for MSVC More...

Private Member Functions
void	assert_invariant () const
	checks the class invariants More...
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 More...
boolean_t	get_impl (boolean_t *) const
	get a boolean (explicit) More...
array_t *	get_impl_ptr (array_t *) noexcept
	get a pointer to the value (array) More...
boolean_t *	get_impl_ptr (boolean_t *) noexcept
	get a pointer to the value (boolean) More...
constexpr const array_t *	get_impl_ptr (const array_t *) const noexcept
	get a pointer to the value (array) More...
constexpr const boolean_t *	get_impl_ptr (const boolean_t *) const noexcept
	get a pointer to the value (boolean) More...
constexpr const number_float_t *	get_impl_ptr (const number_float_t *) const noexcept
	get a pointer to the value (floating-point number) More...
constexpr const number_integer_t *	get_impl_ptr (const number_integer_t *) const noexcept
	get a pointer to the value (integer number) More...
constexpr const number_unsigned_t *	get_impl_ptr (const number_unsigned_t *) const noexcept
	get a pointer to the value (unsigned number) More...
constexpr const object_t *	get_impl_ptr (const object_t *) const noexcept
	get a pointer to the value (object) More...
constexpr const string_t *	get_impl_ptr (const string_t *) const noexcept
	get a pointer to the value (string) More...
number_float_t *	get_impl_ptr (number_float_t *) noexcept
	get a pointer to the value (floating-point number) More...
number_integer_t *	get_impl_ptr (number_integer_t *) noexcept
	get a pointer to the value (integer number) More...
number_unsigned_t *	get_impl_ptr (number_unsigned_t *) noexcept
	get a pointer to the value (unsigned number) More...
object_t *	get_impl_ptr (object_t *) noexcept
	get a pointer to the value (object) More...
string_t *	get_impl_ptr (string_t *) noexcept
	get a pointer to the value (string) More...

Static Private Member Functions
template<typename T , typename... Args>
static T *	create (Args &&... args)
	helper for exception-safe object creation More...
static string_t	escape_string (const string_t &s)
	escape a string More...
static std::size_t	extra_space (const string_t &s) noexcept
	calculates the extra space to escape a JSON string More...
template<typename ReferenceType , typename ThisType >
static ReferenceType	get_ref_impl (ThisType &obj)
	helper function to implement get_ref() More...

Private Attributes
value_t	m_type = value_t::null
	the type of the current element More...
json_value	m_value = {}
	the value of the current element More...

Friends
template<detail::value_t >
struct	detail::external_constructor

container types
The canonic container types to use basic_json like any other STL container.
using	value_type = basic_json
	the type of elements in a basic_json container More...
using	reference = value_type &
	the type of an element reference More...
using	const_reference = const value_type &
	the type of an element const reference More...
using	difference_type = std::ptrdiff_t
	a type to represent differences between iterators More...
using	size_type = std::size_t
	a type to represent container sizes More...
using	allocator_type = AllocatorType< basic_json >
	the allocator type More...
using	pointer = typename std::allocator_traits< allocator_type >::pointer
	the type of an element pointer More...
using	const_pointer = typename std::allocator_traits< allocator_type >::const_pointer
	the type of an element const pointer More...
using	iterator = iter_impl< basic_json >
	an iterator for a basic_json container More...
using	const_iterator = iter_impl< const basic_json >
	a const iterator for a basic_json container More...
using	reverse_iterator = json_reverse_iterator< typename basic_json::iterator >
	a reverse iterator for a basic_json container More...
using	const_reverse_iterator = json_reverse_iterator< typename basic_json::const_iterator >
	a const reverse iterator for a basic_json container More...

JSON value data types
The data types to store a JSON value. These types are derived from the template arguments passed to class basic_json.
using	object_t = ObjectType< StringType, basic_json, std::less< StringType >, AllocatorType< std::pair< const StringType, basic_json > > >
	a type for an object More...
using	array_t = ArrayType< basic_json, AllocatorType< basic_json > >
	a type for an array More...
using	string_t = StringType
	a type for a string More...
using	boolean_t = BooleanType
	a type for a boolean More...
using	number_integer_t = NumberIntegerType
	a type for a number (integer) More...
using	number_unsigned_t = NumberUnsignedType
	a type for a number (unsigned) More...
using	number_float_t = NumberFloatType
	a type for a number (floating-point) More...

lexicographical comparison operators
bool	operator== (const_reference lhs, const_reference rhs) noexcept
	comparison: equal More...
template<typename ScalarType , typename std::enable_if< std::is_scalar< ScalarType >::value, int >::type = 0>
bool	operator== (const_reference lhs, const ScalarType rhs) noexcept
	comparison: equal More...
template<typename ScalarType , typename std::enable_if< std::is_scalar< ScalarType >::value, int >::type = 0>
bool	operator== (const ScalarType lhs, const_reference rhs) noexcept
	comparison: equal More...
bool	operator!= (const_reference lhs, const_reference rhs) noexcept
	comparison: not equal More...
template<typename ScalarType , typename std::enable_if< std::is_scalar< ScalarType >::value, int >::type = 0>
bool	operator!= (const_reference lhs, const ScalarType rhs) noexcept
	comparison: not equal More...
template<typename ScalarType , typename std::enable_if< std::is_scalar< ScalarType >::value, int >::type = 0>
bool	operator!= (const ScalarType lhs, const_reference rhs) noexcept
	comparison: not equal More...
bool	operator< (const_reference lhs, const_reference rhs) noexcept
	comparison: less than More...
bool	operator<= (const_reference lhs, const_reference rhs) noexcept
	comparison: less than or equal More...
bool	operator> (const_reference lhs, const_reference rhs) noexcept
	comparison: greater than More...
bool	operator>= (const_reference lhs, const_reference rhs) noexcept
	comparison: greater than or equal More...

serialization
std::ostream &	operator<< (std::ostream &o, const basic_json &j)
	serialize to stream More...
std::ostream &	operator>> (const basic_json &j, std::ostream &o)
	serialize to stream More...

deserialization
std::istream &	operator<< (basic_json &j, std::istream &i)
	deserialize from stream More...
std::istream &	operator>> (std::istream &i, basic_json &j)
	deserialize from stream More...
template<class T , std::size_t N>
static basic_json	parse (T(&array)[N], const parser_callback_t cb=nullptr)
	deserialize from an array More...
template<typename CharT , typename std::enable_if< std::is_pointer< CharT >::value and std::is_integral< typename std::remove_pointer< CharT >::type >::value and sizeof(typename std::remove_pointer< CharT >::type)==1, int >::type = 0>
static basic_json	parse (const CharT s, const parser_callback_t cb=nullptr)
	deserialize from string literal More...
static basic_json	parse (std::istream &i, const parser_callback_t cb=nullptr)
	deserialize from stream More...
static basic_json	parse (std::istream &&i, const parser_callback_t cb=nullptr)
	deserialize from stream More...
template<class IteratorType , typename std::enable_if< std::is_base_of< std::random_access_iterator_tag, typename std::iterator_traits< IteratorType >::iterator_category >::value, int >::type = 0>
static basic_json	parse (IteratorType first, IteratorType last, const parser_callback_t cb=nullptr)
	deserialize from an iterator range with contiguous storage More...
template<class ContiguousContainer , typename std::enable_if< not std::is_pointer< ContiguousContainer >::value and std::is_base_of< std::random_access_iterator_tag, typename std::iterator_traits< decltype(std::begin(std::declval< ContiguousContainer const >()))>::iterator_category >::value , int , ::type = 0>
static basic_json	parse (const ContiguousContainer &c, const parser_callback_t cb=nullptr)
	deserialize from a container with contiguous storage More...

constructors and destructors
Constructors of class basic_json, copy/move constructor, copy assignment, static functions creating objects, and the destructor.
static basic_json	array (std::initializer_list< basic_json > init=std::initializer_list< basic_json >())
	explicitly create an array from an initializer list More...
static basic_json	object (std::initializer_list< basic_json > init=std::initializer_list< basic_json >())
	explicitly create an object from an initializer list More...
	basic_json (const value_t value_type_)
	create an empty value with a given type More...
	basic_json (std::nullptr_t=nullptr) noexcept
	create a null object More...
template<typename CompatibleType , typename U = detail::uncvref_t<CompatibleType>, detail::enable_if_t< not std::is_base_of< std::istream, U >::value and not std::is_same< U, basic_json_t >::value and not detail::is_basic_json_nested_type< basic_json_t, U >::value and detail::has_to_json< basic_json, U >::value, int > = 0>
	basic_json (CompatibleType &&val) noexcept(noexcept(JSONSerializer< U >::to_json(std::declval< basic_json_t & >(), std::forward< CompatibleType >(val))))
	create a JSON value More...
	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 More...
	basic_json (size_type cnt, const basic_json &val)
	construct an array with count copies of given value More...
template<class InputIT , typename std::enable_if< std::is_same< InputIT, typename basic_json_t::iterator >::value or std::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 More...
JSON_DEPRECATED	basic_json (std::istream &i, const parser_callback_t cb=nullptr)
	construct a JSON value given an input stream More...
	basic_json (const basic_json &other)
	copy constructor More...
	basic_json (basic_json &&other) noexcept
	move constructor More...
reference &	operator= (basic_json other) noexcept(std::is_nothrow_move_constructible< value_t >::value and std::is_nothrow_move_assignable< value_t >::value and std::is_nothrow_move_constructible< json_value >::value and std::is_nothrow_move_assignable< json_value >::value)
	copy assignment More...
	~basic_json ()
	destructor More...

iterators
static iteration_proxy< iterator >	iterator_wrapper (reference cont)
	wrapper to access iterator member functions in range-based for More...
static iteration_proxy< const_iterator >	iterator_wrapper (const_reference cont)
	wrapper to access iterator member functions in range-based for More...
iterator	begin () noexcept
	returns an iterator to the first element More...
const_iterator	begin () const noexcept
	returns a const iterator to the first element More...
const_iterator	cbegin () const noexcept
	returns a const iterator to the first element More...
iterator	end () noexcept
	returns an iterator to one past the last element More...
const_iterator	end () const noexcept
	returns a const iterator to one past the last element More...
const_iterator	cend () const noexcept
	returns a const iterator to one past the last element More...
reverse_iterator	rbegin () noexcept
	returns an iterator to the reverse-beginning More...
const_reverse_iterator	rbegin () const noexcept
	returns a const reverse iterator to the last element More...
reverse_iterator	rend () noexcept
	returns an iterator to the reverse-end More...
const_reverse_iterator	rend () const noexcept
	returns a const reverse iterator to one before the first More...
const_reverse_iterator	crbegin () const noexcept
	returns a const reverse iterator to the last element More...
const_reverse_iterator	crend () const noexcept
	returns a const reverse iterator to one before the first More...

binary serialization/deserialization support
static std::vector< uint8_t >	to_msgpack (const basic_json &j)
	create a MessagePack serialization of a given JSON value More...
static basic_json	from_msgpack (const std::vector< uint8_t > &v, const size_t start_index=0)
	create a JSON value from a byte vector in MessagePack format More...
static std::vector< uint8_t >	to_cbor (const basic_json &j)
	create a MessagePack serialization of a given JSON value More...
static basic_json	from_cbor (const std::vector< uint8_t > &v, const size_t start_index=0)
	create a JSON value from a byte vector in CBOR format More...
template<typename T >
static void	add_to_vector (std::vector< uint8_t > &vec, size_t bytes, const T number)
template<typename T >
static T	get_from_vector (const std::vector< uint8_t > &vec, const size_t current_index)
	take sufficient bytes from a vector to fill an integer variable More...
static void	to_msgpack_internal (const basic_json &j, std::vector< uint8_t > &v)
	create a MessagePack serialization of a given JSON value More...
static void	to_cbor_internal (const basic_json &j, std::vector< uint8_t > &v)
	create a CBOR serialization of a given JSON value More...
static void	check_length (const size_t size, const size_t len, const size_t offset)
static basic_json	from_msgpack_internal (const std::vector< uint8_t > &v, size_t &idx)
	create a JSON value from a given MessagePack vector More...
static basic_json	from_cbor_internal (const std::vector< uint8_t > &v, size_t &idx)
	create a JSON value from a given CBOR vector More...

JSON Patch functions
static basic_json	diff (const basic_json &source, const basic_json &target, const std::string &path="")
	creates a diff as a JSON patch More...
basic_json	patch (const basic_json &json_patch) const
	applies a JSON patch More...

object inspection
Functions to inspect the type of a JSON value.
string_t	dump (const int indent=-1) const
	serialization More...
constexpr value_t	type () const noexcept
	return the type of the JSON value (explicit) More...
constexpr bool	is_primitive () const noexcept
	return whether type is primitive More...
constexpr bool	is_structured () const noexcept
	return whether type is structured More...
constexpr bool	is_null () const noexcept
	return whether value is null More...
constexpr bool	is_boolean () const noexcept
	return whether value is a boolean More...
constexpr bool	is_number () const noexcept
	return whether value is a number More...
constexpr bool	is_number_integer () const noexcept
	return whether value is an integer number More...
constexpr bool	is_number_unsigned () const noexcept
	return whether value is an unsigned integer number More...
constexpr bool	is_number_float () const noexcept
	return whether value is a floating-point number More...
constexpr bool	is_object () const noexcept
	return whether value is an object More...
constexpr bool	is_array () const noexcept
	return whether value is an array More...
constexpr bool	is_string () const noexcept
	return whether value is a string More...
constexpr bool	is_discarded () const noexcept
	return whether value is discarded More...
constexpr	operator value_t () const noexcept
	return the type of the JSON value (implicit) More...

value access
Direct access to the stored value of a JSON value.
template<typename BasicJsonType , detail::enable_if_t< std::is_same< typename std::remove_const< BasicJsonType >::type, basic_json_t >::value, int > = 0>
basic_json	get () const
	get special-case overload More...
template<typename ValueTypeCV , typename ValueType = detail::uncvref_t<ValueTypeCV>, detail::enable_if_t< not std::is_same< basic_json_t, ValueType >::value and detail::has_from_json< basic_json_t, ValueType >::value and not detail::has_non_default_from_json< basic_json_t, ValueType >::value, int > = 0>
ValueType	get () const noexcept(noexcept(JSONSerializer< ValueType >::from_json(std::declval< const basic_json_t & >(), std::declval< ValueType & >())))
	get a value (explicit) More...
template<typename ValueTypeCV , typename ValueType = detail::uncvref_t<ValueTypeCV>, detail::enable_if_t< not std::is_same< basic_json_t, ValueType >::value and detail::has_non_default_from_json< basic_json_t, ValueType >::value, int > = 0>
ValueType	get () const noexcept(noexcept(JSONSerializer< ValueTypeCV >::from_json(std::declval< const basic_json_t & >())))
	get a value (explicit); special case More...
template<typename PointerType , typename std::enable_if< std::is_pointer< PointerType >::value, int >::type = 0>
PointerType	get () noexcept
	get a pointer value (explicit) More...
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) More...
template<typename PointerType , typename std::enable_if< std::is_pointer< PointerType >::value, int >::type = 0>
PointerType	get_ptr () noexcept
	get a pointer value (implicit) More...
template<typename PointerType , typename std::enable_if< std::is_pointer< PointerType >::value and 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) More...
template<typename ReferenceType , typename std::enable_if< std::is_reference< ReferenceType >::value, int >::type = 0>
ReferenceType	get_ref ()
	get a reference value (implicit) More...
template<typename ReferenceType , typename std::enable_if< std::is_reference< ReferenceType >::value and std::is_const< typename std::remove_reference< ReferenceType >::type >::value, int >::type = 0>
ReferenceType	get_ref () const
	get a reference value (implicit) More...
template<typename ValueType , typename std::enable_if< not std::is_pointer< ValueType >::value and not std::is_same< ValueType, typename string_t::value_type >::value and not std::is_same< ValueType, std::initializer_list< typename string_t::value_type > >::value, int >::type = 0>
	operator ValueType () const
	get a value (implicit) More...

element access
Access to the JSON value.
reference	at (size_type idx)
	access specified array element with bounds checking More...
const_reference	at (size_type idx) const
	access specified array element with bounds checking More...
reference	at (const typename object_t::key_type &key)
	access specified object element with bounds checking More...
const_reference	at (const typename object_t::key_type &key) const
	access specified object element with bounds checking More...
reference	operator[] (size_type idx)
	access specified array element More...
const_reference	operator[] (size_type idx) const
	access specified array element More...
reference	operator[] (const typename object_t::key_type &key)
	access specified object element More...
const_reference	operator[] (const typename object_t::key_type &key) const
	read-only access specified object element More...
template<typename T , std::size_t n>
reference	operator[] (T *(&key)[n])
	access specified object element More...
template<typename T , std::size_t n>
const_reference	operator[] (T *(&key)[n]) const
	read-only access specified object element More...
template<typename T >
reference	operator[] (T *key)
	access specified object element More...
template<typename T >
const_reference	operator[] (T *key) const
	read-only access specified object element More...
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 More...
string_t	value (const typename object_t::key_type &key, const char *default_value) const
	overload for a default value of type const char* More...
template<class ValueType , typename std::enable_if< std::is_convertible< basic_json_t, ValueType >::value, int >::type = 0>
ValueType	value (const json_pointer &ptr, ValueType default_value) const
	access specified object element via JSON Pointer with default value More...
string_t	value (const json_pointer &ptr, const char *default_value) const
	overload for a default value of type const char* More...
reference	front ()
	access the first element More...
const_reference	front () const
	access the first element More...
reference	back ()
	access the last element More...
const_reference	back () const
	access the last element More...
template<class IteratorType , typename std::enable_if< std::is_same< IteratorType, typename basic_json_t::iterator >::value or std::is_same< IteratorType, typename basic_json_t::const_iterator >::value, int >::type = 0>
IteratorType	erase (IteratorType pos)
	remove element given an iterator More...
template<class IteratorType , typename std::enable_if< std::is_same< IteratorType, typename basic_json_t::iterator >::value or std::is_same< IteratorType, typename basic_json_t::const_iterator >::value, int >::type = 0>
IteratorType	erase (IteratorType first, IteratorType last)
	remove elements given an iterator range More...
size_type	erase (const typename object_t::key_type &key)
	remove element from a JSON object given a key More...
void	erase (const size_type idx)
	remove element from a JSON array given an index More...

lookup
iterator	find (typename object_t::key_type key)
	find an element in a JSON object More...
const_iterator	find (typename object_t::key_type key) const
	find an element in a JSON object More...
size_type	count (typename object_t::key_type key) const
	returns the number of occurrences of a key in a JSON object More...

capacity
bool	empty () const noexcept
	checks whether the container is empty More...
size_type	size () const noexcept
	returns the number of elements More...
size_type	max_size () const noexcept
	returns the maximum possible number of elements More...

modifiers
void	clear () noexcept
	clears the contents More...
void	push_back (basic_json &&val)
	add an object to an array More...
reference	operator+= (basic_json &&val)
	add an object to an array More...
void	push_back (const basic_json &val)
	add an object to an array More...
reference	operator+= (const basic_json &val)
	add an object to an array More...
void	push_back (const typename object_t::value_type &val)
	add an object to an object More...
reference	operator+= (const typename object_t::value_type &val)
	add an object to an object More...
void	push_back (std::initializer_list< basic_json > init)
	add an object to an object More...
reference	operator+= (std::initializer_list< basic_json > init)
	add an object to an object More...
template<class... Args>
void	emplace_back (Args &&... args)
	add an object to an array More...
template<class... Args>
std::pair< iterator, bool >	emplace (Args &&... args)
	add an object to an object if key does not exist More...
iterator	insert (const_iterator pos, const basic_json &val)
	inserts element More...
iterator	insert (const_iterator pos, basic_json &&val)
	inserts element More...
iterator	insert (const_iterator pos, size_type cnt, const basic_json &val)
	inserts elements More...
iterator	insert (const_iterator pos, const_iterator first, const_iterator last)
	inserts elements More...
iterator	insert (const_iterator pos, std::initializer_list< basic_json > ilist)
	inserts elements More...
void	swap (reference other) noexcept(std::is_nothrow_move_constructible< value_t >::value and std::is_nothrow_move_assignable< value_t >::value and std::is_nothrow_move_constructible< json_value >::value and std::is_nothrow_move_assignable< json_value >::value)
	exchanges the values More...
void	swap (array_t &other)
	exchanges the values More...
void	swap (object_t &other)
	exchanges the values More...
void	swap (string_t &other)
	exchanges the values More...

JSON Pointer functions
reference	operator[] (const json_pointer &ptr)
	access specified element via JSON Pointer More...
const_reference	operator[] (const json_pointer &ptr) const
	access specified element via JSON Pointer More...
reference	at (const json_pointer &ptr)
	access specified element via JSON Pointer More...
const_reference	at (const json_pointer &ptr) const
	access specified element via JSON Pointer More...
basic_json	flatten () const
	return flattened JSON value More...
basic_json	unflatten () const
	unflatten a previously flattened JSON value More...

#include </home/sftnight/build/workspace/root-makedoc-v616/rootspi/rdoc/src/v6-16-00-patches/io/io/res/json.hpp>

Member Typedef Documentation

allocator_type

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

using nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType, JSONSerializer >::allocator_type = AllocatorType<basic_json>

the allocator type

Definition at line 1080 of file json.hpp.

array_t

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

using nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType, JSONSerializer >::array_t = ArrayType<basic_json, AllocatorType<basic_json> >

a type for an array

RFC 7159 describes JSON arrays as follows:

An array is an ordered sequence of zero or more values.

To store objects in C++, a type is defined by the template parameters explained below.

Template Parameters

ArrayType	container type to store arrays (e.g., std::vector or std::list)
AllocatorType	allocator to use for arrays (e.g., std::allocator)

Default type

With the default values for ArrayType (std::vector) and AllocatorType (std::allocator), the default value for array_t is:

std::vector<
  basic_json, // value_type
  std::allocator<basic_json> // allocator_type
>

Limits

RFC 7159 specifies:

An implementation may set limits on the maximum depth of nesting.

In this class, the array's limit of nesting is not constraint explicitly. However, a maximum depth of nesting may be introduced by the compiler or runtime environment. A theoretical limit can be queried by calling the max_size function of a JSON array.

Storage

Arrays are stored as pointers in a basic_json type. That is, for any access to array values, a pointer of type array_t* must be dereferenced.

See also

object_t – type for an object value

Since

version 1.0.0

Definition at line 1328 of file json.hpp.

basic_json_t

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

using nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType, JSONSerializer >::basic_json_t = basic_json<ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType, JSONSerializer>

private

workaround type for MSVC

Definition at line 1044 of file json.hpp.

boolean_t

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

using nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType, JSONSerializer >::boolean_t = BooleanType

a type for a boolean

RFC 7159 implicitly describes a boolean as a type which differentiates the two literals true and false.

To store objects in C++, a type is defined by the template parameter BooleanType which chooses the type to use.

Default type

With the default values for BooleanType (bool), the default value for boolean_t is:

bool

Storage

Boolean values are stored directly inside a basic_json type.

Since

version 1.0.0

Definition at line 1407 of file json.hpp.

const_iterator

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

using nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType, JSONSerializer >::const_iterator = iter_impl<const basic_json>

a const iterator for a basic_json container

Definition at line 1090 of file json.hpp.

const_pointer

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

using nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType, JSONSerializer >::const_pointer = typename std::allocator_traits<allocator_type>::const_pointer

the type of an element const pointer

Definition at line 1085 of file json.hpp.

const_reference

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

using nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType, JSONSerializer >::const_reference = const value_type&

the type of an element const reference

Definition at line 1072 of file json.hpp.

const_reverse_iterator

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

using nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType, JSONSerializer >::const_reverse_iterator = json_reverse_iterator<typename basic_json::const_iterator>

a const reverse iterator for a basic_json container

Definition at line 1094 of file json.hpp.

difference_type

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

using nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType, JSONSerializer >::difference_type = std::ptrdiff_t

a type to represent differences between iterators

Definition at line 1075 of file json.hpp.

iterator

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

using nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType, JSONSerializer >::iterator = iter_impl<basic_json>

an iterator for a basic_json container

Definition at line 1088 of file json.hpp.

json_serializer

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

template<typename T , typename SFINAE >

using nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType, JSONSerializer >::json_serializer = JSONSerializer<T, SFINAE>

Definition at line 1055 of file json.hpp.

number_float_t

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

using nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType, JSONSerializer >::number_float_t = NumberFloatType

a type for a number (floating-point)

RFC 7159 describes numbers as follows:

The representation of numbers is similar to that used in most programming languages. A number is represented in base 10 using decimal digits. It contains an integer component that may be prefixed with an optional minus sign, which may be followed by a fraction part and/or an exponent part. Leading zeros are not allowed. (...) Numeric values that cannot be represented in the grammar below (such as Infinity and NaN) are not permitted.

This description includes both integer and floating-point numbers. However, C++ allows more precise storage if it is known whether the number is a signed integer, an unsigned integer or a floating-point number. Therefore, three different types, number_integer_t, number_unsigned_t and number_float_t are used.

To store floating-point numbers in C++, a type is defined by the template parameter NumberFloatType which chooses the type to use.

Default type

With the default values for NumberFloatType (double), the default value for number_float_t is:

double

Default behavior

• The restrictions about leading zeros is not enforced in C++. Instead, leading zeros in floating-point literals will be ignored. Internally, the value will be stored as decimal number. For instance, the C++ floating-point literal 01.2 will be serialized to 1.2. During deserialization, leading zeros yield an error.
• Not-a-number (NaN) values will be serialized to null.

Limits

RFC 7159 states:

This specification allows implementations to set limits on the range and precision of numbers accepted. Since software that implements IEEE 754-2008 binary64 (double precision) numbers is generally available and widely used, good interoperability can be achieved by implementations that expect no more precision or range than these provide, in the sense that implementations will approximate JSON numbers within the expected precision.

This implementation does exactly follow this approach, as it uses double precision floating-point numbers. Note values smaller than -1.79769313486232e+308 and values greater than 1.79769313486232e+308 will be stored as NaN internally and be serialized to null.

Storage

Floating-point number values are stored directly inside a basic_json type.

See also

number_integer_t – type for number values (integer)

number_unsigned_t – type for number values (unsigned integer)

Since

version 1.0.0

Definition at line 1618 of file json.hpp.

number_integer_t

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

using nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType, JSONSerializer >::number_integer_t = NumberIntegerType

a type for a number (integer)

RFC 7159 describes numbers as follows:

The representation of numbers is similar to that used in most programming languages. A number is represented in base 10 using decimal digits. It contains an integer component that may be prefixed with an optional minus sign, which may be followed by a fraction part and/or an exponent part. Leading zeros are not allowed. (...) Numeric values that cannot be represented in the grammar below (such as Infinity and NaN) are not permitted.

This description includes both integer and floating-point numbers. However, C++ allows more precise storage if it is known whether the number is a signed integer, an unsigned integer or a floating-point number. Therefore, three different types, number_integer_t, number_unsigned_t and number_float_t are used.

To store integer numbers in C++, a type is defined by the template parameter NumberIntegerType which chooses the type to use.

Default type

With the default values for NumberIntegerType (int64_t), the default value for number_integer_t is:

int64_t

Default behavior

• The restrictions about leading zeros is not enforced in C++. Instead, leading zeros in integer literals lead to an interpretation as octal number. Internally, the value will be stored as decimal number. For instance, the C++ integer literal 010 will be serialized to 8. During deserialization, leading zeros yield an error.
• Not-a-number (NaN) values will be serialized to null.

Limits

RFC 7159 specifies:

An implementation may set limits on the range and precision of numbers.

When the default type is used, the maximal integer number that can be stored is 9223372036854775807 (INT64_MAX) and the minimal integer number that can be stored is -9223372036854775808 (INT64_MIN). Integer numbers that are out of range will yield over/underflow when used in a constructor. During deserialization, too large or small integer numbers will be automatically be stored as number_unsigned_t or number_float_t.

RFC 7159 further states:

Note that when such software is used, numbers that are integers and are in the range $[-2^{53}+1, 2^{53}-1]$ are interoperable in the sense that implementations will agree exactly on their numeric values.

As this range is a subrange of the exactly supported range [INT64_MIN, INT64_MAX], this class's integer type is interoperable.

Storage

Integer number values are stored directly inside a basic_json type.

See also

number_float_t – type for number values (floating-point)

number_unsigned_t – type for number values (unsigned integer)

Since

version 1.0.0

Definition at line 1479 of file json.hpp.

number_unsigned_t

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

using nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType, JSONSerializer >::number_unsigned_t = NumberUnsignedType

a type for a number (unsigned)

RFC 7159 describes numbers as follows:

The representation of numbers is similar to that used in most programming languages. A number is represented in base 10 using decimal digits. It contains an integer component that may be prefixed with an optional minus sign, which may be followed by a fraction part and/or an exponent part. Leading zeros are not allowed. (...) Numeric values that cannot be represented in the grammar below (such as Infinity and NaN) are not permitted.

This description includes both integer and floating-point numbers. However, C++ allows more precise storage if it is known whether the number is a signed integer, an unsigned integer or a floating-point number. Therefore, three different types, number_integer_t, number_unsigned_t and number_float_t are used.

To store unsigned integer numbers in C++, a type is defined by the template parameter NumberUnsignedType which chooses the type to use.

Default type

With the default values for NumberUnsignedType (uint64_t), the default value for number_unsigned_t is:

uint64_t

Default behavior

• The restrictions about leading zeros is not enforced in C++. Instead, leading zeros in integer literals lead to an interpretation as octal number. Internally, the value will be stored as decimal number. For instance, the C++ integer literal 010 will be serialized to 8. During deserialization, leading zeros yield an error.
• Not-a-number (NaN) values will be serialized to null.

Limits

RFC 7159 specifies:

An implementation may set limits on the range and precision of numbers.

When the default type is used, the maximal integer number that can be stored is 18446744073709551615 (UINT64_MAX) and the minimal integer number that can be stored is 0. Integer numbers that are out of range will yield over/underflow when used in a constructor. During deserialization, too large or small integer numbers will be automatically be stored as number_integer_t or number_float_t.

RFC 7159 further states:

Note that when such software is used, numbers that are integers and are in the range $[-2^{53}+1, 2^{53}-1]$ are interoperable in the sense that implementations will agree exactly on their numeric values.

As this range is a subrange (when considered in conjunction with the number_integer_t type) of the exactly supported range [0, UINT64_MAX], this class's integer type is interoperable.

Storage

Integer number values are stored directly inside a basic_json type.

See also

number_float_t – type for number values (floating-point)

number_integer_t – type for number values (integer)

Since

version 2.0.0

Definition at line 1550 of file json.hpp.

object_t

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

using nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType, JSONSerializer >::object_t = ObjectType<StringType, basic_json, std::less<StringType>, AllocatorType<std::pair<const StringType, basic_json> >>

a type for an object

RFC 7159 describes JSON objects as follows:

An object is an unordered collection of zero or more name/value pairs, where a name is a string and a value is a string, number, boolean, null, object, or array.

To store objects in C++, a type is defined by the template parameters described below.

Template Parameters

ObjectType	the container to store objects (e.g., std::map or std::unordered_map)
StringType	the type of the keys or names (e.g., std::string). The comparison function std::less<StringType> is used to order elements inside the container.
AllocatorType	the allocator to use for objects (e.g., std::allocator)

Default type

With the default values for ObjectType (std::map), StringType (std::string), and AllocatorType (std::allocator), the default value for object_t is:

std::map<
  std::string, // key_type
  basic_json, // value_type
  std::less<std::string>, // key_compare
  std::allocator<std::pair<const std::string, basic_json>> // allocator_type
>

Behavior

The choice of object_t influences the behavior of the JSON class. With the default type, objects have the following behavior:

• When all names are unique, objects will be interoperable in the sense that all software implementations receiving that object will agree on the name-value mappings.
• When the names within an object are not unique, later stored name/value pairs overwrite previously stored name/value pairs, leaving the used names unique. For instance, {"key": 1} and {"key": 2, "key": 1} will be treated as equal and both stored as {"key": 1}.
• Internally, name/value pairs are stored in lexicographical order of the names. Objects will also be serialized (see dump) in this order. For instance, {"b": 1, "a": 2} and {"a": 2, "b": 1} will be stored and serialized as {"a": 2, "b": 1}.
• When comparing objects, the order of the name/value pairs is irrelevant. This makes objects interoperable in the sense that they will not be affected by these differences. For instance, {"b": 1, "a": 2} and {"a": 2, "b": 1} will be treated as equal.

Limits

RFC 7159 specifies:

An implementation may set limits on the maximum depth of nesting.

In this class, the object's limit of nesting is not constraint explicitly. However, a maximum depth of nesting may be introduced by the compiler or runtime environment. A theoretical limit can be queried by calling the max_size function of a JSON object.

Storage

Objects are stored as pointers in a basic_json type. That is, for any access to object values, a pointer of type object_t* must be dereferenced.

See also

array_t – type for an array value

Since

version 1.0.0

Note

The order name/value pairs are added to the object is not preserved by the library. Therefore, iterating an object may return name/value pairs in a different order than they were originally stored. In fact, keys will be traversed in alphabetical order as std::map with std::less is used by default. Please note this behavior conforms to RFC 7159, because any order implements the specified "unordered" nature of JSON objects.

Definition at line 1278 of file json.hpp.

parser_callback_t

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

using nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType, JSONSerializer >::parser_callback_t = std::function<bool(int depth, parse_event_t event, basic_json& parsed)>

per-element parser callback type

With a parser callback function, the result of parsing a JSON text can be influenced. When passed to parse(std::istream&, const parser_callback_t) or parse(const CharT, const parser_callback_t), it is called on certain events (passed as parse_event_t via parameter event) with a set recursion depth depth and context JSON value parsed. The return value of the callback function is a boolean indicating whether the element that emitted the callback shall be kept or not.

We distinguish six scenarios (determined by the event type) in which the callback function can be called. The following table describes the values of the parameters depth, event, and parsed.

parameter event	description	parameter depth	parameter parsed
parse_event_t::object_start	the parser read { and started to process a JSON object	depth of the parent of the JSON object	a JSON value with type discarded
parse_event_t::key	the parser read a key of a value in an object	depth of the currently parsed JSON object	a JSON string containing the key
parse_event_t::object_end	the parser read } and finished processing a JSON object	depth of the parent of the JSON object	the parsed JSON object
parse_event_t::array_start	the parser read [ and started to process a JSON array	depth of the parent of the JSON array	a JSON value with type discarded
parse_event_t::array_end	the parser read ] and finished processing a JSON array	depth of the parent of the JSON array	the parsed JSON array
parse_event_t::value	the parser finished reading a JSON value	depth of the value	the parsed JSON value

Example when certain parse events are triggered

Discarding a value (i.e., returning false) has different effects depending on the context in which function was called:

• Discarded values in structured types are skipped. That is, the parser will behave as if the discarded value was never read.
• In case a value outside a structured type is skipped, it is replaced with null. This case happens if the top-level element is skipped.

Parameters

[in]	depth	the depth of the recursion during parsing
[in]	event	an event of type parse_event_t indicating the context in the callback function has been called
[in,out]	parsed	the current intermediate parse result; note that writing to this value has no effect for parse_event_t::key events

Returns

Whether the JSON value which called the function during parsing should be kept (true) or not (false). In the latter case, it is either skipped completely or replaced by an empty discarded object.

See also

parse(std::istream&, parser_callback_t) or parse(const CharT, const parser_callback_t) for examples

Since

version 1.0.0

Definition at line 1875 of file json.hpp.

pointer

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

using nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType, JSONSerializer >::pointer = typename std::allocator_traits<allocator_type>::pointer

the type of an element pointer

Definition at line 1083 of file json.hpp.

reference

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

using nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType, JSONSerializer >::reference = value_type&

the type of an element reference

Definition at line 1070 of file json.hpp.

reverse_iterator

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

using nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType, JSONSerializer >::reverse_iterator = json_reverse_iterator<typename basic_json::iterator>

a reverse iterator for a basic_json container

Definition at line 1092 of file json.hpp.

size_type

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

using nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType, JSONSerializer >::size_type = std::size_t

a type to represent container sizes

Definition at line 1077 of file json.hpp.

string_t

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

using nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType, JSONSerializer >::string_t = StringType

a type for a string

RFC 7159 describes JSON strings as follows:

A string is a sequence of zero or more Unicode characters.

To store objects in C++, a type is defined by the template parameter described below. Unicode values are split by the JSON class into byte-sized characters during deserialization.

Template Parameters

StringType

the container to store strings (e.g., std::string). Note this container is used for keys/names in objects, see object_t.

Default type

With the default values for StringType (std::string), the default value for string_t is:

std::string

Encoding

Strings are stored in UTF-8 encoding. Therefore, functions like std::string::size() or std::string::length() return the number of bytes in the string rather than the number of characters or glyphs.

String comparison

RFC 7159 states:

Software implementations are typically required to test names of object members for equality. Implementations that transform the textual representation into sequences of Unicode code units and then perform the comparison numerically, code unit by code unit, are interoperable in the sense that implementations will agree in all cases on equality or inequality of two strings. For example, implementations that compare strings with escaped characters unconverted may incorrectly find that "a\\b" and "a\u005Cb" are not equal.

This implementation is interoperable as it does compare strings code unit by code unit.

Storage

String values are stored as pointers in a basic_json type. That is, for any access to string values, a pointer of type string_t* must be dereferenced.

Since

version 1.0.0

Definition at line 1381 of file json.hpp.

value_t

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

using nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType, JSONSerializer >::value_t = detail::value_t

Definition at line 1049 of file json.hpp.

value_type

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

using nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType, JSONSerializer >::value_type = basic_json

the type of elements in a basic_json container

Definition at line 1067 of file json.hpp.

Member Enumeration Documentation

parse_event_t

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

enum class nlohmann::basic_json::parse_event_t : uint8_t

strong

JSON callback events.

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

Example when certain parse events are triggered

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 1807 of file json.hpp.

Constructor & Destructor Documentation

basic_json() [1/9]

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

nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType, JSONSerializer >::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

@complexity Constant.

Exceptions

std::bad_alloc

if allocation for object, array, or string value fails

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

Since

version 1.0.0

Definition at line 1916 of file json.hpp.

basic_json() [2/9]

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

nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType, JSONSerializer >::basic_json ( std::nullptr_t  = nullptr )

inlinenoexcept

create a null object

Create a null JSON value. It either takes a null pointer as parameter (explicitly creating null) or no parameter (implicitly creating null). The passed null pointer itself is not read – it is only used to choose the right constructor.

@complexity Constant.

@exceptionsafety No-throw guarantee: this constructor never throws exceptions.

@liveexample{The following code shows the constructor with and without a null pointer parameter.,basic_json__nullptr_t}

Since

version 1.0.0

Definition at line 1940 of file json.hpp.

basic_json() [3/9]

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

template<typename CompatibleType , typename U = detail::uncvref_t<CompatibleType>, detail::enable_if_t< not std::is_base_of< std::istream, U >::value and not std::is_same< U, basic_json_t >::value and not detail::is_basic_json_nested_type< basic_json_t, U >::value and detail::has_to_json< basic_json, U >::value, int > = 0>

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

inlinenoexcept

create a JSON value

This is a "catch all" constructor for all compatible JSON types; that is, types for which a to_json() method exsits. The constructor forwards the parameter val to that method (to json_serializer<U>::to_json method with U = uncvref_t<CompatibleType>, to be exact).

Template type CompatibleType includes, but is not limited to, the following types:

• arrays: array_t and all kinds of compatible containers such as std::vector, std::deque, std::list, std::forward_list, std::array, std::set, std::unordered_set, std::multiset, and unordered_multiset with a value_type from which a basic_json value can be constructed.
• objects: object_t and all kinds of compatible associative containers such as std::map, std::unordered_map, std::multimap, and std::unordered_multimap with a key_type compatible to string_t and a value_type from which a basic_json value can be constructed.
• strings: string_t, string literals, and all compatible string containers can be used.
• numbers: number_integer_t, number_unsigned_t, number_float_t, and all convertible number types such as int, size_t, int64_t, float or double can be used.
• boolean: boolean_t / bool can be used.

See the examples below.

Template Parameters

CompatibleType	a type such that: CompatibleType is not derived from std::istream, CompatibleType is not basic_json (to avoid hijacking copy/move constructors), CompatibleType is not a basic_json nested type (e.g., json_pointer, iterator, etc ...) @ref json_serializer has a to_json(basic_json_t&, CompatibleType&&) method
U	= uncvref_t<CompatibleType>

Parameters

[in]

val

the value to be forwarded

@complexity Usually linear in the size of the passed val, also depending on the implementation of the called to_json() method.

Exceptions

what	json_serializer<U>::to_json() throws

@liveexample{The following code shows the constructor with several compatible types.,basic_json__CompatibleType}

Since

version 2.1.0

Definition at line 2006 of file json.hpp.

basic_json() [4/9]

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

nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType, JSONSerializer >::basic_json ( std::initializer_list< basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType, JSONSerializer > >  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"

@complexity Linear in the size of the initializer list init.

@liveexample{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 2082 of file json.hpp.

basic_json() [5/9]

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

nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType, JSONSerializer >::basic_json ( size_type  cnt, const basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType, JSONSerializer > &  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, std::distance(begin(),end()) == cnt holds.

Parameters

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

@complexity Linear in cnt.

@liveexample{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 2229 of file json.hpp.

basic_json() [6/9]

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

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

nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType, JSONSerializer >::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)

Precondition

Iterators first and last must be initialized. This precondition is enforced with an assertion.

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"

@complexity Linear in distance between first and last.

@liveexample{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 2276 of file json.hpp.

basic_json() [7/9]

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

JSON_DEPRECATED nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType, JSONSerializer >::basic_json ( std::istream &  i, const parser_callback_t  cb = nullptr  )

inlineexplicit

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)

@complexity 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.

Deprecated:

This constructor is deprecated and will be removed in version 3.0.0 to unify the interface of the library. Deserialization will be done by stream operators or by calling one of the parse functions, e.g. parse(std::istream&, const parser_callback_t). That is, calls like json j(i); for an input stream i need to be replaced by json j = json::parse(i);. See the example below.

@liveexample{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, deprecated in version 2.0.3, to be removed in version 3.0.0

Definition at line 2396 of file json.hpp.

basic_json() [8/9]

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

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

inline

copy constructor

Creates a copy of a given JSON value.

Parameters

[in]

other

the JSON value to copy

@complexity Linear in the size of other.

@requirement This function helps basic_json satisfying the 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.

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

Since

version 1.0.0

Definition at line 2428 of file json.hpp.

basic_json() [9/9]

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

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

inlinenoexcept

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

@complexity Constant.

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

Since

version 1.0.0

Definition at line 2505 of file json.hpp.

~basic_json()

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

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

inline

destructor

Destroys the JSON value and frees all allocated memory.

@complexity Linear.

@requirement This function helps basic_json satisfying the Container requirements:

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

Since

version 1.0.0

Definition at line 2575 of file json.hpp.

Member Function Documentation

add_to_vector()

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

template<typename T >

static void nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType, JSONSerializer >::add_to_vector ( std::vector< uint8_t > &  vec, size_t  bytes, const T  number  )

inlinestaticprivate

Note

Some code in the switch cases has been copied, because otherwise copilers would complain about implicit fallthrough and there is no portable attribute to mute such warnings.

Definition at line 6546 of file json.hpp.

array()

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

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

inlinestatic

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

@complexity Linear in the size of init.

@liveexample{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 2165 of file json.hpp.

assert_invariant()

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

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

inlineprivate

checks the class invariants

This function asserts the class invariants. It needs to be called at the end of every constructor to make sure that created objects respect the invariant. Furthermore, it has to be called each time the type of a JSON value is changed, because the invariant expresses a relationship between m_type and m_value.

Definition at line 1785 of file json.hpp.

at() [1/6]

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

reference nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType, JSONSerializer >::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

@complexity 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

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

Since

version 2.0.0

Definition at line 12336 of file json.hpp.

at() [2/6]

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

const_reference nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType, JSONSerializer >::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

@complexity 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

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

Since

version 2.0.0

Definition at line 12361 of file json.hpp.

at() [3/6]

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

reference nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType, JSONSerializer >::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"

@complexity Logarithmic in the size of the container.

@liveexample{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 3621 of file json.hpp.

at() [4/6]

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

const_reference nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType, JSONSerializer >::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"

@complexity Logarithmic in the size of the container.

@liveexample{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 3668 of file json.hpp.

at() [5/6]

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

reference nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType, JSONSerializer >::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"

@complexity Constant.

@liveexample{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 3531 of file json.hpp.

at() [6/6]

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

const_reference nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType, JSONSerializer >::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"

@complexity Constant.

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

Since

version 1.0.0

Definition at line 3574 of file json.hpp.

back() [1/2]

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

reference nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType, JSONSerializer >::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

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 case of number, string, or boolean values, a reference to the value is returned.

@complexity 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.

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

See also

front() – access the first element

Since

version 1.0.0

Definition at line 4235 of file json.hpp.

back() [2/2]

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

const_reference nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType, JSONSerializer >::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

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 case of number, string, or boolean values, a reference to the value is returned.

@complexity 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.

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

See also

front() – access the first element

Since

version 1.0.0

Definition at line 4245 of file json.hpp.

begin() [1/2]

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

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

inlinenoexcept

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

@complexity Constant.

@requirement This function helps basic_json satisfying the Container requirements:

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

@liveexample{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 4680 of file json.hpp.

begin() [2/2]

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

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

inlinenoexcept

returns an iterator to the first element

Returns an iterator to the first element.

Illustration from cppreference.com

Returns

iterator to the first element

@complexity Constant.

@requirement This function helps basic_json satisfying the Container requirements:

• The complexity is constant.

@liveexample{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 4670 of file json.hpp.

cbegin()

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

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

inlinenoexcept

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

@complexity Constant.

@requirement This function helps basic_json satisfying the Container requirements:

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

@liveexample{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 4710 of file json.hpp.

cend()

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

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

inlinenoexcept

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

@complexity Constant.

@requirement This function helps basic_json satisfying the Container requirements:

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

@liveexample{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 4781 of file json.hpp.

check_length()

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

static void nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType, JSONSerializer >::check_length ( const size_t  size, const size_t  len, const size_t  offset  )

inlinestaticprivate

Definition at line 7175 of file json.hpp.

clear()

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

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

inlinenoexcept

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	[]

@complexity Linear in the size of the JSON value.

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

Since

version 1.0.0

Definition at line 5185 of file json.hpp.

count()

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

size_type nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType, JSONSerializer >::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).

Note

This method always returns 0 when executed on a JSON type that is not an object.

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.

@complexity Logarithmic in the size of the JSON object.

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

Since

version 1.0.0

Definition at line 4630 of file json.hpp.

crbegin()

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

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

inlinenoexcept

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

@complexity Constant.

@requirement This function helps basic_json satisfying the ReversibleContainer requirements:

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

@liveexample{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 4885 of file json.hpp.

create()

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

template<typename T , typename... Args>

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

inlinestaticprivate

helper for exception-safe object creation

Definition at line 1626 of file json.hpp.

crend()

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

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

inlinenoexcept

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

@complexity Constant.

@requirement This function helps basic_json satisfying the ReversibleContainer requirements:

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

@liveexample{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 4914 of file json.hpp.

diff()

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

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

inlinestatic

creates a diff as a JSON patch

Creates a JSON Patch 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:

source.patch(diff(source, target)) == target;

Note

Currently, only remove, add, and replace operations are generated.

Parameters

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

Returns

a JSON patch to convert the source to target

@complexity Linear in the lengths of source and target.

@liveexample{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)

Since

version 2.0.0

Definition at line 12765 of file json.hpp.

dump() [1/2]

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

string_t nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType, JSONSerializer >::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

@complexity Linear.

@liveexample{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 2647 of file json.hpp.

dump() [2/2]

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

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

inlineprivate

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 8415 of file json.hpp.

emplace()

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

template<class... Args>

std::pair< iterator, bool > nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType, JSONSerializer >::emplace ( Args &&...  args )

inline

add an object to an object if key does not exist

Inserts a new element into a JSON object constructed in-place with the given args if there is no element with the key in the container. If the function is called on a JSON null value, an empty object is created before appending the value created from args.

Parameters

[in]

args

arguments to forward to a constructor of basic_json

Template Parameters

Args	compatible types to create a basic_json object

Returns

a pair consisting of an iterator to the inserted element, or the already-existing element if no insertion happened, and a bool denoting whether the insertion took place.

Exceptions

std::domain_error

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

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

@liveexample{The example shows how emplace() can be used to add elements to a JSON object. Note how the null value was silently converted to a JSON object. Further note how no value is added if there was already one value stored with the same key.,emplace}

Since

version 2.0.8

Definition at line 5492 of file json.hpp.

emplace_back()

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

template<class... Args>

void nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType, JSONSerializer >::emplace_back ( Args &&...  args )

inline

add an object to an array

Creates a JSON value from the passed parameters args to the end of the JSON value. If the function is called on a JSON null value, an empty array is created before appending the value created from args.

Parameters

[in]

args

arguments to forward to a constructor of basic_json

Template Parameters

Args	compatible types to create a basic_json object

Exceptions

std::domain_error

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

@complexity Amortized constant.

@liveexample{The example shows how push_back() can be used to add elements to a JSON array. Note how the null value was silently converted to a JSON array.,emplace_back}

Since

version 2.0.8

Definition at line 5444 of file json.hpp.

empty()

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

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

inlinenoexcept

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

Note

This function does not return whether a string stored as JSON value is empty - it returns whether the JSON container itself is empty which is false in the case of a string.

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

@requirement This function helps basic_json satisfying the Container requirements:

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

@liveexample{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 4995 of file json.hpp.

end() [1/2]

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

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

inlinenoexcept

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

@complexity Constant.

@requirement This function helps basic_json satisfying the Container requirements:

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

@liveexample{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 4751 of file json.hpp.

end() [2/2]

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

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

inlinenoexcept

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

@complexity Constant.

@requirement This function helps basic_json satisfying the Container requirements:

• The complexity is constant.

@liveexample{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 4741 of file json.hpp.

erase() [1/4]

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

void nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType, JSONSerializer >::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"

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

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

See also

erase(IteratorType) – removes the element at a given position

erase(IteratorType, IteratorType) – 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 4531 of file json.hpp.

erase() [2/4]

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

size_type nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType, JSONSerializer >::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"

@complexity log(size()) + count(key)

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

See also

erase(IteratorType) – removes the element at a given position

erase(IteratorType, IteratorType) – 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 4496 of file json.hpp.

erase() [3/4]

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

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

IteratorType nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType, JSONSerializer >::erase ( IteratorType  first, IteratorType  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

IteratorType

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"

@complexity 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

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

See also

erase(IteratorType) – 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 4408 of file json.hpp.

erase() [4/4]

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

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

IteratorType nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType, JSONSerializer >::erase ( IteratorType  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

IteratorType

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"

@complexity 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

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

See also

erase(IteratorType, IteratorType) – 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 4301 of file json.hpp.

escape_string()

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

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

inlinestaticprivate

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

@complexity Linear in the length of string s.

Definition at line 8143 of file json.hpp.

extra_space()

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

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

inlinestaticprivatenoexcept

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

@complexity Linear in the length of string s.

Definition at line 8097 of file json.hpp.

find() [1/2]

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

iterator nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType, JSONSerializer >::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.

Note

This method always returns end() when executed on a JSON type that is not an object.

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 or the JSON value is not an object, past-the-end (see end()) iterator is returned.

@complexity Logarithmic in the size of the JSON object.

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

Since

version 1.0.0

Definition at line 4581 of file json.hpp.

find() [2/2]

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

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

inline

find an element in a JSON object

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.

Note

This method always returns end() when executed on a JSON type that is not an object.

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 or the JSON value is not an object, past-the-end (see end()) iterator is returned.

@complexity Logarithmic in the size of the JSON object.

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

Since

version 1.0.0

Definition at line 4597 of file json.hpp.

flatten()

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

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

inline

return flattened JSON value

The function creates a JSON object whose keys are JSON pointers (see RFC 6901) 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 primitive values

Note

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

@complexity Linear in the size the JSON value.

@liveexample{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 12388 of file json.hpp.

from_cbor()

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

static basic_json nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType, JSONSerializer >::from_cbor ( const std::vector< uint8_t > &  v, const size_t  start_index = 0  )

inlinestatic

create a JSON value from a byte vector in CBOR format

Deserializes a given byte vector v to a JSON value using the CBOR (Concise Binary Object Representation) serialization format.

Parameters

[in]	v	a byte vector in CBOR format
[in]	start_index	the index to start reading from v (0 by default)

Returns

deserialized JSON value

Exceptions

std::invalid_argument	if unsupported features from CBOR were used in the given vector v or if the input is not valid MessagePack
std::out_of_range	if the given vector ends prematurely

@complexity Linear in the size of the byte vector v.

@liveexample{The example shows the deserialization of a byte vector in CBOR format to a JSON value.,from_cbor}

See also

http://cbor.io

to_cbor(const basic_json&) for the analogous serialization

from_msgpack(const std::vector<uint8_t>&, const size_t) for the related MessagePack format

Since

version 2.0.9, parameter start_index since 2.1.1

Definition at line 8037 of file json.hpp.

from_cbor_internal()

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

static basic_json nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType, JSONSerializer >::from_cbor_internal ( const std::vector< uint8_t > &  v, size_t &  idx  )

inlinestaticprivate

create a JSON value from a given CBOR vector

Parameters

[in]	v	CBOR serialization
[in]	idx	byte index to start reading from v

Returns

deserialized JSON value

Exceptions

std::invalid_argument	if unsupported features from CBOR were used in the given vector v or if the input is not valid CBOR
std::out_of_range	if the given vector ends prematurely

See also

https://tools.ietf.org/html/rfc7049

Definition at line 7448 of file json.hpp.

from_msgpack()

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

static basic_json nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType, JSONSerializer >::from_msgpack ( const std::vector< uint8_t > &  v, const size_t  start_index = 0  )

inlinestatic

create a JSON value from a byte vector in MessagePack format

Deserializes a given byte vector v to a JSON value using the MessagePack serialization format.

Parameters

[in]	v	a byte vector in MessagePack format
[in]	start_index	the index to start reading from v (0 by default)

Returns

deserialized JSON value

Exceptions

std::invalid_argument	if unsupported features from MessagePack were used in the given vector v or if the input is not valid MessagePack
std::out_of_range	if the given vector ends prematurely

@complexity Linear in the size of the byte vector v.

@liveexample{The example shows the deserialization of a byte vector in MessagePack format to a JSON value.,from_msgpack}

See also

http://msgpack.org

to_msgpack(const basic_json&) for the analogous serialization

from_cbor(const std::vector<uint8_t>&, const size_t) for the related CBOR format

Since

version 2.0.9, parameter start_index since 2.1.1

Definition at line 7974 of file json.hpp.

from_msgpack_internal()

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

static basic_json nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType, JSONSerializer >::from_msgpack_internal ( const std::vector< uint8_t > &  v, size_t &  idx  )

inlinestaticprivate

create a JSON value from a given MessagePack vector

Parameters

[in]	v	MessagePack serialization
[in]	idx	byte index to start reading from v

Returns

deserialized JSON value

Exceptions

std::invalid_argument	if unsupported features from MessagePack were used in the given vector v or if the input is not valid MessagePack
std::out_of_range	if the given vector ends prematurely

See also

https://github.com/msgpack/msgpack/blob/master/spec.md

Definition at line 7210 of file json.hpp.

front() [1/2]

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

reference nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType, JSONSerializer >::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 case of number, string, or boolean values, a reference to the value is returned.

@complexity 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

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

See also

back() – access the last element

Since

version 1.0.0

Definition at line 4192 of file json.hpp.

front() [2/2]

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

const_reference nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType, JSONSerializer >::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 case of number, string, or boolean values, a reference to the value is returned.

@complexity 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

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

See also

back() – access the last element

Since

version 1.0.0

Definition at line 4200 of file json.hpp.

get() [1/5]

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

template<typename BasicJsonType , detail::enable_if_t< std::is_same< typename std::remove_const< BasicJsonType >::type, basic_json_t >::value, int > = 0>

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

inline

get special-case overload

This overloads avoids a lot of template boilerplate, it can be seen as the identity method

Template Parameters

BasicJsonType

== basic_json

Returns

a copy of *this

@complexity Constant.

Since

version 2.1.0

Definition at line 3173 of file json.hpp.

get() [2/5]

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

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, JSONSerializer >::get ( ) const

inlineconstexprnoexcept

get a pointer value (explicit)

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

@complexity Constant.

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

See also

get_ptr() for explicit pointer-member access

Since

version 1.0.0

Definition at line 3327 of file json.hpp.

get() [3/5]

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

template<typename ValueTypeCV , typename ValueType = detail::uncvref_t<ValueTypeCV>, detail::enable_if_t< not std::is_same< basic_json_t, ValueType >::value and detail::has_from_json< basic_json_t, ValueType >::value and not detail::has_non_default_from_json< basic_json_t, ValueType >::value, int > = 0>

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

inlinenoexcept

get a value (explicit)

Explicit type conversion between the JSON value and a compatible value which is CopyConstructible and DefaultConstructible. The value is converted by calling the json_serializer<ValueType> from_json() method.

The function is equivalent to executing

ValueType ret;
JSONSerializer<ValueType>::from_json(*this, ret);
return ret;

This overloads is chosen if:

• ValueType is not basic_json,
• json_serializer<ValueType> has a from_json() method of the form void from_json(const @ref basic_json&, ValueType&), and
• json_serializer<ValueType> does not have a from_json() method of the form ValueType from_json(const @ref basic_json&)

Template Parameters

ValueTypeCV	the provided value type
ValueType	the returned value type

Returns

copy of the JSON value, converted to ValueType

Exceptions

what	json_serializer<ValueType> from_json() method throws

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

Since

version 2.1.0

Definition at line 3225 of file json.hpp.

get() [4/5]

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

template<typename ValueTypeCV , typename ValueType = detail::uncvref_t<ValueTypeCV>, detail::enable_if_t< not std::is_same< basic_json_t, ValueType >::value and detail::has_non_default_from_json< basic_json_t, ValueType >::value, int > = 0>

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

inlinenoexcept

get a value (explicit); special case

Explicit type conversion between the JSON value and a compatible value which is not CopyConstructible and not DefaultConstructible. The value is converted by calling the json_serializer<ValueType> from_json() method.

The function is equivalent to executing

return JSONSerializer<ValueTypeCV>::from_json(*this);

This overloads is chosen if:

• ValueType is not basic_json and
• json_serializer<ValueType> has a from_json() method of the form ValueType from_json(const @ref basic_json&)

Note

If json_serializer<ValueType> has both overloads of from_json(), this one is chosen.

Template Parameters

ValueTypeCV	the provided value type
ValueType	the returned value type

Returns

copy of the JSON value, converted to ValueType

Exceptions

what	json_serializer<ValueType> from_json() method throws

Since

version 2.1.0

Definition at line 3278 of file json.hpp.

get() [5/5]

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

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, JSONSerializer >::get ( )

inlinenoexcept

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

@complexity Constant.

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

See also

get_ptr() for explicit pointer-member access

Since

version 1.0.0

Definition at line 3315 of file json.hpp.

get_allocator()

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

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

inlinestatic

returns the allocator associated with the container

Definition at line 1102 of file json.hpp.

get_from_vector()

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

template<typename T >

static T nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType, JSONSerializer >::get_from_vector ( const std::vector< uint8_t > &  vec, const size_t  current_index  )

inlinestaticprivate

take sufficient bytes from a vector to fill an integer variable

In the context of binary serialization formats, we need to read several bytes from a byte vector and combine them to multi-byte integral data types.

Parameters

[in]	vec	byte vector to read from
[in]	current_index	the position in the vector after which to read

Returns

the next sizeof(T) bytes from vec, in reverse order as T

Template Parameters

T	the integral return type

Exceptions

std::out_of_range

if there are less than sizeof(T)+1 bytes in the vector vec to read

In the for loop, the bytes from the vector are copied in reverse order into the return value. In the figures below, let sizeof(T)=4 and i be the loop variable.

Precondition:

vec: | | | a | b | c | d | T: | | | | | ^ ^ ^ ^ current_index i ptr sizeof(T)

Postcondition:

vec: | | | a | b | c | d | T: | d | c | b | a | ^ ^ ^ | i ptr current_index

See also

Code adapted from http://stackoverflow.com/a/41031865/266378.

Definition at line 6626 of file json.hpp.

get_impl()

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

boolean_t nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType, JSONSerializer >::get_impl ( boolean_t *  ) const

inlineprivate

get a boolean (explicit)

Definition at line 3026 of file json.hpp.

get_impl_ptr() [1/14]

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

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

inlineprivatenoexcept

get a pointer to the value (array)

Definition at line 3049 of file json.hpp.

get_impl_ptr() [2/14]

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

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

inlineprivatenoexcept

get a pointer to the value (boolean)

Definition at line 3073 of file json.hpp.

get_impl_ptr() [3/14]

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

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

inlineconstexprprivatenoexcept

get a pointer to the value (array)

Definition at line 3055 of file json.hpp.

get_impl_ptr() [4/14]

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

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

inlineconstexprprivatenoexcept

get a pointer to the value (boolean)

Definition at line 3079 of file json.hpp.

get_impl_ptr() [5/14]

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

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

inlineconstexprprivatenoexcept

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

Definition at line 3115 of file json.hpp.

get_impl_ptr() [6/14]

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

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

inlineconstexprprivatenoexcept

get a pointer to the value (integer number)

Definition at line 3091 of file json.hpp.

get_impl_ptr() [7/14]

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

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

inlineconstexprprivatenoexcept

get a pointer to the value (unsigned number)

Definition at line 3103 of file json.hpp.

get_impl_ptr() [8/14]

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

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

inlineconstexprprivatenoexcept

get a pointer to the value (object)

Definition at line 3043 of file json.hpp.

get_impl_ptr() [9/14]

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

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

inlineconstexprprivatenoexcept

get a pointer to the value (string)

Definition at line 3067 of file json.hpp.

get_impl_ptr() [10/14]

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

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

inlineprivatenoexcept

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

Definition at line 3109 of file json.hpp.

get_impl_ptr() [11/14]

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

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

inlineprivatenoexcept

get a pointer to the value (integer number)

Definition at line 3085 of file json.hpp.

get_impl_ptr() [12/14]

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

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

inlineprivatenoexcept

get a pointer to the value (unsigned number)

Definition at line 3097 of file json.hpp.

get_impl_ptr() [13/14]

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

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

inlineprivatenoexcept

get a pointer to the value (object)

Definition at line 3037 of file json.hpp.

get_impl_ptr() [14/14]

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

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

inlineprivatenoexcept

get a pointer to the value (string)

Definition at line 3061 of file json.hpp.

get_ptr() [1/2]

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

template<typename PointerType , typename std::enable_if< std::is_pointer< PointerType >::value and 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, JSONSerializer >::get_ptr ( ) const

inlineconstexprnoexcept

get a pointer value (implicit)

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. Enforced by a static assertion.

Returns

pointer to the internally stored JSON value if the requested pointer type PointerType fits to the JSON value; nullptr otherwise

@complexity Constant.

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

Since

version 1.0.0

Definition at line 3389 of file json.hpp.

get_ptr() [2/2]

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

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, JSONSerializer >::get_ptr ( )

inlinenoexcept

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. Enforced by a static assertion.

Returns

pointer to the internally stored JSON value if the requested pointer type PointerType fits to the JSON value; nullptr otherwise

@complexity Constant.

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

Since

version 1.0.0

Definition at line 3361 of file json.hpp.

get_ref() [1/2]

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

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, JSONSerializer >::get_ref ( )

inline

get a reference value (implicit)

Implicit 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. Enforced by static assertion.

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

@complexity Constant.

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

Since

version 1.1.0

Definition at line 3438 of file json.hpp.

get_ref() [2/2]

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

template<typename ReferenceType , typename std::enable_if< std::is_reference< ReferenceType >::value and 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, JSONSerializer >::get_ref ( ) const

inline

get a reference value (implicit)

get a reference value (implicit) Implicit 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. Enforced by static assertion.

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

@complexity Constant.

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

Since

version 1.1.0

Definition at line 3451 of file json.hpp.

get_ref_impl()

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

template<typename ReferenceType , typename ThisType >

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

inlinestaticprivate

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 3132 of file json.hpp.

insert() [1/5]

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

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

inline

inserts element

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"

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

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

Since

version 1.0.0

Definition at line 5564 of file json.hpp.

insert() [2/5]

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

iterator nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType, JSONSerializer >::insert ( const_iterator  pos, const basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType, JSONSerializer > &  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"

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

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

Since

version 1.0.0

Definition at line 5540 of file json.hpp.

insert() [3/5]

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

iterator nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType, JSONSerializer >::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

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

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

Since

version 1.0.0

Definition at line 5643 of file json.hpp.

insert() [4/5]

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

iterator nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType, JSONSerializer >::insert ( const_iterator  pos, size_type  cnt, const basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType, JSONSerializer > &  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"

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

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

Since

version 1.0.0

Definition at line 5593 of file json.hpp.

insert() [5/5]

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

iterator nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType, JSONSerializer >::insert ( const_iterator  pos, std::initializer_list< basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType, JSONSerializer > >  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

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

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

Since

version 1.0.0

Definition at line 5701 of file json.hpp.

is_array()

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

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

inlineconstexprnoexcept

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.

@complexity Constant.

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

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

Since

version 1.0.0

Definition at line 2941 of file json.hpp.

is_boolean()

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

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

inlineconstexprnoexcept

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.

@complexity Constant.

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

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

Since

version 1.0.0

Definition at line 2782 of file json.hpp.

is_discarded()

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

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

inlineconstexprnoexcept

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.

@complexity Constant.

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

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

Since

version 1.0.0

Definition at line 2990 of file json.hpp.

is_null()

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

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

inlineconstexprnoexcept

return whether value is null

This function returns true iff the JSON value is null.

Returns

true if type is null, false otherwise.

@complexity Constant.

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

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

Since

version 1.0.0

Definition at line 2760 of file json.hpp.

is_number()

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

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

inlineconstexprnoexcept

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.

@complexity Constant.

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

@liveexample{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 2812 of file json.hpp.

is_number_float()

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

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

inlineconstexprnoexcept

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.

@complexity Constant.

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

@liveexample{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 2897 of file json.hpp.

is_number_integer()

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

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

inlineconstexprnoexcept

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.

@complexity Constant.

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

@liveexample{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 2841 of file json.hpp.

is_number_unsigned()

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

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

inlineconstexprnoexcept

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.

@complexity Constant.

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

@liveexample{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 2869 of file json.hpp.

is_object()

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

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

inlineconstexprnoexcept

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.

@complexity Constant.

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

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

Since

version 1.0.0

Definition at line 2919 of file json.hpp.

is_primitive()

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

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

inlineconstexprnoexcept

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.

@complexity Constant.

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

@liveexample{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 2711 of file json.hpp.

is_string()

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

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

inlineconstexprnoexcept

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.

@complexity Constant.

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

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

Since

version 1.0.0

Definition at line 2963 of file json.hpp.

is_structured()

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

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

inlineconstexprnoexcept

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.

@complexity Constant.

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

@liveexample{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 2738 of file json.hpp.

iterator_wrapper() [1/2]

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

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

inlinestatic

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 4943 of file json.hpp.

iterator_wrapper() [2/2]

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

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

inlinestatic

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 4935 of file json.hpp.

max_size()

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

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

inlinenoexcept

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. std::distance(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()

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

@requirement This function helps basic_json satisfying the Container requirements:

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

@liveexample{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 5129 of file json.hpp.

meta()

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

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

inlinestatic

returns version information on the library

This function returns a JSON object with information about the library, including the version number and information on the platform and compiler.

Returns

JSON object holding version information

key	description
compiler	Information on the used compiler. It is an object with the following keys: c++ (the used C++ standard), family (the compiler family; possible values are clang, icc, gcc, ilecpp, msvc, pgcpp, sunpro, and unknown), and version (the compiler version).
copyright	The copyright line for the library as string.
name	The name of the library as string.
platform	The used platform as string. Possible values are win32, linux, apple, unix, and unknown.
url	The URL of the project as string.
version	The version of the library. It is an object with the following keys: major, minor, and patch as defined by Semantic Versioning, and string (the version string).

@liveexample{The following code shows an example output of the meta() function.,meta}

@complexity Constant.

Since

2.1.0

Definition at line 1130 of file json.hpp.

object()

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

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

inlinestatic

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)

@complexity Linear in the size of init.

@liveexample{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 2205 of file json.hpp.

operator value_t()

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

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

inlineconstexprnoexcept

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

@complexity Constant.

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

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

Since

version 1.0.0

Definition at line 3013 of file json.hpp.

operator ValueType()

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

template<typename ValueType , typename std::enable_if< not std::is_pointer< ValueType >::value and not std::is_same< ValueType, typename string_t::value_type >::value and 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, JSONSerializer >::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

@complexity Linear in the size of the JSON value.

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

Since

version 1.0.0

Definition at line 3492 of file json.hpp.

operator+=() [1/4]

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

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

inline

add an object to an array

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"

@complexity Amortized constant.

@liveexample{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 5284 of file json.hpp.

operator+=() [2/4]

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

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

inline

add an object to an array

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"

@complexity Amortized constant.

@liveexample{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 5318 of file json.hpp.

operator+=() [3/4]

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

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

inline

add an object to an object

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"

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

@liveexample{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 5368 of file json.hpp.

operator+=() [4/4]

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

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

inline

add an object to an object

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

@complexity 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.

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

Definition at line 5416 of file json.hpp.

operator=()

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

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

inlinenoexcept

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

@complexity Linear.

@requirement This function helps basic_json satisfying the Container requirements:

• The complexity is linear.

@liveexample{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 2542 of file json.hpp.

operator[]() [1/10]

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

reference nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType, JSONSerializer >::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

@complexity 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

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

Since

version 2.0.0

Definition at line 12284 of file json.hpp.

operator[]() [2/10]

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

const_reference nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType, JSONSerializer >::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

@complexity 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

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

Since

version 2.0.0

Definition at line 12311 of file json.hpp.

operator[]() [3/10]

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

reference nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType, JSONSerializer >::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"

@complexity Logarithmic in the size of the container.

@liveexample{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 3798 of file json.hpp.

operator[]() [4/10]

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

const_reference nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType, JSONSerializer >::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

Precondition

The element with key key must exist. This precondition is enforced with an assertion.

Exceptions

std::domain_error

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

@complexity Logarithmic in the size of the container.

@liveexample{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 3847 of file json.hpp.

operator[]() [5/10]

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

reference nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType, JSONSerializer >::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"

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

@liveexample{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 3714 of file json.hpp.

operator[]() [6/10]

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

const_reference nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType, JSONSerializer >::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"

@complexity Constant.

@liveexample{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 3760 of file json.hpp.

operator[]() [7/10]

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

template<typename T , std::size_t n>

reference nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType, JSONSerializer >::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"

@complexity Logarithmic in the size of the container.

@liveexample{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 3887 of file json.hpp.

operator[]() [8/10]

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

template<typename T , std::size_t n>

const_reference nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType, JSONSerializer >::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"

@complexity Logarithmic in the size of the container.

@liveexample{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 3922 of file json.hpp.

operator[]() [9/10]

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

template<typename T >

reference nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType, JSONSerializer >::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"

@complexity Logarithmic in the size of the container.

@liveexample{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 3955 of file json.hpp.

operator[]() [10/10]

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

template<typename T >

const_reference nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType, JSONSerializer >::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

Precondition

The element with key key must exist. This precondition is enforced with an assertion.

Exceptions

std::domain_error

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

@complexity Logarithmic in the size of the container.

@liveexample{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 4005 of file json.hpp.

parse() [1/6]

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

template<typename CharT , typename std::enable_if< std::is_pointer< CharT >::value and std::is_integral< typename std::remove_pointer< CharT >::type >::value and sizeof(typename std::remove_pointer< CharT >::type)==1, int >::type = 0>

static basic_json nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType, JSONSerializer >::parse ( const CharT  s, const parser_callback_t  cb = nullptr  )

inlinestatic

deserialize from string literal

Template Parameters

CharT

character/literal type with size of 1 byte

Parameters

[in]	s	string literal 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

@complexity 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.

String containers like std::string or string_t can be parsed with parse(const ContiguousContainer&, const parser_callback_t)

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

See also

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

Since

version 1.0.0 (originally for string_t)

Definition at line 6322 of file json.hpp.

parse() [2/6]

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

template<class ContiguousContainer , typename std::enable_if< not std::is_pointer< ContiguousContainer >::value and std::is_base_of< std::random_access_iterator_tag, typename std::iterator_traits< decltype(std::begin(std::declval< ContiguousContainer const >()))>::iterator_category >::value , int , ::type = 0>

static basic_json nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType, JSONSerializer >::parse ( const ContiguousContainer &  c, const parser_callback_t  cb = nullptr  )

inlinestatic

deserialize from a container with contiguous storage

This function reads from a container with contiguous storage of 1-byte values. Compatible container types include std::vector, std::string, std::array, and std::initializer_list. User-defined containers can be used as long as they implement random-access iterators and a contiguous storage.

Precondition

The container storage is contiguous. Violating this precondition yields undefined behavior. This precondition is enforced with an assertion.

Each element of the container has a size of 1 byte. Violating this precondition yields undefined behavior. This precondition is enforced with a static assertion.

Warning

There is no way to enforce all preconditions at compile-time. If the function is called with a noncompliant container and with assertions switched off, the behavior is undefined and will most likely yield segmentation violation.

Template Parameters

ContiguousContainer

container type with contiguous storage

Parameters

[in]	c	container to read 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

@complexity 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.

@liveexample{The example below demonstrates the parse() function reading from a contiguous container.,parse__contiguouscontainer__parser_callback_t}

Since

version 2.0.3

Definition at line 6484 of file json.hpp.

parse() [3/6]

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

template<class IteratorType , typename std::enable_if< std::is_base_of< std::random_access_iterator_tag, typename std::iterator_traits< IteratorType >::iterator_category >::value, int >::type = 0>

static basic_json nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType, JSONSerializer >::parse ( IteratorType  first, IteratorType  last, const parser_callback_t  cb = nullptr  )

inlinestatic

deserialize from an iterator range with contiguous storage

This function reads from an iterator range of a container with contiguous storage of 1-byte values. Compatible container types include std::vector, std::string, std::array, std::valarray, and std::initializer_list. Furthermore, C-style arrays can be used with std::begin()/std::end(). User-defined containers can be used as long as they implement random-access iterators and a contiguous storage.

Precondition

The iterator range is contiguous. Violating this precondition yields undefined behavior. This precondition is enforced with an assertion.

Each element in the range has a size of 1 byte. Violating this precondition yields undefined behavior. This precondition is enforced with a static assertion.

Warning

There is no way to enforce all preconditions at compile-time. If the function is called with noncompliant iterators and with assertions switched off, the behavior is undefined and will most likely yield segmentation violation.

Template Parameters

IteratorType

iterator of container with contiguous storage

Parameters

[in]	first	begin of the range to parse (included)
[in]	last	end of the range to parse (excluded)
[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

@complexity 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.

@liveexample{The example below demonstrates the parse() function reading from an iterator range.,parse__iteratortype__parser_callback_t}

Since

version 2.0.3

Definition at line 6412 of file json.hpp.

parse() [4/6]

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

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

inlinestatic

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

@complexity 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.

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

See also

parse(const CharT, const parser_callback_t) for a version that reads from a string

Since

version 1.0.0

Definition at line 6361 of file json.hpp.

parse() [5/6]

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

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

inlinestatic

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

@complexity 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.

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

See also

parse(const CharT, const parser_callback_t) for a version that reads from a string

Since

version 1.0.0

Definition at line 6352 of file json.hpp.

parse() [6/6]

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

template<class T , std::size_t N>

static basic_json nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType, JSONSerializer >::parse ( T(&)  array[N], const parser_callback_t  cb = nullptr  )

inlinestatic

deserialize from an array

This function reads from an array of 1-byte values.

Precondition

Each element of the container has a size of 1 byte. Violating this precondition yields undefined behavior. This precondition is enforced with a static assertion.

Parameters

[in]	array	array to read 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

@complexity 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.

@liveexample{The example below demonstrates the parse() function reading from an array.,parse__array__parser_callback_t}

Since

version 2.0.3

Definition at line 6284 of file json.hpp.

patch()

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

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

inline

applies a JSON patch

JSON Patch defines a JSON document structure for expressing a sequence of operations to apply to a JSON) document. With this function, 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"

@complexity 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.

@liveexample{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)

RFC 6901 (JSON Pointer)

Since

version 2.0.0

Definition at line 12472 of file json.hpp.

push_back() [1/4]

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

void nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType, JSONSerializer >::push_back ( basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType, JSONSerializer > &&  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"

@complexity Amortized constant.

@liveexample{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 5258 of file json.hpp.

push_back() [2/4]

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

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

inline

add an object to an array

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"

@complexity Amortized constant.

@liveexample{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 5294 of file json.hpp.

push_back() [3/4]

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

void nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType, JSONSerializer >::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"

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

@liveexample{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 5344 of file json.hpp.

push_back() [4/4]

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

void nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType, JSONSerializer >::push_back ( std::initializer_list< basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType, JSONSerializer > >  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

@complexity 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.

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

Definition at line 5399 of file json.hpp.

rbegin() [1/2]

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

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

inlinenoexcept

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

@complexity Constant.

@requirement This function helps basic_json satisfying the ReversibleContainer requirements:

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

@liveexample{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 4819 of file json.hpp.

rbegin() [2/2]

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

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

inlinenoexcept

returns an iterator to the reverse-beginning

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

Illustration from cppreference.com

@complexity Constant.

@requirement This function helps basic_json satisfying the ReversibleContainer requirements:

• The complexity is constant.
• Has the semantics of reverse_iterator(end()).

@liveexample{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 4811 of file json.hpp.

rend() [1/2]

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

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

inlinenoexcept

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

@complexity Constant.

@requirement This function helps basic_json satisfying the ReversibleContainer requirements:

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

@liveexample{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 4856 of file json.hpp.

rend() [2/2]

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

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

inlinenoexcept

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

@complexity Constant.

@requirement This function helps basic_json satisfying the ReversibleContainer requirements:

• The complexity is constant.
• Has the semantics of reverse_iterator(begin()).

@liveexample{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 4848 of file json.hpp.

size()

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

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

inlinenoexcept

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

Note

This function does not return the length of a string stored as JSON value - it returns the number of elements in the JSON value which is 1 in the case of a string.

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

@requirement This function helps basic_json satisfying the Container requirements:

• The complexity is constant.
• Has the semantics of std::distance(begin(), end()).

@liveexample{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 5063 of file json.hpp.

swap() [1/4]

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

void nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType, JSONSerializer >::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"

@complexity Constant.

@liveexample{The example below shows how arrays can be swapped with swap().,swap__array_t}

Since

version 1.0.0

Definition at line 5770 of file json.hpp.

swap() [2/4]

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

void nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType, JSONSerializer >::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"

@complexity Constant.

@liveexample{The example below shows how objects can be swapped with swap().,swap__object_t}

Since

version 1.0.0

Definition at line 5803 of file json.hpp.

swap() [3/4]

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

void nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType, JSONSerializer >::swap ( reference  other )

inlinenoexcept

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

@complexity Constant.

@liveexample{The example below shows how JSON values can be swapped with swap().,swap__reference}

Since

version 1.0.0

Definition at line 5738 of file json.hpp.

swap() [4/4]

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

void nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType, JSONSerializer >::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"

@complexity Constant.

@liveexample{The example below shows how strings can be swapped with swap().,swap__string_t}

Since

version 1.0.0

Definition at line 5836 of file json.hpp.

to_cbor()

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

static std::vector< uint8_t > nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType, JSONSerializer >::to_cbor ( const basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType, JSONSerializer > &  j )

inlinestatic

create a MessagePack serialization of a given JSON value

Serializes a given JSON value j to a byte vector using the CBOR (Concise Binary Object Representation) serialization format. CBOR is a binary serialization format which aims to be more compact than JSON itself, yet more efficient to parse.

Parameters

[in]

j

JSON value to serialize

Returns

MessagePack serialization as byte vector

@complexity Linear in the size of the JSON value j.

@liveexample{The example shows the serialization of a JSON value to a byte vector in CBOR format.,to_cbor}

See also

http://cbor.io

from_cbor(const std::vector<uint8_t>&, const size_t) for the analogous deserialization

to_msgpack(const basic_json& for the related MessagePack format

Since

version 2.0.9

Definition at line 8004 of file json.hpp.

to_cbor_internal()

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

static void nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType, JSONSerializer >::to_cbor_internal ( const basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType, JSONSerializer > &  j, std::vector< uint8_t > &  v  )

inlinestaticprivate

create a CBOR serialization of a given JSON value

This is a straightforward implementation of the CBOR specification.

Parameters

[in]	j	JSON value to serialize
[in,out]	v	byte vector to write the serialization to

See also

https://tools.ietf.org/html/rfc7049

Definition at line 6898 of file json.hpp.

to_msgpack()

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

static std::vector< uint8_t > nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType, JSONSerializer >::to_msgpack ( const basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType, JSONSerializer > &  j )

inlinestatic

create a MessagePack serialization of a given JSON value

Serializes a given JSON value j to a byte vector using the MessagePack serialization format. MessagePack is a binary serialization format which aims to be more compact than JSON itself, yet more efficient to parse.

Parameters

[in]

j

JSON value to serialize

Returns

MessagePack serialization as byte vector

@complexity Linear in the size of the JSON value j.

@liveexample{The example shows the serialization of a JSON value to a byte vector in MessagePack format.,to_msgpack}

See also

http://msgpack.org

from_msgpack(const std::vector<uint8_t>&, const size_t) for the analogous deserialization

to_cbor(const basic_json& for the related CBOR format

Since

version 2.0.9

Definition at line 7941 of file json.hpp.

to_msgpack_internal()

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

static void nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType, JSONSerializer >::to_msgpack_internal ( const basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType, JSONSerializer > &  j, std::vector< uint8_t > &  v  )

inlinestaticprivate

create a MessagePack serialization of a given JSON value

This is a straightforward implementation of the MessagePack specification.

Parameters

[in]	j	JSON value to serialize
[in,out]	v	byte vector to write the serialization to

See also

https://github.com/msgpack/msgpack/blob/master/spec.md

Definition at line 6652 of file json.hpp.

type()

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

constexpr value_t nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType, JSONSerializer >::type ( ) const

inlineconstexprnoexcept

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

@complexity Constant.

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

@liveexample{The following code exemplifies type() for all JSON types.,type}

Since

version 1.0.0

Definition at line 2681 of file json.hpp.

type_name()

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

std::string nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType, JSONSerializer >::type_name ( ) const

inline

return the type as string

Returns the type name as string to be used in error messages - usually to indicate that a function was called on a wrong JSON type.

Returns

basically a string representation of a the m_type member

@complexity Constant.

@liveexample{The following code exemplifies type_name() for all JSON types.,type_name}

Since

version 1.0.0, public since 2.1.0

Definition at line 8065 of file json.hpp.

unflatten()

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

basic_json nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType, JSONSerializer >::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)
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().

@complexity Linear in the size the JSON value.

@liveexample{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 12422 of file json.hpp.

value() [1/4]

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

string_t nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType, JSONSerializer >::value ( const json_pointer &  ptr, const char *  default_value  ) const

inline

overload for a default value of type const char*

access specified object element via JSON Pointer 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

try {
    return at(ptr);
} catch(std::out_of_range) {
    return default_value;
}

Note

Unlike at(const json_pointer&), this function does not throw if the given key key was not found.

Parameters

[in]	ptr	a JSON pointer to the element to access
[in]	default_value	the value to return if ptr found no value

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"

@complexity Logarithmic in the size of the container.

@liveexample{The example below shows how object elements can be queried with a default value.,basic_json__value_ptr}

See also

operator[](const json_pointer&) for unchecked access by reference

Since

version 2.0.2

Definition at line 4162 of file json.hpp.

value() [2/4]

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

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

inline

access specified object element via JSON Pointer 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

try {
    return at(ptr);
} catch(std::out_of_range) {
    return default_value;
}

Note

Unlike at(const json_pointer&), this function does not throw if the given key key was not found.

Parameters

[in]	ptr	a JSON pointer to the element to access
[in]	default_value	the value to return if ptr found no value

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"

@complexity Logarithmic in the size of the container.

@liveexample{The example below shows how object elements can be queried with a default value.,basic_json__value_ptr}

See also

operator[](const json_pointer&) for unchecked access by reference

Since

version 2.0.2

Definition at line 4139 of file json.hpp.

value() [3/4]

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

string_t nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType, JSONSerializer >::value ( const typename object_t::key_type &  key, const char *  default_value  ) const

inline

overload for a default value of type const char*

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

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"

@complexity Logarithmic in the size of the container.

@liveexample{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 4091 of file json.hpp.

value() [4/4]

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

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, JSONSerializer >::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

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"

@complexity Logarithmic in the size of the container.

@liveexample{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 4067 of file json.hpp.

Friends And Related Function Documentation

detail::external_constructor

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

template<detail::value_t >

friend struct detail::external_constructor

friend

Definition at line 1042 of file json.hpp.

operator!= [1/3]

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

template<typename ScalarType , typename std::enable_if< std::is_scalar< ScalarType >::value, int >::type = 0>

bool operator!= ( const ScalarType  lhs, const_reference  rhs  )

friend

comparison: not equal

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

@complexity Linear.

@liveexample{The example demonstrates comparing several JSON types.,operator__notequal}

Since

version 1.0.0

Definition at line 6017 of file json.hpp.

operator!= [2/3]

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

template<typename ScalarType , typename std::enable_if< std::is_scalar< ScalarType >::value, int >::type = 0>

bool operator!= ( const_reference  lhs, const ScalarType  rhs  )

friend

comparison: not equal

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

@complexity Linear.

@liveexample{The example demonstrates comparing several JSON types.,operator__notequal}

Since

version 1.0.0

Definition at line 6006 of file json.hpp.

operator!= [3/3]

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

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

@complexity Linear.

@liveexample{The example demonstrates comparing several JSON types.,operator__notequal}

Since

version 1.0.0

Definition at line 5995 of file json.hpp.

operator<

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

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

@complexity Linear.

@liveexample{The example demonstrates comparing several JSON types.,operator__less}

Since

version 1.0.0

Definition at line 6046 of file json.hpp.

operator<< [1/2]

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

std::istream & operator<< ( basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType, JSONSerializer > &  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

@complexity 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.

@liveexample{The example below shows how a JSON value is constructed by reading a serialization from a stream.,operator_deserialize}

See also

parse(std::istream&, const parser_callback_t) for a variant with a parser callback function to filter values while parsing

Since

version 1.0.0

Definition at line 6514 of file json.hpp.

operator<< [2/2]

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

std::ostream & operator<< ( std::ostream &  o, const basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType, JSONSerializer > &  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

@complexity Linear.

@liveexample{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 6222 of file json.hpp.

operator<=

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

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

@complexity Linear.

@liveexample{The example demonstrates comparing several JSON types.,operator__greater}

Since

version 1.0.0

Definition at line 6141 of file json.hpp.

operator== [1/3]

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

template<typename ScalarType , typename std::enable_if< std::is_scalar< ScalarType >::value, int >::type = 0>

bool operator== ( const ScalarType  lhs, const_reference  rhs  )

friend

comparison: equal

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

@complexity Linear.

@liveexample{The example demonstrates comparing several JSON types.,operator__equal}

Since

version 1.0.0

Definition at line 5974 of file json.hpp.

operator== [2/3]

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

template<typename ScalarType , typename std::enable_if< std::is_scalar< ScalarType >::value, int >::type = 0>

bool operator== ( const_reference  lhs, const ScalarType  rhs  )

friend

comparison: equal

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

@complexity Linear.

@liveexample{The example demonstrates comparing several JSON types.,operator__equal}

Since

version 1.0.0

Definition at line 5963 of file json.hpp.

operator== [3/3]

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

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

@complexity Linear.

@liveexample{The example demonstrates comparing several JSON types.,operator__equal}

Since

version 1.0.0

Definition at line 5882 of file json.hpp.

operator>

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

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

@complexity Linear.

@liveexample{The example demonstrates comparing several JSON types.,operator__lessequal}

Since

version 1.0.0

Definition at line 6163 of file json.hpp.

operator>=

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

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

@complexity Linear.

@liveexample{The example demonstrates comparing several JSON types.,operator__greaterequal}

Since

version 1.0.0

Definition at line 6185 of file json.hpp.

operator>> [1/2]

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

std::ostream & operator>> ( const basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType, JSONSerializer > &  j, std::ostream &  o  )

friend

serialize to stream

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

@complexity Linear.

@liveexample{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 6241 of file json.hpp.

operator>> [2/2]

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

std::istream & operator>> ( std::istream &  i, basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType, JSONSerializer > &  j  )

friend

deserialize from stream

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

@complexity 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.

@liveexample{The example below shows how a JSON value is constructed by reading a serialization from a stream.,operator_deserialize}

See also

parse(std::istream&, const parser_callback_t) for a variant with a parser callback function to filter values while parsing

Since

version 1.0.0

Definition at line 6524 of file json.hpp.

Member Data Documentation

m_type

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

value_t nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType, JSONSerializer >::m_type = value_t::null

private

the type of the current element

Definition at line 8553 of file json.hpp.

m_value

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

json_value nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType, JSONSerializer >::m_value = {}

private

the value of the current element

Definition at line 8556 of file json.hpp.

Libraries for nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType, JSONSerializer >:

[legend]