detail namespace with internal helper functions More...

Namespaces
	dtoa_impl
	implements the Grisu2 algorithm for binary to decimal floating-point conversion.

Classes
class	binary_reader
	deserialization of CBOR and MessagePack values More...

class	binary_writer
	serialization to CBOR and MessagePack values More...

struct	conjunction

struct	conjunction< B1 >

struct	conjunction< B1, Bn... >

class	exception
	general exception of the basic_json class More...

struct	external_constructor

struct	external_constructor< value_t::array >

struct	external_constructor< value_t::boolean >

struct	external_constructor< value_t::number_float >

struct	external_constructor< value_t::number_integer >

struct	external_constructor< value_t::number_unsigned >

struct	external_constructor< value_t::object >

struct	external_constructor< value_t::string >

struct	from_json_fn

struct	has_from_json

struct	has_non_default_from_json

struct	has_to_json

struct	index_sequence

class	input_adapter

struct	input_adapter_protocol
	abstract input adapter interface More...

class	input_buffer_adapter
	input adapter for buffer input More...

class	input_stream_adapter

struct	internal_iterator
	an iterator value More...

class	invalid_iterator
	exception indicating errors with iterators More...

struct	is_basic_json

struct	is_basic_json< NLOHMANN_BASIC_JSON_TPL >

struct	is_basic_json_nested_type

struct	is_compatible_array_type

struct	is_compatible_complete_type

struct	is_compatible_integer_type

struct	is_compatible_integer_type_impl

struct	is_compatible_integer_type_impl< true, RealIntegerType, CompatibleNumberIntegerType >

struct	is_compatible_object_type

struct	is_compatible_object_type_impl

struct	is_compatible_object_type_impl< true, RealType, CompatibleObjectType >

struct	is_compatible_type

struct	is_complete_type

struct	is_complete_type< T, decltype(void(sizeof(T)))>

class	iter_impl
	a template for a bidirectional iterator for the basic_json class More...

class	iteration_proxy
	proxy class for the items() function More...

class	json_ref

class	json_reverse_iterator
	a template for a reverse iterator class More...

class	lexer
	lexical analysis More...

struct	make_index_sequence

struct	make_index_sequence< 0 >

struct	make_index_sequence< 1 >

struct	merge_and_renumber

struct	merge_and_renumber< index_sequence< I1... >, index_sequence< I2... > >

struct	negation

class	other_error
	exception indicating other library errors More...

class	out_of_range
	exception indicating access out of the defined range More...

class	output_adapter

struct	output_adapter_protocol
	abstract output adapter interface More...

class	output_stream_adapter
	output adapter for output streams More...

class	output_string_adapter
	output adapter for basic_string More...

class	output_vector_adapter
	output adapter for byte vectors More...

class	parse_error
	exception indicating a parse error More...

class	parser
	syntax analysis More...

class	primitive_iterator_t

struct	priority_tag

struct	priority_tag< 0 >

class	serializer

struct	static_const

struct	to_json_fn

class	type_error
	exception indicating executing a member function with a wrong type More...

Typedefs
template<bool B, typename T = void>
using	enable_if_t = typename std::enable_if< B, T >::type

template<typename T >
using	uncvref_t = typename std::remove_cv< typename std::remove_reference< T >::type >::type

template<typename... Ts>
using	index_sequence_for = make_index_sequence< sizeof...(Ts)>

using	input_adapter_t = std::shared_ptr< input_adapter_protocol >
	a type to simplify interfaces

template<typename CharType >
using	output_adapter_t = std::shared_ptr< output_adapter_protocol< CharType > >
	a type to simplify interfaces

Enumerations
enum	value_t : std::uint8_t { value_t::null, value_t::object, value_t::array, value_t::string, value_t::boolean, value_t::number_integer, value_t::number_unsigned, value_t::number_float, value_t::discarded }
	the JSON type enumeration More...

Functions
	NLOHMANN_JSON_HAS_HELPER (mapped_type)

	NLOHMANN_JSON_HAS_HELPER (key_type)

	NLOHMANN_JSON_HAS_HELPER (value_type)

	NLOHMANN_JSON_HAS_HELPER (iterator)

bool	operator< (const value_t lhs, const value_t rhs) noexcept
	comparison operator for JSON types More...

template<typename BasicJsonType , typename ArithmeticType , enable_if_t< std::is_arithmetic< ArithmeticType >::value and not std::is_same< ArithmeticType, typename BasicJsonType::boolean_t >::value, int > = 0>
void	get_arithmetic_value (const BasicJsonType &j, ArithmeticType &val)

template<typename BasicJsonType >
void	from_json (const BasicJsonType &j, typename BasicJsonType::boolean_t &b)

template<typename BasicJsonType >
void	from_json (const BasicJsonType &j, typename BasicJsonType::string_t &s)

template<typename BasicJsonType >
void	from_json (const BasicJsonType &j, typename BasicJsonType::number_float_t &val)

template<typename BasicJsonType >
void	from_json (const BasicJsonType &j, typename BasicJsonType::number_unsigned_t &val)

template<typename BasicJsonType >
void	from_json (const BasicJsonType &j, typename BasicJsonType::number_integer_t &val)

template<typename BasicJsonType , typename EnumType , enable_if_t< std::is_enum< EnumType >::value, int > = 0>
void	from_json (const BasicJsonType &j, EnumType &e)

template<typename BasicJsonType >
void	from_json (const BasicJsonType &j, typename BasicJsonType::array_t &arr)

template<typename BasicJsonType , typename T , typename Allocator , enable_if_t< std::is_convertible< BasicJsonType, T >::value, int > = 0>
void	from_json (const BasicJsonType &j, std::forward_list< T, Allocator > &l)

template<typename BasicJsonType , typename T , enable_if_t< std::is_convertible< BasicJsonType, T >::value, int > = 0>
void	from_json (const BasicJsonType &j, std::valarray< T > &l)

template<typename BasicJsonType , typename CompatibleArrayType >
void	from_json_array_impl (const BasicJsonType &j, CompatibleArrayType &arr, priority_tag< 0 >)

template<typename BasicJsonType , typename CompatibleArrayType >
auto	from_json_array_impl (const BasicJsonType &j, CompatibleArrayType &arr, priority_tag< 1 >) -> decltype(arr.reserve(std::declval< typename CompatibleArrayType::size_type >()), void())

template<typename BasicJsonType , typename T , std::size_t N>
void	from_json_array_impl (const BasicJsonType &j, std::array< T, N > &arr, priority_tag< 2 >)

template<typename BasicJsonType , typename CompatibleArrayType , enable_if_t< is_compatible_array_type< BasicJsonType, CompatibleArrayType >::value and not std::is_same< typename BasicJsonType::array_t, CompatibleArrayType >::value and std::is_constructible< BasicJsonType, typename CompatibleArrayType::value_type >::value, int > = 0>
void	from_json (const BasicJsonType &j, CompatibleArrayType &arr)

template<typename BasicJsonType , typename CompatibleObjectType , enable_if_t< is_compatible_object_type< BasicJsonType, CompatibleObjectType >::value, int > = 0>
void	from_json (const BasicJsonType &j, CompatibleObjectType &obj)

template<typename BasicJsonType , typename ArithmeticType , enable_if_t< std::is_arithmetic< ArithmeticType >::value and not std::is_same< ArithmeticType, typename BasicJsonType::number_unsigned_t >::value and not std::is_same< ArithmeticType, typename BasicJsonType::number_integer_t >::value and not std::is_same< ArithmeticType, typename BasicJsonType::number_float_t >::value and not std::is_same< ArithmeticType, typename BasicJsonType::boolean_t >::value, int > = 0>
void	from_json (const BasicJsonType &j, ArithmeticType &val)

template<typename BasicJsonType , typename A1 , typename A2 >
void	from_json (const BasicJsonType &j, std::pair< A1, A2 > &p)

template<typename BasicJsonType , typename Tuple , std::size_t... Idx>
void	from_json_tuple_impl (const BasicJsonType &j, Tuple &t, index_sequence< Idx... >)

template<typename BasicJsonType , typename... Args>
void	from_json (const BasicJsonType &j, std::tuple< Args... > &t)

template<typename BasicJsonType , typename T , enable_if_t< std::is_same< T, typename BasicJsonType::boolean_t >::value, int > = 0>
void	to_json (BasicJsonType &j, T b) noexcept

template<typename BasicJsonType , typename CompatibleString , enable_if_t< std::is_constructible< typename BasicJsonType::string_t, CompatibleString >::value, int > = 0>
void	to_json (BasicJsonType &j, const CompatibleString &s)

template<typename BasicJsonType >
void	to_json (BasicJsonType &j, typename BasicJsonType::string_t &&s)

template<typename BasicJsonType , typename FloatType , enable_if_t< std::is_floating_point< FloatType >::value, int > = 0>
void	to_json (BasicJsonType &j, FloatType val) noexcept

template<typename BasicJsonType , typename CompatibleNumberUnsignedType , enable_if_t< is_compatible_integer_type< typename BasicJsonType::number_unsigned_t, CompatibleNumberUnsignedType >::value, int > = 0>
void	to_json (BasicJsonType &j, CompatibleNumberUnsignedType val) noexcept

template<typename BasicJsonType , typename CompatibleNumberIntegerType , enable_if_t< is_compatible_integer_type< typename BasicJsonType::number_integer_t, CompatibleNumberIntegerType >::value, int > = 0>
void	to_json (BasicJsonType &j, CompatibleNumberIntegerType val) noexcept

template<typename BasicJsonType , typename EnumType , enable_if_t< std::is_enum< EnumType >::value, int > = 0>
void	to_json (BasicJsonType &j, EnumType e) noexcept

template<typename BasicJsonType >
void	to_json (BasicJsonType &j, const std::vector< bool > &e)

template<typename BasicJsonType , typename CompatibleArrayType , enable_if_t< is_compatible_array_type< BasicJsonType, CompatibleArrayType >::value or std::is_same< typename BasicJsonType::array_t, CompatibleArrayType >::value, int > = 0>
void	to_json (BasicJsonType &j, const CompatibleArrayType &arr)

template<typename BasicJsonType , typename T , enable_if_t< std::is_convertible< T, BasicJsonType >::value, int > = 0>
void	to_json (BasicJsonType &j, std::valarray< T > arr)

template<typename BasicJsonType >
void	to_json (BasicJsonType &j, typename BasicJsonType::array_t &&arr)

template<typename BasicJsonType , typename CompatibleObjectType , enable_if_t< is_compatible_object_type< BasicJsonType, CompatibleObjectType >::value, int > = 0>
void	to_json (BasicJsonType &j, const CompatibleObjectType &obj)

template<typename BasicJsonType >
void	to_json (BasicJsonType &j, typename BasicJsonType::object_t &&obj)

template<typename BasicJsonType , typename T , std::size_t N, enable_if_t< not std::is_constructible< typename BasicJsonType::string_t, T(&)[N]>::value, int > = 0>
void	to_json (BasicJsonType &j, T(&arr)[N])

template<typename BasicJsonType , typename... Args>
void	to_json (BasicJsonType &j, const std::pair< Args... > &p)

template<typename BasicJsonType , typename Tuple , std::size_t... Idx>
void	to_json_tuple_impl (BasicJsonType &j, const Tuple &t, index_sequence< Idx... >)

template<typename BasicJsonType , typename... Args>
void	to_json (BasicJsonType &j, const std::tuple< Args... > &t)

template<typename FloatType >
char *	to_chars (char first, char last, FloatType value)
	generates a decimal representation of the floating-point number value in [first, last). More...

Detailed Description

detail namespace with internal helper functions

This namespace collects functions that should not be exposed, implementations of some basic_json methods, and meta-programming helpers.

Since: version 2.1.0

Enumeration Type Documentation

◆ value_t

enum nlohmann::detail::value_t : std::uint8_t

strong

the JSON type enumeration

This enumeration collects the different JSON types. It is internally used to distinguish the stored values, and the functions basic_json::is_null(), basic_json::is_object(), basic_json::is_array(), basic_json::is_string(), basic_json::is_boolean(), basic_json::is_number() (with basic_json::is_number_integer(), basic_json::is_number_unsigned(), and basic_json::is_number_float()), basic_json::is_discarded(), basic_json::is_primitive(), and basic_json::is_structured() rely on it.

Note: There are three enumeration entries (number_integer, number_unsigned, and number_float), because the library distinguishes these three types for numbers: basic_json::number_unsigned_t is used for unsigned integers, basic_json::number_integer_t is used for signed integers, and basic_json::number_float_t is used for floating-point numbers or to approximate integers which do not fit in the limits of their respective type.

See also: basic_json::basic_json(const value_t value_type) – create a JSON value with the default value for a given type

Since: version 1.0.0

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

Function Documentation

◆ operator<()

bool nlohmann::detail::operator<	(	const value_t	lhs,
		const value_t	rhs
	)

inlinenoexcept

comparison operator for JSON types

Returns an ordering that is similar to Python:

order: null < boolean < number < object < array < string
furthermore, each type is not smaller than itself
discarded values are not comparable

Since: version 1.0.0

◆ to_chars()

template<typename FloatType >

char* nlohmann::detail::to_chars	(	char *	first,
		char *	last,
		FloatType	value
	)

generates a decimal representation of the floating-point number value in [first, last).

The format of the resulting decimal representation is similar to printf's g format. Returns an iterator pointing past-the-end of the decimal representation.

Note: The input number must be finite, i.e. NaN's and Inf's are not supported.; The buffer must be large enough.; The result is NOT null-terminated.

Namespaces

Classes

Typedefs