detail namespace with internal helper functions 更多...

命名空间
namespace	container_input_adapter_factory_impl

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

namespace	impl

namespace	utility_internal

类
struct	actual_object_comparator

class	binary_reader
	deserialization of CBOR, MessagePack, and UBJSON values 更多...

class	binary_writer
	serialization to CBOR and MessagePack values 更多...

struct	char_traits

struct	char_traits< signed char >

struct	char_traits< unsigned char >

struct	conjunction

struct	conjunction< B >

struct	conjunction< B, Bn... >

struct	detector

struct	detector< Default, void_t< Op< Args... > >, Op, Args... >

class	exception
	general exception of the basic_json class 更多...

struct	external_constructor

struct	external_constructor< value_t::array >

struct	external_constructor< value_t::binary >

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 >

class	file_input_adapter

struct	from_json_fn

struct	has_from_json

struct	has_from_json< BasicJsonType, T, enable_if_t< !is_basic_json< T >::value > >

struct	has_key_compare

struct	has_non_default_from_json

struct	has_non_default_from_json< BasicJsonType, T, enable_if_t< !is_basic_json< T >::value > >

struct	has_to_json

struct	has_to_json< BasicJsonType, T, enable_if_t< !is_basic_json< T >::value > >

struct	identity_tag

class	input_stream_adapter

struct	integer_sequence

struct	internal_iterator
	an iterator value 更多...

class	invalid_iterator
	exception indicating errors with iterators 更多...

struct	is_basic_json

struct	is_basic_json< NLOHMANN_BASIC_JSON_TPL >

struct	is_basic_json_context

struct	is_c_string

struct	is_comparable

struct	is_comparable< Compare, A, B, void_t< decltype(std::declval< Compare >()(std::declval< A >(), std::declval< B >())), decltype(std::declval< Compare >()(std::declval< B >(), std::declval< A >()))> >

struct	is_compatible_array_type

struct	is_compatible_array_type_impl

struct	is_compatible_array_type_impl< BasicJsonType, CompatibleArrayType, enable_if_t< is_detected< iterator_t, CompatibleArrayType >::value &&is_iterator_traits< iterator_traits< detected_t< iterator_t, CompatibleArrayType > > >::value &&!std::is_same< CompatibleArrayType, detected_t< range_value_t, CompatibleArrayType > >::value > >

struct	is_compatible_integer_type

struct	is_compatible_integer_type_impl

struct	is_compatible_integer_type_impl< RealIntegerType, CompatibleNumberIntegerType, enable_if_t< std::is_integral< RealIntegerType >::value &&std::is_integral< CompatibleNumberIntegerType >::value &&!std::is_same< bool, CompatibleNumberIntegerType >::value > >

struct	is_compatible_object_type

struct	is_compatible_object_type_impl

struct	is_compatible_object_type_impl< BasicJsonType, CompatibleObjectType, enable_if_t< is_detected< mapped_type_t, CompatibleObjectType >::value &&is_detected< key_type_t, CompatibleObjectType >::value > >

struct	is_compatible_string_type

struct	is_compatible_type

struct	is_compatible_type_impl

struct	is_compatible_type_impl< BasicJsonType, CompatibleType, enable_if_t< is_complete_type< CompatibleType >::value > >

struct	is_complete_type

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

struct	is_constructible

struct	is_constructible< const std::pair< T1, T2 > >

struct	is_constructible< const std::tuple< Ts... > >

struct	is_constructible< std::pair< T1, T2 > >

struct	is_constructible< std::tuple< Ts... > >

struct	is_constructible_array_type

struct	is_constructible_array_type_impl

struct	is_constructible_array_type_impl< BasicJsonType, ConstructibleArrayType, enable_if_t< !std::is_same< ConstructibleArrayType, typename BasicJsonType::value_type >::value &&!is_compatible_string_type< BasicJsonType, ConstructibleArrayType >::value &&is_default_constructible< ConstructibleArrayType >::value &&(std::is_move_assignable< ConstructibleArrayType >::value\|\|std::is_copy_assignable< ConstructibleArrayType >::value)&&is_detected< iterator_t, ConstructibleArrayType >::value &&is_iterator_traits< iterator_traits< detected_t< iterator_t, ConstructibleArrayType > > >::value &&is_detected< range_value_t, ConstructibleArrayType >::value &&!std::is_same< ConstructibleArrayType, detected_t< range_value_t, ConstructibleArrayType > >::value &&is_complete_type< detected_t< range_value_t, ConstructibleArrayType > >::value > >

struct	is_constructible_array_type_impl< BasicJsonType, ConstructibleArrayType, enable_if_t< std::is_same< ConstructibleArrayType, typename BasicJsonType::value_type >::value > >

struct	is_constructible_object_type

struct	is_constructible_object_type_impl

struct	is_constructible_object_type_impl< BasicJsonType, ConstructibleObjectType, enable_if_t< is_detected< mapped_type_t, ConstructibleObjectType >::value &&is_detected< key_type_t, ConstructibleObjectType >::value > >

struct	is_constructible_string_type

struct	is_constructible_tuple

struct	is_constructible_tuple< T1, std::tuple< Args... > >

struct	is_default_constructible

struct	is_default_constructible< const std::pair< T1, T2 > >

struct	is_default_constructible< const std::tuple< Ts... > >

struct	is_default_constructible< std::pair< T1, T2 > >

struct	is_default_constructible< std::tuple< Ts... > >

struct	is_detected_lazy

struct	is_getable

struct	is_iterator_of_multibyte

struct	is_iterator_traits

struct	is_iterator_traits< iterator_traits< T > >

struct	is_json_iterator_of

struct	is_json_iterator_of< BasicJsonType, typename BasicJsonType::const_iterator >

struct	is_json_iterator_of< BasicJsonType, typename BasicJsonType::iterator >

struct	is_json_ref

struct	is_json_ref< json_ref< T > >

struct	is_ordered_map

struct	is_range

struct	is_sax

struct	is_sax_static_asserts

struct	is_specialization_of

struct	is_specialization_of< Primary, Primary< Args... > >

struct	is_transparent

class	iter_impl
	a template for a bidirectional iterator for the basic_json class This class implements a both iterators (iterator and const_iterator) for the basic_json class. 更多...

class	iteration_proxy
	proxy class for the items() function 更多...

class	iteration_proxy_value

class	iterator_input_adapter

struct	iterator_input_adapter_factory

struct	iterator_input_adapter_factory< IteratorType, enable_if_t< is_iterator_of_multibyte< IteratorType >::value > >

struct	iterator_traits

struct	iterator_traits< T *, enable_if_t< std::is_object< T >::value > >

struct	iterator_traits< T, enable_if_t< !std::is_pointer< T >::value > >

struct	iterator_types

struct	iterator_types< It, void_t< typename It::difference_type, typename It::value_type, typename It::pointer, typename It::reference, typename It::iterator_category > >

struct	json_default_base
	Default base class of the basic_json class. 更多...

class	json_ref

class	json_reverse_iterator
	a template for a reverse iterator class 更多...

class	json_sax_acceptor

class	json_sax_dom_callback_parser

class	json_sax_dom_parser
	SAX implementation to create a JSON value from SAX events 更多...

class	lexer
	lexical analysis 更多...

class	lexer_base

struct	make_void

struct	negation

struct	nonesuch

class	other_error
	exception indicating other library errors 更多...

class	out_of_range
	exception indicating access out of the defined range 更多...

class	output_adapter

struct	output_adapter_protocol
	abstract output adapter interface 更多...

class	output_stream_adapter
	output adapter for output streams 更多...

class	output_string_adapter
	output adapter for basic_string 更多...

class	output_vector_adapter
	output adapter for byte vectors 更多...

class	parse_error
	exception indicating a parse error 更多...

class	parser
	syntax analysis 更多...

struct	position_t
	struct to capture the start position of the current token 更多...

class	primitive_iterator_t

struct	priority_tag

struct	priority_tag< 0 >

class	serializer

class	span_input_adapter

struct	static_const

struct	to_json_fn

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

struct	value_in_range_of_impl1

struct	value_in_range_of_impl1< OfType, T, false >

struct	value_in_range_of_impl1< OfType, T, true >

struct	value_in_range_of_impl2

struct	value_in_range_of_impl2< OfType, T, false, false >

struct	value_in_range_of_impl2< OfType, T, false, true >

struct	value_in_range_of_impl2< OfType, T, true, false >

struct	value_in_range_of_impl2< OfType, T, true, true >

class	wide_string_input_adapter

struct	wide_string_input_helper

struct	wide_string_input_helper< BaseInputAdapter, 2 >

struct	wide_string_input_helper< BaseInputAdapter, 4 >

类型定义
template<typename ... Ts>
using	void_t = typename make_void<Ts...>::type

template<template< class... > class Op, class... Args>
using	is_detected = typename detector<nonesuch, void, Op, Args...>::value_t

template<template< class... > class Op, class... Args>
using	detected_t = typename detector<nonesuch, void, Op, Args...>::type

template<class Default , template< class... > class Op, class... Args>
using	detected_or = detector<Default, void, Op, Args...>

template<class Default , template< class... > class Op, class... Args>
using	detected_or_t = typename detected_or<Default, Op, Args...>::type

template<class Expected , template< class... > class Op, class... Args>
using	is_detected_exact = std::is_same<Expected, detected_t<Op, Args...>>

template<class To , template< class... > class Op, class... Args>
using	is_detected_convertible

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

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

template<size_t... Ints>
using	index_sequence = integer_sequence<size_t, Ints...>

template<typename T , T N>
using	make_integer_sequence = typename utility_internal::Gen<T, N>::type

template<size_t N>
using	make_index_sequence = make_integer_sequence<size_t, N>

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

template<typename T >
using	mapped_type_t = typename T::mapped_type

template<typename T >
using	key_type_t = typename T::key_type

template<typename T >
using	value_type_t = typename T::value_type

template<typename T >
using	difference_type_t = typename T::difference_type

template<typename T >
using	pointer_t = typename T::pointer

template<typename T >
using	reference_t = typename T::reference

template<typename T >
using	iterator_category_t = typename T::iterator_category

template<typename T , typename... Args>
using	to_json_function = decltype(T::to_json(std::declval<Args>()...))

template<typename T , typename... Args>
using	from_json_function = decltype(T::from_json(std::declval<Args>()...))

template<typename T , typename U >
using	get_template_function = decltype(std::declval<T>().template get<U>())

template<typename T >
using	detect_key_compare = typename T::key_compare

template<typename BasicJsonType >
using	actual_object_comparator_t = typename actual_object_comparator<BasicJsonType>::type

template<typename R >
using	iterator_t = enable_if_t<is_range<R>::value, result_of_begin<decltype(std::declval<R&>())>>

template<typename T >
using	range_value_t = value_type_t<iterator_traits<iterator_t<T>>>

template<typename T >
using	is_json_pointer = is_specialization_of<::nlohmann::json_pointer, uncvref_t<T>>

template<typename T >
using	detect_is_transparent = typename T::is_transparent

template<typename Comparator , typename ObjectKeyType , typename KeyTypeCVRef , bool RequireTransparentComparator = true, bool ExcludeObjectKeyType = RequireTransparentComparator, typename KeyType = uncvref_t<KeyTypeCVRef>>
using	is_usable_as_key_type

template<typename BasicJsonType , typename KeyTypeCVRef , bool RequireTransparentComparator = true, bool ExcludeObjectKeyType = RequireTransparentComparator, typename KeyType = uncvref_t<KeyTypeCVRef>>
using	is_usable_as_basic_json_key_type

template<typename ObjectType , typename KeyType >
using	detect_erase_with_key_type = decltype(std::declval<ObjectType&>().erase(std::declval<KeyType>()))

template<typename BasicJsonType , typename KeyType >
using	has_erase_with_key_type

template<typename... Types>
using	all_integral = conjunction<std::is_integral<Types>...>

template<typename... Types>
using	all_signed = conjunction<std::is_signed<Types>...>

template<typename... Types>
using	all_unsigned = conjunction<std::is_unsigned<Types>...>

template<typename... Types>
using	same_sign

template<typename OfType , typename T >
using	never_out_of_range

template<bool Value>
using	bool_constant = std::integral_constant<bool, Value>

template<typename T >
using	is_c_string_uncvref = is_c_string<uncvref_t<T>>

template<typename StringType , typename Arg >
using	string_can_append = decltype(std::declval<StringType&>().append(std::declval < Arg && > ()))

template<typename StringType , typename Arg >
using	detect_string_can_append = is_detected<string_can_append, StringType, Arg>

template<typename StringType , typename Arg >
using	string_can_append_op = decltype(std::declval<StringType&>() += std::declval < Arg && > ())

template<typename StringType , typename Arg >
using	detect_string_can_append_op = is_detected<string_can_append_op, StringType, Arg>

template<typename StringType , typename Arg >
using	string_can_append_iter = decltype(std::declval<StringType&>().append(std::declval<const Arg&>().begin(), std::declval<const Arg&>().end()))

template<typename StringType , typename Arg >
using	detect_string_can_append_iter = is_detected<string_can_append_iter, StringType, Arg>

template<typename StringType , typename Arg >
using	string_can_append_data = decltype(std::declval<StringType&>().append(std::declval<const Arg&>().data(), std::declval<const Arg&>().size()))

template<typename StringType , typename Arg >
using	detect_string_can_append_data = is_detected<string_can_append_data, StringType, Arg>

using	contiguous_bytes_input_adapter = decltype(input_adapter(std::declval<const char>(), std::declval<const char>()))

template<typename T >
using	null_function_t = decltype(std::declval<T&>().null())

template<typename T >
using	boolean_function_t

template<typename T , typename Integer >
using	number_integer_function_t

template<typename T , typename Unsigned >
using	number_unsigned_function_t

template<typename T , typename Float , typename String >
using	number_float_function_t

template<typename T , typename String >
using	string_function_t

template<typename T , typename Binary >
using	binary_function_t

template<typename T >
using	start_object_function_t

template<typename T , typename String >
using	key_function_t

template<typename T >
using	end_object_function_t = decltype(std::declval<T&>().end_object())

template<typename T >
using	start_array_function_t

template<typename T >
using	end_array_function_t = decltype(std::declval<T&>().end_array())

template<typename T , typename Exception >
using	parse_error_function_t

template<typename BasicJsonType >
using	parser_callback_t

template<class T >
using	json_base_class

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

枚举
enum class	value_t : std::uint8_t { null , object , array , string , boolean , number_integer , number_unsigned , number_float , binary , discarded }
	the JSON type enumeration 更多...

enum class	input_format_t { json , cbor , msgpack , ubjson , bson , bjdata }
	the supported input formats 更多...

enum class	cbor_tag_handler_t { error , ignore , store }
	how to treat CBOR tags 更多...

enum class	parse_event_t : std::uint8_t { object_start , object_end , array_start , array_end , key , value }

enum class	error_handler_t { strict , replace , ignore }
	how to treat decoding errors 更多...

函数
bool	operator< (const value_t lhs, const value_t rhs) noexcept
	comparison operator for JSON types

template<typename StringType >
void	replace_substring (StringType &s, const StringType &f, const StringType &t)
	replace all occurrences of a substring by another string

template<typename StringType >
StringType	escape (StringType s)
	string escaping as described in RFC 6901 (Sect. 4)

template<typename StringType >
static void	unescape (StringType &s)
	string unescaping as described in RFC 6901 (Sect. 4)

template<typename T , typename... Args>
constexpr std::array< T, sizeof...(Args)>	make_array (Args &&... args)

template<typename T , typename U , enable_if_t< !std::is_same< T, U >::value, int > = 0>
T	conditional_static_cast (U value)

template<typename OfType , typename T >
constexpr bool	value_in_range_of (T val)

std::size_t	concat_length ()

template<typename... Args>
std::size_t	concat_length (const char *cstr, const Args &... rest)

template<typename StringType , typename... Args>
std::size_t	concat_length (const StringType &str, const Args &... rest)

template<typename... Args>
std::size_t	concat_length (const char, const Args &... rest)

template<typename OutStringType >
void	concat_into (OutStringType &)

template<typename OutStringType , typename Arg , typename... Args, enable_if_t< !detect_string_can_append< OutStringType, Arg >::value &&detect_string_can_append_op< OutStringType, Arg >::value, int > = 0>
void	concat_into (OutStringType &out, Arg &&arg, Args &&... rest)

template<typename OutStringType , typename Arg , typename... Args, enable_if_t< !detect_string_can_append< OutStringType, Arg >::value &&!detect_string_can_append_op< OutStringType, Arg >::value &&detect_string_can_append_iter< OutStringType, Arg >::value, int > = 0>
void	concat_into (OutStringType &out, const Arg &arg, Args &&... rest)

template<typename OutStringType = std::string, typename... Args>
OutStringType	concat (Args &&... args)

template<typename BasicJsonType >
void	from_json (const BasicJsonType &j, typename std::nullptr_t &n)

template<typename BasicJsonType , typename ArithmeticType , enable_if_t< std::is_arithmetic< ArithmeticType >::value &&!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 , typename StringType , enable_if_t< std::is_assignable< StringType &, const typename BasicJsonType::string_t >::value &&is_detected_exact< typename BasicJsonType::string_t::value_type, value_type_t, StringType >::value &&!std::is_same< typename BasicJsonType::string_t, StringType >::value &&!is_json_ref< StringType >::value, int > = 0>
void	from_json (const BasicJsonType &j, StringType &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 , typename T , typename Allocator , enable_if_t< is_getable< 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< is_getable< BasicJsonType, T >::value, int > = 0>
void	from_json (const BasicJsonType &j, std::valarray< T > &l)

template<typename BasicJsonType , typename T , std::size_t N>
auto	from_json (const BasicJsonType &j, T(&arr)[N]) -> decltype(j.template get< T >(), void())

template<typename BasicJsonType >
void	from_json_array_impl (const BasicJsonType &j, typename BasicJsonType::array_t &arr, priority_tag< 3 >)

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

template<typename BasicJsonType , typename ConstructibleArrayType , enable_if_t< std::is_assignable< ConstructibleArrayType &, ConstructibleArrayType >::value, int > = 0>
auto	from_json_array_impl (const BasicJsonType &j, ConstructibleArrayType &arr, priority_tag< 1 >) -> decltype(arr.reserve(std::declval< typename ConstructibleArrayType::size_type >()), j.template get< typename ConstructibleArrayType::value_type >(), void())

template<typename BasicJsonType , typename ConstructibleArrayType , enable_if_t< std::is_assignable< ConstructibleArrayType &, ConstructibleArrayType >::value, int > = 0>
void	from_json_array_impl (const BasicJsonType &j, ConstructibleArrayType &arr, priority_tag< 0 >)

template<typename BasicJsonType , typename ConstructibleArrayType , enable_if_t< is_constructible_array_type< BasicJsonType, ConstructibleArrayType >::value &&!is_constructible_object_type< BasicJsonType, ConstructibleArrayType >::value &&!is_constructible_string_type< BasicJsonType, ConstructibleArrayType >::value &&!std::is_same< ConstructibleArrayType, typename BasicJsonType::binary_t >::value &&!is_basic_json< ConstructibleArrayType >::value, int > = 0>
auto	from_json (const BasicJsonType &j, ConstructibleArrayType &arr) -> decltype(from_json_array_impl(j, arr, priority_tag< 3 > {}), j.template get< typename ConstructibleArrayType::value_type >(), void())

template<typename BasicJsonType , typename T , std::size_t... Idx>
std::array< T, sizeof...(Idx)>	from_json_inplace_array_impl (BasicJsonType &&j, identity_tag< std::array< T, sizeof...(Idx)> >, index_sequence< Idx... >)

template<typename BasicJsonType , typename T , std::size_t N>
auto	from_json (BasicJsonType &&j, identity_tag< std::array< T, N > > tag) -> decltype(from_json_inplace_array_impl(std::forward< BasicJsonType >(j), tag, make_index_sequence< N > {}))

template<typename BasicJsonType >
void	from_json (const BasicJsonType &j, typename BasicJsonType::binary_t &bin)

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

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

template<typename BasicJsonType , typename... Args, std::size_t... Idx>
std::tuple< Args... >	from_json_tuple_impl_base (BasicJsonType &&j, index_sequence< Idx... >)

template<typename BasicJsonType , class A1 , class A2 >
std::pair< A1, A2 >	from_json_tuple_impl (BasicJsonType &&j, identity_tag< std::pair< A1, A2 > >, priority_tag< 0 >)

template<typename BasicJsonType , typename A1 , typename A2 >
void	from_json_tuple_impl (BasicJsonType &&j, std::pair< A1, A2 > &p, priority_tag< 1 >)

template<typename BasicJsonType , typename... Args>
std::tuple< Args... >	from_json_tuple_impl (BasicJsonType &&j, identity_tag< std::tuple< Args... > >, priority_tag< 2 >)

template<typename BasicJsonType , typename... Args>
void	from_json_tuple_impl (BasicJsonType &&j, std::tuple< Args... > &t, priority_tag< 3 >)

template<typename BasicJsonType , typename TupleRelated >
auto	from_json (BasicJsonType &&j, TupleRelated &&t) -> decltype(from_json_tuple_impl(std::forward< BasicJsonType >(j), std::forward< TupleRelated >(t), priority_tag< 3 > {}))

template<typename BasicJsonType , typename Key , typename Value , typename Compare , typename Allocator , typename = enable_if_t < !std::is_constructible < typename BasicJsonType::string_t, Key >::value >>
void	from_json (const BasicJsonType &j, std::map< Key, Value, Compare, Allocator > &m)

template<typename BasicJsonType , typename Key , typename Value , typename Hash , typename KeyEqual , typename Allocator , typename = enable_if_t < !std::is_constructible < typename BasicJsonType::string_t, Key >::value >>
void	from_json (const BasicJsonType &j, std::unordered_map< Key, Value, Hash, KeyEqual, Allocator > &m)

template<typename string_type >
void	int_to_string (string_type &target, std::size_t value)

template<std::size_t N, typename IteratorType , enable_if_t< N==0, int > = 0>
auto	get (const nlohmann::detail::iteration_proxy_value< IteratorType > &i) -> decltype(i.key())

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 BoolRef , enable_if_t<((std::is_same< std::vector< bool >::reference, BoolRef >::value &&!std::is_same< std::vector< bool >::reference, typename BasicJsonType::boolean_t & >::value)\|\|(std::is_same< std::vector< bool >::const_reference, BoolRef >::value &&!std::is_same< detail::uncvref_t< std::vector< bool >::const_reference >, typename BasicJsonType::boolean_t >::value)) &&std::is_convertible< const BoolRef &, typename BasicJsonType::boolean_t >::value, int > = 0>
void	to_json (BasicJsonType &j, const BoolRef &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 &&!is_compatible_object_type< BasicJsonType, CompatibleArrayType >::value &&!is_compatible_string_type< BasicJsonType, CompatibleArrayType >::value &&!std::is_same< typename BasicJsonType::binary_t, CompatibleArrayType >::value &&!is_basic_json< CompatibleArrayType >::value, int > = 0>
void	to_json (BasicJsonType &j, const CompatibleArrayType &arr)

template<typename BasicJsonType >
void	to_json (BasicJsonType &j, const typename BasicJsonType::binary_t &bin)

template<typename BasicJsonType , typename T , enable_if_t< std::is_convertible< T, BasicJsonType >::value, int > = 0>
void	to_json (BasicJsonType &j, const 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 &&!is_basic_json< 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< !std::is_constructible< typename BasicJsonType::string_t, const T(&)[N]>::value, int > = 0>
void	to_json (BasicJsonType &j, const T(&arr)[N])

template<typename BasicJsonType , typename T1 , typename T2 , enable_if_t< std::is_constructible< BasicJsonType, T1 >::value &&std::is_constructible< BasicJsonType, T2 >::value, int > = 0>
void	to_json (BasicJsonType &j, const std::pair< T1, T2 > &p)

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

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

std::size_t	combine (std::size_t seed, std::size_t h) noexcept

template<typename BasicJsonType >
std::size_t	hash (const BasicJsonType &j)
	hash a JSON value

template<typename IteratorType >
iterator_input_adapter_factory< IteratorType >::adapter_type	input_adapter (IteratorType first, IteratorType last)

template<typename ContainerType >
container_input_adapter_factory_impl::container_input_adapter_factory< ContainerType >::adapter_type	input_adapter (const ContainerType &container)

file_input_adapter	input_adapter (std::FILE *file)

input_stream_adapter	input_adapter (std::istream &stream)

input_stream_adapter	input_adapter (std::istream &&stream)

template<typename CharT , typename std::enable_if< std::is_pointer< CharT >::value &&!std::is_array< CharT >::value &&std::is_integral< typename std::remove_pointer< CharT >::type >::value &&sizeof(typename std::remove_pointer< CharT >::type)==1, int >::type = 0>
contiguous_bytes_input_adapter	input_adapter (CharT b)

template<typename T , std::size_t N>
auto	input_adapter (T(&array)[N]) -> decltype(input_adapter(array, array+N))

static bool	little_endianness (int num=1) noexcept
	determine system byte order

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

详细描述

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.

自从: version 2.1.0

类型定义说明

◆ actual_object_comparator_t

template<typename BasicJsonType >

using detail::actual_object_comparator_t = typename actual_object_comparator<BasicJsonType>::type

◆ all_integral

template<typename... Types>

using detail::all_integral = conjunction<std::is_integral<Types>...>

◆ all_signed

template<typename... Types>

using detail::all_signed = conjunction<std::is_signed<Types>...>

◆ all_unsigned

template<typename... Types>

using detail::all_unsigned = conjunction<std::is_unsigned<Types>...>

◆ binary_function_t

template<typename T , typename Binary >

using detail::binary_function_t

初始值:

decltype(std::declval<T&>().binary(std::declval<Binary&>()))

◆ bool_constant

template<bool Value>

using detail::bool_constant = std::integral_constant<bool, Value>

◆ boolean_function_t

template<typename T >

using detail::boolean_function_t

初始值:

decltype(std::declval<T&>().boolean(std::declval<bool>()))

◆ contiguous_bytes_input_adapter

using detail::contiguous_bytes_input_adapter = decltype(input_adapter(std::declval<const char*>(), std::declval<const char*>()))

◆ detect_erase_with_key_type

template<typename ObjectType , typename KeyType >

using detail::detect_erase_with_key_type = decltype(std::declval<ObjectType&>().erase(std::declval<KeyType>()))

◆ detect_is_transparent

template<typename T >

using detail::detect_is_transparent = typename T::is_transparent

◆ detect_key_compare

template<typename T >

using detail::detect_key_compare = typename T::key_compare

◆ detect_string_can_append

template<typename StringType , typename Arg >

using detail::detect_string_can_append = is_detected<string_can_append, StringType, Arg>

◆ detect_string_can_append_data

template<typename StringType , typename Arg >

using detail::detect_string_can_append_data = is_detected<string_can_append_data, StringType, Arg>

◆ detect_string_can_append_iter

template<typename StringType , typename Arg >

using detail::detect_string_can_append_iter = is_detected<string_can_append_iter, StringType, Arg>

◆ detect_string_can_append_op

template<typename StringType , typename Arg >

using detail::detect_string_can_append_op = is_detected<string_can_append_op, StringType, Arg>

◆ detected_or

template<class Default , template< class... > class Op, class... Args>

using detail::detected_or = detector<Default, void, Op, Args...>

◆ detected_or_t

template<class Default , template< class... > class Op, class... Args>

using detail::detected_or_t = typename detected_or<Default, Op, Args...>::type

◆ detected_t

template<template< class... > class Op, class... Args>

using detail::detected_t = typename detector<nonesuch, void, Op, Args...>::type

◆ difference_type_t

template<typename T >

using detail::difference_type_t = typename T::difference_type

◆ enable_if_t

template<bool B, typename T = void>

using detail::enable_if_t = typename std::enable_if<B, T>::type

◆ end_array_function_t

template<typename T >

using detail::end_array_function_t = decltype(std::declval<T&>().end_array())

◆ end_object_function_t

template<typename T >

using detail::end_object_function_t = decltype(std::declval<T&>().end_object())

◆ from_json_function

template<typename T , typename... Args>

using detail::from_json_function = decltype(T::from_json(std::declval<Args>()...))

◆ get_template_function

template<typename T , typename U >

using detail::get_template_function = decltype(std::declval<T>().template get<U>())

◆ has_erase_with_key_type

template<typename BasicJsonType , typename KeyType >

using detail::has_erase_with_key_type

初始值:

 typename std::conditional <
                                is_detected <
                                detect_erase_with_key_type,
                                typename BasicJsonType::object_t, KeyType >::value,
                                std::true_type,
                                std::false_type >::type

◆ index_sequence

template<size_t... Ints>

using detail::index_sequence = integer_sequence<size_t, Ints...>

◆ index_sequence_for

template<typename... Ts>

using detail::index_sequence_for = make_index_sequence<sizeof...(Ts)>

◆ is_c_string_uncvref

template<typename T >

using detail::is_c_string_uncvref = is_c_string<uncvref_t<T>>

◆ is_detected

template<template< class... > class Op, class... Args>

using detail::is_detected = typename detector<nonesuch, void, Op, Args...>::value_t

◆ is_detected_convertible

template<class To , template< class... > class Op, class... Args>

using detail::is_detected_convertible

初始值:

std::is_convertible<detected_t<Op, Args...>, To>

detail::detected_t

typename detector< nonesuch, void, Op, Args... >::type detected_t

Definition json.hpp:300

◆ is_detected_exact

template<class Expected , template< class... > class Op, class... Args>

using detail::is_detected_exact = std::is_same<Expected, detected_t<Op, Args...>>

◆ is_json_pointer

template<typename T >

using detail::is_json_pointer = is_specialization_of<::nlohmann::json_pointer, uncvref_t<T>>

◆ is_usable_as_basic_json_key_type

template<typename BasicJsonType , typename KeyTypeCVRef , bool RequireTransparentComparator = true, bool ExcludeObjectKeyType = RequireTransparentComparator, typename KeyType = uncvref_t<KeyTypeCVRef>>

using detail::is_usable_as_basic_json_key_type

初始值:

 typename std::conditional <
        is_usable_as_key_type<typename BasicJsonType::object_comparator_t,
        typename BasicJsonType::object_t::key_type, KeyTypeCVRef,
        RequireTransparentComparator, ExcludeObjectKeyType>::value
        && !is_json_iterator_of<BasicJsonType, KeyType>::value,
        std::true_type,
        std::false_type >::type

◆ is_usable_as_key_type

template<typename Comparator , typename ObjectKeyType , typename KeyTypeCVRef , bool RequireTransparentComparator = true, bool ExcludeObjectKeyType = RequireTransparentComparator, typename KeyType = uncvref_t<KeyTypeCVRef>>

using detail::is_usable_as_key_type

初始值:

 typename std::conditional <
                              is_comparable<Comparator, ObjectKeyType, KeyTypeCVRef>::value
                              && !(ExcludeObjectKeyType && std::is_same<KeyType,
                                   ObjectKeyType>::value)
                              && (!RequireTransparentComparator
                                  || is_detected <detect_is_transparent, Comparator>::value)
                              && !is_json_pointer<KeyType>::value,
                              std::true_type,
                              std::false_type >::type

◆ iterator_category_t

template<typename T >

using detail::iterator_category_t = typename T::iterator_category

◆ iterator_t

template<typename R >

using detail::iterator_t = enable_if_t<is_range<R>::value, result_of_begin<decltype(std::declval<R&>())>>

◆ json_base_class

template<class T >

using detail::json_base_class

初始值:

 typename std::conditional <
                        std::is_same<T, void>::value,
                        json_default_base,
                        T
                        >::type

◆ key_function_t

template<typename T , typename String >

using detail::key_function_t

初始值:

decltype(std::declval<T&>().key(std::declval<String&>()))

◆ key_type_t

template<typename T >

using detail::key_type_t = typename T::key_type

◆ make_index_sequence

template<size_t N>

using detail::make_index_sequence = make_integer_sequence<size_t, N>

◆ make_integer_sequence

template<typename T , T N>

using detail::make_integer_sequence = typename utility_internal::Gen<T, N>::type

◆ mapped_type_t

template<typename T >

using detail::mapped_type_t = typename T::mapped_type

◆ never_out_of_range

template<typename OfType , typename T >

using detail::never_out_of_range

初始值:

 std::integral_constant < bool,
      (std::is_signed<OfType>::value && (sizeof(T) < sizeof(OfType)))
      || (same_sign<OfType, T>::value && sizeof(OfType) == sizeof(T)) >

◆ null_function_t

template<typename T >

using detail::null_function_t = decltype(std::declval<T&>().null())

◆ number_float_function_t

template<typename T , typename Float , typename String >

using detail::number_float_function_t

初始值:

decltype(std::declval<T&>().number_float(

std::declval<Float>(), std::declval<const String&>()))

◆ number_integer_function_t

template<typename T , typename Integer >

using detail::number_integer_function_t

初始值:

decltype(std::declval<T&>().number_integer(std::declval<Integer>()))

◆ number_unsigned_function_t

template<typename T , typename Unsigned >

using detail::number_unsigned_function_t

初始值:

decltype(std::declval<T&>().number_unsigned(std::declval<Unsigned>()))

◆ output_adapter_t

template<typename CharType >

using detail::output_adapter_t = std::shared_ptr<output_adapter_protocol<CharType>>

a type to simplify interfaces

◆ parse_error_function_t

template<typename T , typename Exception >

using detail::parse_error_function_t

初始值:

 decltype(std::declval<T&>().parse_error(
        std::declval<std::size_t>(), std::declval<const std::string&>(),
        std::declval<const Exception&>()))

◆ parser_callback_t

template<typename BasicJsonType >

using detail::parser_callback_t

初始值:

std::function<bool(int , parse_event_t , BasicJsonType& )>

◆ pointer_t

template<typename T >

using detail::pointer_t = typename T::pointer

◆ range_value_t

template<typename T >

using detail::range_value_t = value_type_t<iterator_traits<iterator_t<T>>>

◆ reference_t

template<typename T >

using detail::reference_t = typename T::reference

◆ same_sign

template<typename... Types>

using detail::same_sign

初始值:

std::integral_constant < bool,

all_signed<Types...>::value || all_unsigned<Types...>::value >

detail::all_unsigned

conjunction< std::is_unsigned< Types >... > all_unsigned

Definition json.hpp:4068

detail::all_signed

conjunction< std::is_signed< Types >... > all_signed

Definition json.hpp:4065

◆ start_array_function_t

template<typename T >

using detail::start_array_function_t

初始值:

decltype(std::declval<T&>().start_array(std::declval<std::size_t>()))

◆ start_object_function_t

template<typename T >

using detail::start_object_function_t

初始值:

decltype(std::declval<T&>().start_object(std::declval<std::size_t>()))

◆ string_can_append

template<typename StringType , typename Arg >

using detail::string_can_append = decltype(std::declval<StringType&>().append(std::declval < Arg && > ()))

◆ string_can_append_data

template<typename StringType , typename Arg >

using detail::string_can_append_data = decltype(std::declval<StringType&>().append(std::declval<const Arg&>().data(), std::declval<const Arg&>().size()))

◆ string_can_append_iter

template<typename StringType , typename Arg >

using detail::string_can_append_iter = decltype(std::declval<StringType&>().append(std::declval<const Arg&>().begin(), std::declval<const Arg&>().end()))

◆ string_can_append_op

template<typename StringType , typename Arg >

using detail::string_can_append_op = decltype(std::declval<StringType&>() += std::declval < Arg && > ())

◆ string_function_t

template<typename T , typename String >

using detail::string_function_t

初始值:

decltype(std::declval<T&>().string(std::declval<String&>()))

◆ to_json_function

template<typename T , typename... Args>

using detail::to_json_function = decltype(T::to_json(std::declval<Args>()...))

◆ uncvref_t

template<typename T >

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

◆ value_type_t

template<typename T >

using detail::value_type_t = typename T::value_type

◆ void_t

template<typename ... Ts>

using detail::void_t = typename make_void<Ts...>::type

枚举类型说明

◆ cbor_tag_handler_t

enum class detail::cbor_tag_handler_t

strong

how to treat CBOR tags

枚举值
error	throw a parse_error exception in case of a tag
ignore	ignore tags
store	store tags as binary type

◆ error_handler_t

enum class detail::error_handler_t

strong

how to treat decoding errors

枚举值
strict	throw a type_error exception in case of invalid UTF-8
replace	replace invalid UTF-8 sequences with U+FFFD
ignore	ignore invalid UTF-8 sequences

◆ input_format_t

enum class detail::input_format_t

strong

the supported input formats

枚举值
json
cbor
msgpack
ubjson
bson
bjdata

◆ parse_event_t

enum class detail::parse_event_t : std::uint8_t

strong

枚举值
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

◆ value_t

enum class 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.

注解: 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 basic_json::basic_json(const value_t value_type) – create a JSON value with the default value for a given type

自从: version 1.0.0

枚举值
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)
binary	binary array (ordered collection of bytes)
discarded	discarded by the parser callback function

函数说明

◆ combine()

std::size_t detail::combine	(	std::size_t	seed,
		std::size_t	h )

inlinenoexcept

这是这个函数的调用关系图:

◆ concat()

template<typename OutStringType = std::string, typename... Args>

OutStringType detail::concat ( Args &&... args )

inline

函数调用图:

◆ concat_into() [1/3]

template<typename OutStringType >

void detail::concat_into ( OutStringType & )

inline

这是这个函数的调用关系图:

◆ concat_into() [2/3]

template<typename OutStringType , typename Arg , typename... Args, enable_if_t< !detect_string_can_append< OutStringType, Arg >::value &&detect_string_can_append_op< OutStringType, Arg >::value, int > = 0>

void detail::concat_into	(	OutStringType &	out,
		Arg &&	arg,
		Args &&...	rest )

inline

函数调用图:

◆ concat_into() [3/3]

template<typename OutStringType , typename Arg , typename... Args, enable_if_t< !detect_string_can_append< OutStringType, Arg >::value &&!detect_string_can_append_op< OutStringType, Arg >::value &&detect_string_can_append_iter< OutStringType, Arg >::value, int > = 0>

void detail::concat_into	(	OutStringType &	out,
		const Arg &	arg,
		Args &&...	rest )

inline

函数调用图:

◆ concat_length() [1/4]

std::size_t detail::concat_length ( )

inline

这是这个函数的调用关系图:

◆ concat_length() [2/4]

template<typename... Args>

std::size_t detail::concat_length	(	const char *	cstr,
		const Args &...	rest )

inline

函数调用图:

◆ concat_length() [3/4]

template<typename... Args>

std::size_t detail::concat_length	(	const char	,
		const Args &...	rest )

inline

函数调用图:

◆ concat_length() [4/4]

template<typename StringType , typename... Args>

std::size_t detail::concat_length	(	const StringType &	str,
		const Args &...	rest )

inline

函数调用图:

◆ conditional_static_cast()

template<typename T , typename U , enable_if_t< !std::is_same< T, U >::value, int > = 0>

T detail::conditional_static_cast ( U value )

◆ escape()

template<typename StringType >

StringType detail::escape ( StringType s )

inline

string escaping as described in RFC 6901 (Sect. 4)

参数

[in] s string to escape

返回: escaped string

Note the order of escaping "~" to "~0" and "/" to "~1" is important.

函数调用图:

这是这个函数的调用关系图:

◆ from_json() [1/19]

template<typename BasicJsonType , typename T , std::size_t N>

auto detail::from_json	(	BasicJsonType &&	j,
		identity_tag< std::array< T, N > >	tag ) -> decltype(from_json_inplace_array_impl(std::forward<BasicJsonType>(j), tag, make_index_sequence<N> {}))

◆ from_json() [2/19]

template<typename BasicJsonType , typename TupleRelated >

auto detail::from_json	(	BasicJsonType &&	j,
		TupleRelated &&	t ) -> decltype(from_json_tuple_impl(std::forward<BasicJsonType>(j), std::forward<TupleRelated>(t), priority_tag<3> {}))

◆ from_json() [3/19]

template<typename BasicJsonType , typename ArithmeticType , enable_if_t< std::is_arithmetic< ArithmeticType >::value &&!std::is_same< ArithmeticType, typename BasicJsonType::number_unsigned_t >::value &&!std::is_same< ArithmeticType, typename BasicJsonType::number_integer_t >::value &&!std::is_same< ArithmeticType, typename BasicJsonType::number_float_t >::value &&!std::is_same< ArithmeticType, typename BasicJsonType::boolean_t >::value, int > = 0>

void detail::from_json	(	const BasicJsonType &	j,
		ArithmeticType &	val )

inline

函数调用图:

◆ from_json() [4/19]

template<typename BasicJsonType , typename ConstructibleArrayType , enable_if_t< is_constructible_array_type< BasicJsonType, ConstructibleArrayType >::value &&!is_constructible_object_type< BasicJsonType, ConstructibleArrayType >::value &&!is_constructible_string_type< BasicJsonType, ConstructibleArrayType >::value &&!std::is_same< ConstructibleArrayType, typename BasicJsonType::binary_t >::value &&!is_basic_json< ConstructibleArrayType >::value, int > = 0>

auto detail::from_json	(	const BasicJsonType &	j,
		ConstructibleArrayType &	arr ) -> decltype(from_json_array_impl(j, arr, priority_tag<3> {}), j.template get<typename ConstructibleArrayType::value_type>(), void())

◆ from_json() [5/19]

template<typename BasicJsonType , typename ConstructibleObjectType , enable_if_t< is_constructible_object_type< BasicJsonType, ConstructibleObjectType >::value, int > = 0>

void detail::from_json	(	const BasicJsonType &	j,
		ConstructibleObjectType &	obj )

inline

函数调用图:

◆ from_json() [6/19]

template<typename BasicJsonType , typename EnumType , enable_if_t< std::is_enum< EnumType >::value, int > = 0>

void detail::from_json	(	const BasicJsonType &	j,
		EnumType &	e )

inline

函数调用图:

◆ from_json() [7/19]

template<typename BasicJsonType , typename T , typename Allocator , enable_if_t< is_getable< BasicJsonType, T >::value, int > = 0>

void detail::from_json	(	const BasicJsonType &	j,
		std::forward_list< T, Allocator > &	l )

inline

函数调用图:

◆ from_json() [8/19]

template<typename BasicJsonType , typename Key , typename Value , typename Compare , typename Allocator , typename = enable_if_t < !std::is_constructible < typename BasicJsonType::string_t, Key >::value >>

void detail::from_json	(	const BasicJsonType &	j,
		std::map< Key, Value, Compare, Allocator > &	m )

inline

函数调用图:

◆ from_json() [9/19]

template<typename BasicJsonType , typename Key , typename Value , typename Hash , typename KeyEqual , typename Allocator , typename = enable_if_t < !std::is_constructible < typename BasicJsonType::string_t, Key >::value >>

void detail::from_json	(	const BasicJsonType &	j,
		std::unordered_map< Key, Value, Hash, KeyEqual, Allocator > &	m )

inline

函数调用图:

◆ from_json() [10/19]

template<typename BasicJsonType , typename T , enable_if_t< is_getable< BasicJsonType, T >::value, int > = 0>

void detail::from_json	(	const BasicJsonType &	j,
		std::valarray< T > &	l )

inline

函数调用图:

◆ from_json() [11/19]

template<typename BasicJsonType , typename StringType , enable_if_t< std::is_assignable< StringType &, const typename BasicJsonType::string_t >::value &&is_detected_exact< typename BasicJsonType::string_t::value_type, value_type_t, StringType >::value &&!std::is_same< typename BasicJsonType::string_t, StringType >::value &&!is_json_ref< StringType >::value, int > = 0>

void detail::from_json	(	const BasicJsonType &	j,
		StringType &	s )

inline

函数调用图:

◆ from_json() [12/19]

template<typename BasicJsonType , typename T , std::size_t N>

auto detail::from_json	(	const BasicJsonType &	j,
		T(&)	arr[N] ) -> decltype(j.template get<T>(), void())

◆ from_json() [13/19]

template<typename BasicJsonType >

void detail::from_json	(	const BasicJsonType &	j,
		typename BasicJsonType::binary_t &	bin )

inline

函数调用图:

◆ from_json() [14/19]

template<typename BasicJsonType >

void detail::from_json	(	const BasicJsonType &	j,
		typename BasicJsonType::boolean_t &	b )

inline

函数调用图:

◆ from_json() [15/19]

template<typename BasicJsonType >

void detail::from_json	(	const BasicJsonType &	j,
		typename BasicJsonType::number_float_t &	val )

inline

函数调用图:

◆ from_json() [16/19]

template<typename BasicJsonType >

void detail::from_json	(	const BasicJsonType &	j,
		typename BasicJsonType::number_integer_t &	val )

inline

函数调用图:

◆ from_json() [17/19]

template<typename BasicJsonType >

void detail::from_json	(	const BasicJsonType &	j,
		typename BasicJsonType::number_unsigned_t &	val )

inline

函数调用图:

◆ from_json() [18/19]

template<typename BasicJsonType >

void detail::from_json	(	const BasicJsonType &	j,
		typename BasicJsonType::string_t &	s )

inline

函数调用图:

◆ from_json() [19/19]

template<typename BasicJsonType >

void detail::from_json	(	const BasicJsonType &	j,
		typename std::nullptr_t &	n )

inline

函数调用图:

这是这个函数的调用关系图:

◆ from_json_array_impl() [1/4]

template<typename BasicJsonType , typename ConstructibleArrayType , enable_if_t< std::is_assignable< ConstructibleArrayType &, ConstructibleArrayType >::value, int > = 0>

void detail::from_json_array_impl	(	const BasicJsonType &	j,
		ConstructibleArrayType &	arr,
		priority_tag< 0 >	)

inline

◆ from_json_array_impl() [2/4]

template<typename BasicJsonType , typename ConstructibleArrayType , enable_if_t< std::is_assignable< ConstructibleArrayType &, ConstructibleArrayType >::value, int > = 0>

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

◆ from_json_array_impl() [3/4]

template<typename BasicJsonType , typename T , std::size_t N>

auto detail::from_json_array_impl	(	const BasicJsonType &	j,
		std::array< T, N > &	arr,
		priority_tag< 2 >	) -> decltype(j.template get<T>(), void())

◆ from_json_array_impl() [4/4]

template<typename BasicJsonType >

void detail::from_json_array_impl	(	const BasicJsonType &	j,
		typename BasicJsonType::array_t &	arr,
		priority_tag< 3 >	)

inline

◆ from_json_inplace_array_impl()

template<typename BasicJsonType , typename T , std::size_t... Idx>

std::array< T, sizeof...(Idx)> detail::from_json_inplace_array_impl	(	BasicJsonType &&	j,
		identity_tag< std::array< T, sizeof...(Idx)> >	,
		index_sequence< Idx... >	)

◆ from_json_tuple_impl() [1/4]

template<typename BasicJsonType , class A1 , class A2 >

std::pair< A1, A2 > detail::from_json_tuple_impl	(	BasicJsonType &&	j,
		identity_tag< std::pair< A1, A2 > >	,
		priority_tag< 0 >	)

这是这个函数的调用关系图:

◆ from_json_tuple_impl() [2/4]

template<typename BasicJsonType , typename... Args>

std::tuple< Args... > detail::from_json_tuple_impl	(	BasicJsonType &&	j,
		identity_tag< std::tuple< Args... > >	,
		priority_tag< 2 >	)

函数调用图:

◆ from_json_tuple_impl() [3/4]

template<typename BasicJsonType , typename A1 , typename A2 >

void detail::from_json_tuple_impl	(	BasicJsonType &&	j,
		std::pair< A1, A2 > &	p,
		priority_tag< 1 >	)

inline

函数调用图:

◆ from_json_tuple_impl() [4/4]

template<typename BasicJsonType , typename... Args>

void detail::from_json_tuple_impl	(	BasicJsonType &&	j,
		std::tuple< Args... > &	t,
		priority_tag< 3 >	)

inline

函数调用图:

◆ from_json_tuple_impl_base()

template<typename BasicJsonType , typename... Args, std::size_t... Idx>

std::tuple< Args... > detail::from_json_tuple_impl_base	(	BasicJsonType &&	j,
		index_sequence< Idx... >	)

这是这个函数的调用关系图:

◆ get()

template<std::size_t N, typename IteratorType , enable_if_t< N==0, int > = 0>

auto detail::get ( const nlohmann::detail::iteration_proxy_value< IteratorType > & i ) -> decltype(i.key())

这是这个函数的调用关系图:

◆ get_arithmetic_value()

template<typename BasicJsonType , typename ArithmeticType , enable_if_t< std::is_arithmetic< ArithmeticType >::value &&!std::is_same< ArithmeticType, typename BasicJsonType::boolean_t >::value, int > = 0>

void detail::get_arithmetic_value	(	const BasicJsonType &	j,
		ArithmeticType &	val )

函数调用图:

这是这个函数的调用关系图:

◆ hash()

template<typename BasicJsonType >

std::size_t detail::hash ( const BasicJsonType & j )

hash a JSON value

The hash function tries to rely on std::hash where possible. Furthermore, the type of the JSON value is taken into account to have different hash values for null, 0, 0U, and false, etc.

模板参数

BasicJsonType basic_json specialization

参数

j	JSON value to hash

返回: hash value of j

函数调用图:

这是这个函数的调用关系图:

◆ input_adapter() [1/7]

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

contiguous_bytes_input_adapter detail::input_adapter ( CharT b )

函数调用图:

◆ input_adapter() [2/7]

template<typename ContainerType >

container_input_adapter_factory_impl::container_input_adapter_factory< ContainerType >::adapter_type detail::input_adapter ( const ContainerType & container )

◆ input_adapter() [3/7]

template<typename IteratorType >

iterator_input_adapter_factory< IteratorType >::adapter_type detail::input_adapter	(	IteratorType	first,
		IteratorType	last )

这是这个函数的调用关系图:

◆ input_adapter() [4/7]

file_input_adapter detail::input_adapter ( std::FILE * file )

inline

◆ input_adapter() [5/7]

input_stream_adapter detail::input_adapter ( std::istream && stream )

inline

◆ input_adapter() [6/7]

input_stream_adapter detail::input_adapter ( std::istream & stream )

inline

◆ input_adapter() [7/7]

template<typename T , std::size_t N>

auto detail::input_adapter ( T(&) array[N] ) -> decltype(input_adapter(array, array + N))

函数调用图:

◆ int_to_string()

template<typename string_type >

void detail::int_to_string	(	string_type &	target,
		std::size_t	value )

函数调用图:

这是这个函数的调用关系图:

◆ little_endianness()

static bool detail::little_endianness ( int num = 1 )

inlinestaticnoexcept

determine system byte order

返回: true if and only if system's byte order is little endian

注解: from https://stackoverflow.com/a/1001328/266378

函数调用图:

这是这个函数的调用关系图:

◆ make_array()

template<typename T , typename... Args>

constexpr std::array< T, sizeof...(Args)> detail::make_array ( Args &&... args )

inlineconstexpr

◆ operator<()

bool 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 < binary
furthermore, each type is not smaller than itself
discarded values are not comparable
binary is represented as a b"" string in python and directly comparable to a string; however, making a binary array directly comparable with a string would be surprising behavior in a JSON file.

自从: version 1.0.0

◆ replace_substring()

template<typename StringType >

void detail::replace_substring	(	StringType &	s,
		const StringType &	f,
		const StringType &	t )

inline

replace all occurrences of a substring by another string

参数

[in,out]	s	the string to manipulate; changed so that all occurrences of f are replaced with t
[in]	f	the substring to replace with t
[in]	t	the string to replace f

前置条件: The search string f must not be empty. This precondition is enforced with an assertion.

自从: version 2.0.0

这是这个函数的调用关系图:

◆ to_chars()

template<typename FloatType >

JSON_HEDLEY_RETURNS_NON_NULL char * detail::to_chars	(	char *	first,
		const 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.

注解: 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.

◆ to_json() [1/18]

template<typename BasicJsonType , typename CompatibleNumberIntegerType , enable_if_t< is_compatible_integer_type< typename BasicJsonType::number_integer_t, CompatibleNumberIntegerType >::value, int > = 0>

void detail::to_json	(	BasicJsonType &	j,
		CompatibleNumberIntegerType	val )

inlinenoexcept

◆ to_json() [2/18]

template<typename BasicJsonType , typename CompatibleNumberUnsignedType , enable_if_t< is_compatible_integer_type< typename BasicJsonType::number_unsigned_t, CompatibleNumberUnsignedType >::value, int > = 0>

void detail::to_json	(	BasicJsonType &	j,
		CompatibleNumberUnsignedType	val )

inlinenoexcept

◆ to_json() [3/18]

template<typename BasicJsonType , typename BoolRef , enable_if_t<((std::is_same< std::vector< bool >::reference, BoolRef >::value &&!std::is_same< std::vector< bool >::reference, typename BasicJsonType::boolean_t & >::value)||(std::is_same< std::vector< bool >::const_reference, BoolRef >::value &&!std::is_same< detail::uncvref_t< std::vector< bool >::const_reference >, typename BasicJsonType::boolean_t >::value)) &&std::is_convertible< const BoolRef &, typename BasicJsonType::boolean_t >::value, int > = 0>

void detail::to_json	(	BasicJsonType &	j,
		const BoolRef &	b )

inlinenoexcept

◆ to_json() [4/18]

template<typename BasicJsonType , typename CompatibleArrayType , enable_if_t< is_compatible_array_type< BasicJsonType, CompatibleArrayType >::value &&!is_compatible_object_type< BasicJsonType, CompatibleArrayType >::value &&!is_compatible_string_type< BasicJsonType, CompatibleArrayType >::value &&!std::is_same< typename BasicJsonType::binary_t, CompatibleArrayType >::value &&!is_basic_json< CompatibleArrayType >::value, int > = 0>

void detail::to_json	(	BasicJsonType &	j,
		const CompatibleArrayType &	arr )

inline

◆ to_json() [5/18]

template<typename BasicJsonType , typename CompatibleObjectType , enable_if_t< is_compatible_object_type< BasicJsonType, CompatibleObjectType >::value &&!is_basic_json< CompatibleObjectType >::value, int > = 0>

void detail::to_json	(	BasicJsonType &	j,
		const CompatibleObjectType &	obj )

inline

◆ to_json() [6/18]

template<typename BasicJsonType , typename CompatibleString , enable_if_t< std::is_constructible< typename BasicJsonType::string_t, CompatibleString >::value, int > = 0>

void detail::to_json	(	BasicJsonType &	j,
		const CompatibleString &	s )

inline

◆ to_json() [7/18]

template<typename BasicJsonType , typename T1 , typename T2 , enable_if_t< std::is_constructible< BasicJsonType, T1 >::value &&std::is_constructible< BasicJsonType, T2 >::value, int > = 0>

void detail::to_json	(	BasicJsonType &	j,
		const std::pair< T1, T2 > &	p )

inline

◆ to_json() [8/18]

template<typename BasicJsonType , typename T , enable_if_t< std::is_convertible< T, BasicJsonType >::value, int > = 0>

void detail::to_json	(	BasicJsonType &	j,
		const std::valarray< T > &	arr )

inline

◆ to_json() [9/18]

template<typename BasicJsonType >

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

inline

◆ to_json() [10/18]

template<typename BasicJsonType , typename T , enable_if_t< std::is_same< T, iteration_proxy_value< typename BasicJsonType::iterator > >::value, int > = 0>

void detail::to_json	(	BasicJsonType &	j,
		const T &	b )

inline

◆ to_json() [11/18]

template<typename BasicJsonType , typename T , std::size_t N, enable_if_t< !std::is_constructible< typename BasicJsonType::string_t, const T(&)[N]>::value, int > = 0>

void detail::to_json	(	BasicJsonType &	j,
		const T(&)	arr[N] )

inline

◆ to_json() [12/18]

template<typename BasicJsonType >

void detail::to_json	(	BasicJsonType &	j,
		const typename BasicJsonType::binary_t &	bin )

inline

◆ to_json() [13/18]

template<typename BasicJsonType , typename EnumType , enable_if_t< std::is_enum< EnumType >::value, int > = 0>

void detail::to_json	(	BasicJsonType &	j,
		EnumType	e )

inlinenoexcept

◆ to_json() [14/18]

template<typename BasicJsonType , typename FloatType , enable_if_t< std::is_floating_point< FloatType >::value, int > = 0>

void detail::to_json	(	BasicJsonType &	j,
		FloatType	val )

inlinenoexcept

◆ to_json() [15/18]

template<typename BasicJsonType , typename T , enable_if_t< std::is_same< T, typename BasicJsonType::boolean_t >::value, int > = 0>

void detail::to_json	(	BasicJsonType &	j,
		T	b )

inlinenoexcept

这是这个函数的调用关系图:

◆ to_json() [16/18]

template<typename BasicJsonType >

void detail::to_json	(	BasicJsonType &	j,
		typename BasicJsonType::array_t &&	arr )

inline

◆ to_json() [17/18]

template<typename BasicJsonType >

void detail::to_json	(	BasicJsonType &	j,
		typename BasicJsonType::object_t &&	obj )

inline

◆ to_json() [18/18]

template<typename BasicJsonType >

void detail::to_json	(	BasicJsonType &	j,
		typename BasicJsonType::string_t &&	s )

inline

◆ to_json_tuple_impl()

template<typename BasicJsonType , typename Tuple , std::size_t... Idx>

void detail::to_json_tuple_impl	(	BasicJsonType &	j,
		const Tuple &	t,
		index_sequence< Idx... >	)

inline

◆ unescape()

template<typename StringType >

static void detail::unescape ( StringType & s )

static

string unescaping as described in RFC 6901 (Sect. 4)

参数

[in] s string to unescape

返回: unescaped string

Note the order of escaping "~1" to "/" and "~0" to "~" is important.

函数调用图:

这是这个函数的调用关系图:

◆ value_in_range_of()

template<typename OfType , typename T >

constexpr bool detail::value_in_range_of ( T val )

inlineconstexpr

命名空间

类

类型定义

枚举

函数

详细描述

类型定义说明

◆ actual_object_comparator_t

◆ all_integral

◆ all_signed

◆ all_unsigned

◆ binary_function_t

◆ bool_constant

◆ boolean_function_t

◆ contiguous_bytes_input_adapter

◆ detect_erase_with_key_type

◆ detect_is_transparent

◆ detect_key_compare

◆ detect_string_can_append

◆ detect_string_can_append_data

◆ detect_string_can_append_iter

◆ detect_string_can_append_op

◆ detected_or

◆ detected_or_t

◆ detected_t

◆ difference_type_t

◆ enable_if_t

◆ end_array_function_t

◆ end_object_function_t

◆ from_json_function

◆ get_template_function

◆ has_erase_with_key_type

◆ index_sequence

◆ index_sequence_for

◆ is_c_string_uncvref

◆ is_detected

◆ is_detected_convertible

◆ is_detected_exact

◆ is_json_pointer

◆ is_usable_as_basic_json_key_type

◆ is_usable_as_key_type

◆ iterator_category_t

◆ iterator_t

◆ json_base_class

◆ key_function_t

◆ key_type_t

◆ make_index_sequence

◆ make_integer_sequence

◆ mapped_type_t

◆ never_out_of_range

◆ null_function_t

◆ number_float_function_t

◆ number_integer_function_t

◆ number_unsigned_function_t

◆ output_adapter_t

◆ parse_error_function_t

◆ parser_callback_t

◆ pointer_t

◆ range_value_t

◆ reference_t

◆ same_sign

◆ start_array_function_t

◆ start_object_function_t

◆ string_can_append

◆ string_can_append_data

◆ string_can_append_iter

◆ string_can_append_op

◆ string_function_t

◆ to_json_function

◆ uncvref_t

◆ value_type_t

◆ void_t

枚举类型说明

◆ cbor_tag_handler_t

◆ error_handler_t

◆ input_format_t

◆ parse_event_t

◆ value_t

函数说明

◆ combine()