nlohmann::detail Namespace Reference

detail namespace with internal helper functions More...

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

Classes
struct	position_t
	struct to capture the start position of the current token More...
class	exception
	general exception of the basic_json class More...
class	parse_error
	exception indicating a parse error More...
class	invalid_iterator
	exception indicating errors with iterators More...
class	type_error
	exception indicating executing a member function with a wrong type More...
class	out_of_range
	exception indicating access out of the defined range More...
class	other_error
	exception indicating other library errors More...
struct	index_sequence
struct	merge_and_renumber
struct	merge_and_renumber< index_sequence< I1...>, index_sequence< I2...> >
struct	make_index_sequence
struct	make_index_sequence< 0 >
struct	make_index_sequence< 1 >
struct	priority_tag
struct	priority_tag< 0 >
struct	static_const
struct	make_void
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	iterator_traits
struct	iterator_traits< T, enable_if_t< !std::is_pointer< T >::value > >
struct	iterator_traits< T *, enable_if_t< std::is_object< T >::value > >
struct	nonesuch
struct	detector
struct	detector< Default, void_t< Op< Args...> >, Op, Args...>
struct	is_basic_json
struct	is_basic_json< NLOHMANN_BASIC_JSON_TPL >
struct	has_from_json
struct	has_from_json< BasicJsonType, T, enable_if_t< not is_basic_json< T >::value > >
struct	has_non_default_from_json
struct	has_non_default_from_json< BasicJsonType, T, enable_if_t< not is_basic_json< T >::value > >
struct	has_to_json
struct	has_to_json< BasicJsonType, T, enable_if_t< not is_basic_json< T >::value > >
struct	is_iterator_traits
struct	is_iterator_traits< iterator_traits< T > >
struct	is_complete_type
struct	is_complete_type< T, decltype(void(sizeof(T)))>
struct	is_compatible_object_type_impl
struct	is_compatible_object_type_impl< BasicJsonType, CompatibleObjectType, enable_if_t< is_detected< mapped_type_t, CompatibleObjectType >::value andis_detected< key_type_t, CompatibleObjectType >::value > >
struct	is_compatible_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 andis_detected< key_type_t, ConstructibleObjectType >::value > >
struct	is_constructible_object_type
struct	is_compatible_string_type_impl
struct	is_compatible_string_type_impl< BasicJsonType, CompatibleStringType, enable_if_t< is_detected_exact< typename BasicJsonType::string_t::value_type, value_type_t, CompatibleStringType >::value > >
struct	is_compatible_string_type
struct	is_constructible_string_type_impl
struct	is_constructible_string_type_impl< BasicJsonType, ConstructibleStringType, enable_if_t< is_detected_exact< typename BasicJsonType::string_t::value_type, value_type_t, ConstructibleStringType >::value > >
struct	is_constructible_string_type
struct	is_compatible_array_type_impl
struct	is_compatible_array_type_impl< BasicJsonType, CompatibleArrayType, enable_if_t< is_detected< value_type_t, CompatibleArrayType >::value andis_detected< iterator_t, CompatibleArrayType >::value andnot is_iterator_traits< iterator_traits< CompatibleArrayType > >::value > >
struct	is_compatible_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 > >
struct	is_constructible_array_type_impl< BasicJsonType, ConstructibleArrayType, enable_if_t< not std::is_same< ConstructibleArrayType, typename BasicJsonType::value_type >::value andstd::is_default_constructible< ConstructibleArrayType >::value and(std::is_move_assignable< ConstructibleArrayType >::value or std::is_copy_assignable< ConstructibleArrayType >::value) andis_detected< value_type_t, ConstructibleArrayType >::value andis_detected< iterator_t, ConstructibleArrayType >::value andis_complete_type< detected_t< value_type_t, ConstructibleArrayType > >::value > >
struct	is_constructible_array_type
struct	is_compatible_integer_type_impl
struct	is_compatible_integer_type_impl< RealIntegerType, CompatibleNumberIntegerType, enable_if_t< std::is_integral< RealIntegerType >::value andstd::is_integral< CompatibleNumberIntegerType >::value andnot std::is_same< bool, CompatibleNumberIntegerType >::value > >
struct	is_compatible_integer_type
struct	is_compatible_type_impl
struct	is_compatible_type_impl< BasicJsonType, CompatibleType, enable_if_t< is_complete_type< CompatibleType >::value > >
struct	is_compatible_type
struct	conjunction
struct	conjunction< B1 >
struct	conjunction< B1, Bn...>
struct	is_constructible_tuple
struct	is_constructible_tuple< T1, std::tuple< Args...> >
struct	from_json_fn
class	iteration_proxy_value
class	iteration_proxy
	proxy class for the items() function More...
struct	external_constructor
struct	external_constructor< value_t::boolean >
struct	external_constructor< value_t::string >
struct	external_constructor< value_t::number_float >
struct	external_constructor< value_t::number_unsigned >
struct	external_constructor< value_t::number_integer >
struct	external_constructor< value_t::array >
struct	external_constructor< value_t::object >
struct	to_json_fn
struct	input_adapter_protocol
	abstract input adapter interface More...
class	file_input_adapter
class	input_stream_adapter
class	input_buffer_adapter
	input adapter for buffer input More...
struct	wide_string_input_helper
struct	wide_string_input_helper< WideStringType, 2 >
class	wide_string_input_adapter
class	input_adapter
class	json_sax_dom_parser
	SAX implementation to create a JSON value from SAX events. More...
class	json_sax_dom_callback_parser
class	json_sax_acceptor
struct	is_sax
struct	is_sax_static_asserts
class	binary_reader
	deserialization of CBOR, MessagePack, and UBJSON values More...
class	lexer
	lexical analysis More...
class	parser
	syntax analysis More...
class	primitive_iterator_t
struct	internal_iterator
	an iterator value More...
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. More...
class	json_reverse_iterator
	a template for a reverse iterator class More...
class	json_ref
struct	output_adapter_protocol
	abstract output adapter interface More...
class	output_vector_adapter
	output adapter for byte vectors More...
class	output_stream_adapter
	output adapter for output streams More...
class	output_string_adapter
	output adapter for basic_string More...
class	output_adapter
class	binary_writer
	serialization to CBOR and MessagePack values More...
class	serializer

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)>
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 = std::is_convertible< detected_t< Op, Args...>, To >
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 >
using	iterator_t = typename T::iterator
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 >())
using	input_adapter_t = std::shared_ptr< input_adapter_protocol >
	a type to simplify interfaces More...
template<typename T >
using	null_function_t = decltype(std::declval< T & >().null())
template<typename T >
using	boolean_function_t = decltype(std::declval< T & >().boolean(std::declval< bool >()))
template<typename T , typename Integer >
using	number_integer_function_t = decltype(std::declval< T & >().number_integer(std::declval< Integer >()))
template<typename T , typename Unsigned >
using	number_unsigned_function_t = decltype(std::declval< T & >().number_unsigned(std::declval< Unsigned >()))
template<typename T , typename Float , typename String >
using	number_float_function_t = decltype(std::declval< T & >().number_float(std::declval< Float >(), std::declval< const String & >()))
template<typename T , typename String >
using	string_function_t = decltype(std::declval< T & >().string(std::declval< String & >()))
template<typename T >
using	start_object_function_t = decltype(std::declval< T & >().start_object(std::declval< std::size_t >()))
template<typename T , typename String >
using	key_function_t = decltype(std::declval< T & >().key(std::declval< String & >()))
template<typename T >
using	end_object_function_t = decltype(std::declval< T & >().end_object())
template<typename T >
using	start_array_function_t = decltype(std::declval< T & >().start_array(std::declval< std::size_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 = decltype(std::declval< T & >().parse_error(std::declval< std::size_t >(), std::declval< const std::string & >(), std::declval< const Exception & >()))
template<typename CharType >
using	output_adapter_t = std::shared_ptr< output_adapter_protocol< CharType >>
	a type to simplify interfaces More...

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...
enum	input_format_t {   input_format_t::json, input_format_t::cbor, input_format_t::msgpack, input_format_t::ubjson,   input_format_t::bson }
	the supported input formats More...
enum	error_handler_t { error_handler_t::strict, error_handler_t::replace, error_handler_t::ignore }
	how to treat decoding errors More...

Functions
bool	operator< (const value_t lhs, const value_t rhs) noexcept
	comparison operator for JSON types More...
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 andnot 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 ConstructibleStringType , enable_if_t< is_constructible_string_type< BasicJsonType, ConstructibleStringType >::value andnot std::is_same< typename BasicJsonType::string_t, ConstructibleStringType >::value, int > = 0>
void	from_json (const BasicJsonType &j, ConstructibleStringType &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< 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 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 >
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 >
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 andnot is_constructible_object_type< BasicJsonType, ConstructibleArrayType >::value andnot is_constructible_string_type< BasicJsonType, ConstructibleArrayType >::value andnot 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 > ()
j template	void ())
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 andnot std::is_same< ArithmeticType, typename BasicJsonType::number_unsigned_t >::value andnot std::is_same< ArithmeticType, typename BasicJsonType::number_integer_t >::value andnot std::is_same< ArithmeticType, typename BasicJsonType::number_float_t >::value andnot 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 Key , typename Value , typename Compare , typename Allocator , typename = enable_if_t<not 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<not 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 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 andnot is_compatible_object_type< BasicJsonType, CompatibleArrayType >::value andnot is_compatible_string_type< BasicJsonType, CompatibleArrayType >::value andnot is_basic_json< 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, 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 and not 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< not 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...>)
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). 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

Typedef Documentation

template<typename T >

using nlohmann::detail::boolean_function_t = typedef decltype(std::declval<T&>().boolean(std::declval<bool>()))

Definition at line 5035 of file json.hpp.

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

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

Definition at line 2370 of file json.hpp.

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

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

Definition at line 2373 of file json.hpp.

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

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

Definition at line 2367 of file json.hpp.

template<typename T >

using nlohmann::detail::difference_type_t = typedef typename T::difference_type

Definition at line 2495 of file json.hpp.

template<bool B, typename T = void>

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

Definition at line 2191 of file json.hpp.

template<typename T >

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

Definition at line 5069 of file json.hpp.

template<typename T >

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

Definition at line 5062 of file json.hpp.

template<typename T , typename... Args>

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

Definition at line 2513 of file json.hpp.

template<typename T , typename U >

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

Definition at line 2516 of file json.hpp.

template<typename... Ts>

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

Definition at line 2225 of file json.hpp.

using nlohmann::detail::input_adapter_t = typedef std::shared_ptr<input_adapter_protocol>

a type to simplify interfaces

Definition at line 3912 of file json.hpp.

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

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

Definition at line 2364 of file json.hpp.

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

using nlohmann::detail::is_detected_convertible = typedef std::is_convertible<detected_t<Op, Args...>, To>

Definition at line 2380 of file json.hpp.

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

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

Definition at line 2376 of file json.hpp.

template<typename T >

using nlohmann::detail::iterator_category_t = typedef typename T::iterator_category

Definition at line 2504 of file json.hpp.

template<typename T >

using nlohmann::detail::iterator_t = typedef typename T::iterator

Definition at line 2507 of file json.hpp.

template<typename T , typename String >

using nlohmann::detail::key_function_t = typedef decltype(std::declval<T&>().key(std::declval<String&>()))

Definition at line 5059 of file json.hpp.

template<typename T >

using nlohmann::detail::key_type_t = typedef typename T::key_type

Definition at line 2489 of file json.hpp.

template<typename T >

using nlohmann::detail::mapped_type_t = typedef typename T::mapped_type

Definition at line 2486 of file json.hpp.

template<typename T >

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

Definition at line 5031 of file json.hpp.

template<typename T , typename Float , typename String >

using nlohmann::detail::number_float_function_t = typedef decltype(std::declval<T&>().number_float( std::declval<Float>(), std::declval<const String&>()))

Definition at line 5047 of file json.hpp.

template<typename T , typename Integer >

using nlohmann::detail::number_integer_function_t = typedef decltype(std::declval<T&>().number_integer(std::declval<Integer>()))

Definition at line 5039 of file json.hpp.

template<typename T , typename Unsigned >

using nlohmann::detail::number_unsigned_function_t = typedef decltype(std::declval<T&>().number_unsigned(std::declval<Unsigned>()))

Definition at line 5043 of file json.hpp.

template<typename CharType >

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

a type to simplify interfaces

Definition at line 11207 of file json.hpp.

template<typename T , typename Exception >

using nlohmann::detail::parse_error_function_t = typedef decltype(std::declval<T&>().parse_error( std::declval<std::size_t>(), std::declval<const std::string&>(), std::declval<const Exception&>()))

Definition at line 5074 of file json.hpp.

template<typename T >

using nlohmann::detail::pointer_t = typedef typename T::pointer

Definition at line 2498 of file json.hpp.

template<typename T >

using nlohmann::detail::reference_t = typedef typename T::reference

Definition at line 2501 of file json.hpp.

template<typename T >

using nlohmann::detail::start_array_function_t = typedef decltype(std::declval<T&>().start_array(std::declval<std::size_t>()))

Definition at line 5066 of file json.hpp.

template<typename T >

using nlohmann::detail::start_object_function_t = typedef decltype(std::declval<T&>().start_object(std::declval<std::size_t>()))

Definition at line 5055 of file json.hpp.

template<typename T , typename String >

using nlohmann::detail::string_function_t = typedef decltype(std::declval<T&>().string(std::declval<String&>()))

Definition at line 5051 of file json.hpp.

template<typename T , typename... Args>

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

Definition at line 2510 of file json.hpp.

template<typename T >

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

Definition at line 2194 of file json.hpp.

template<typename T >

using nlohmann::detail::value_type_t = typedef typename T::value_type

Definition at line 2492 of file json.hpp.

template<typename... Ts>

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

Definition at line 2267 of file json.hpp.

Enumeration Type Documentation

enum nlohmann::detail::error_handler_t

strong

how to treat decoding errors

Enumerator
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

Definition at line 13779 of file json.hpp.

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

enum nlohmann::detail::input_format_t

strong

the supported input formats

Enumerator
json
cbor
msgpack
ubjson
bson

Definition at line 3887 of file json.hpp.

{ json, cbor, msgpack, ubjson, bson };

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

Definition at line 2854 of file json.hpp.

                   : std::uint8_t
{
    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

template<typename BasicJsonType >

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

Definition at line 2898 of file json.hpp.

{
    if (JSON_HEDLEY_UNLIKELY(not j.is_null()))
    {
        JSON_THROW(type_error::create(302, "type must be null, but is " + std::string(j.type_name())));
    }
    n = nullptr;
}

template<typename BasicJsonType >

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

Definition at line 2938 of file json.hpp.

{
    if (JSON_HEDLEY_UNLIKELY(not j.is_boolean()))
    {
        JSON_THROW(type_error::create(302, "type must be boolean, but is " + std::string(j.type_name())));
    }
    b = *j.template get_ptr<const typename BasicJsonType::boolean_t*>();
}

template<typename BasicJsonType >

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

Definition at line 2948 of file json.hpp.

{
    if (JSON_HEDLEY_UNLIKELY(not j.is_string()))
    {
        JSON_THROW(type_error::create(302, "type must be string, but is " + std::string(j.type_name())));
    }
    s = *j.template get_ptr<const typename BasicJsonType::string_t*>();
}

template<typename BasicJsonType , typename ConstructibleStringType , enable_if_t< is_constructible_string_type< BasicJsonType, ConstructibleStringType >::value andnot std::is_same< typename BasicJsonType::string_t, ConstructibleStringType >::value, int > = 0>

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

Definition at line 2964 of file json.hpp.

{
    if (JSON_HEDLEY_UNLIKELY(not j.is_string()))
    {
        JSON_THROW(type_error::create(302, "type must be string, but is " + std::string(j.type_name())));
    }

    s = *j.template get_ptr<const typename BasicJsonType::string_t*>();
}

template<typename BasicJsonType >

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

Definition at line 2975 of file json.hpp.

{
    get_arithmetic_value(j, val);
}

template<typename BasicJsonType >

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

Definition at line 2981 of file json.hpp.

{
    get_arithmetic_value(j, val);
}

template<typename BasicJsonType >

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

Definition at line 2987 of file json.hpp.

{
    get_arithmetic_value(j, val);
}

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

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

Definition at line 2994 of file json.hpp.

{
    typename std::underlying_type<EnumType>::type val;
    get_arithmetic_value(j, val);
    e = static_cast<EnumType>(val);
}

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

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

Definition at line 3004 of file json.hpp.

{
    if (JSON_HEDLEY_UNLIKELY(not j.is_array()))
    {
        JSON_THROW(type_error::create(302, "type must be array, but is " + std::string(j.type_name())));
    }
    l.clear();
    std::transform(j.rbegin(), j.rend(),
                   std::front_inserter(l), [](const BasicJsonType & i)
    {
        return i.template get<T>();
    });
}

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

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

Definition at line 3021 of file json.hpp.

{
    if (JSON_HEDLEY_UNLIKELY(not j.is_array()))
    {
        JSON_THROW(type_error::create(302, "type must be array, but is " + std::string(j.type_name())));
    }
    l.resize(j.size());
    std::copy(j.begin(), j.end(), std::begin(l));
}

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

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

Definition at line 3032 of file json.hpp.

{
    for (std::size_t i = 0; i < N; ++i)
    {
        arr[i] = j.at(i).template get<T>();
    }
}

template<typename BasicJsonType , typename ConstructibleArrayType , enable_if_t< is_constructible_array_type< BasicJsonType, ConstructibleArrayType >::value andnot is_constructible_object_type< BasicJsonType, ConstructibleArrayType >::value andnot is_constructible_string_type< BasicJsonType, ConstructibleArrayType >::value andnot is_basic_json< ConstructibleArrayType >::value, int > = 0>

auto nlohmann::detail::from_json	(	const BasicJsonType &	j,
		ConstructibleArrayType &	arr
	)		-> decltype(from_json_array_impl(j, arr, priority_tag<3>

Definition at line 3105 of file json.hpp.

                                                         {}),

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

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

Definition at line 3121 of file json.hpp.

{
    if (JSON_HEDLEY_UNLIKELY(not j.is_object()))
    {
        JSON_THROW(type_error::create(302, "type must be object, but is " + std::string(j.type_name())));
    }

    ConstructibleObjectType ret;
    auto inner_object = j.template get_ptr<const typename BasicJsonType::object_t*>();
    using value_type = typename ConstructibleObjectType::value_type;
    std::transform(
        inner_object->begin(), inner_object->end(),
        std::inserter(ret, ret.begin()),
        [](typename BasicJsonType::object_t::value_type const & p)
    {
        return value_type(p.first, p.second.template get<typename ConstructibleObjectType::mapped_type>());
    });
    obj = std::move(ret);
}

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

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

Definition at line 3153 of file json.hpp.

{
    switch (static_cast<value_t>(j))
    {
        case value_t::number_unsigned:
        {
            val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_unsigned_t*>());
            break;
        }
        case value_t::number_integer:
        {
            val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_integer_t*>());
            break;
        }
        case value_t::number_float:
        {
            val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_float_t*>());
            break;
        }
        case value_t::boolean:
        {
            val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::boolean_t*>());
            break;
        }

        default:
            JSON_THROW(type_error::create(302, "type must be number, but is " + std::string(j.type_name())));
    }
}

template<typename BasicJsonType , typename A1 , typename A2 >

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

Definition at line 3184 of file json.hpp.

{
    p = {j.at(0).template get<A1>(), j.at(1).template get<A2>()};
}

template<typename BasicJsonType , typename... Args>

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

Definition at line 3196 of file json.hpp.

{
    from_json_tuple_impl(j, t, index_sequence_for<Args...> {});
}

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

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

Definition at line 3204 of file json.hpp.

{
    if (JSON_HEDLEY_UNLIKELY(not j.is_array()))
    {
        JSON_THROW(type_error::create(302, "type must be array, but is " + std::string(j.type_name())));
    }
    m.clear();
    for (const auto& p : j)
    {
        if (JSON_HEDLEY_UNLIKELY(not p.is_array()))
        {
            JSON_THROW(type_error::create(302, "type must be array, but is " + std::string(p.type_name())));
        }
        m.emplace(p.at(0).template get<Key>(), p.at(1).template get<Value>());
    }
}

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

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

Definition at line 3224 of file json.hpp.

{
    if (JSON_HEDLEY_UNLIKELY(not j.is_array()))
    {
        JSON_THROW(type_error::create(302, "type must be array, but is " + std::string(j.type_name())));
    }
    m.clear();
    for (const auto& p : j)
    {
        if (JSON_HEDLEY_UNLIKELY(not p.is_array()))
        {
            JSON_THROW(type_error::create(302, "type must be array, but is " + std::string(p.type_name())));
        }
        m.emplace(p.at(0).template get<Key>(), p.at(1).template get<Value>());
    }
}

template<typename BasicJsonType >

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

Definition at line 3042 of file json.hpp.

{
    arr = *j.template get_ptr<const typename BasicJsonType::array_t*>();
}

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

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

Definition at line 3048 of file json.hpp.

{
    for (std::size_t i = 0; i < N; ++i)
    {
        arr[i] = j.at(i).template get<T>();
    }
}

template<typename BasicJsonType , typename ConstructibleArrayType >

auto nlohmann::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())

Definition at line 3059 of file json.hpp.

{
    using std::end;

    ConstructibleArrayType ret;
    ret.reserve(j.size());
    std::transform(j.begin(), j.end(),
                   std::inserter(ret, end(ret)), [](const BasicJsonType & i)
    {
        // get<BasicJsonType>() returns *this, this won't call a from_json
        // method when value_type is BasicJsonType
        return i.template get<typename ConstructibleArrayType::value_type>();
    });
    arr = std::move(ret);
}

template<typename BasicJsonType , typename ConstructibleArrayType >

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

Definition at line 3080 of file json.hpp.

{
    using std::end;

    ConstructibleArrayType ret;
    std::transform(
        j.begin(), j.end(), std::inserter(ret, end(ret)),
        [](const BasicJsonType & i)
    {
        // get<BasicJsonType>() returns *this, this won't call a from_json
        // method when value_type is BasicJsonType
        return i.template get<typename ConstructibleArrayType::value_type>();
    });
    arr = std::move(ret);
}

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

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

Definition at line 3190 of file json.hpp.

{
    t = std::make_tuple(j.at(Idx).template get<typename std::tuple_element<Idx, Tuple>::type>()...);
}

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

auto nlohmann::detail::get

(

const nlohmann::detail::iteration_proxy_value< IteratorType > &

i

)

-> decltype(i.key())

Definition at line 3412 of file json.hpp.

{
    return i.key();
}

j template nlohmann::detail::get< typename ConstructibleArrayType::value_type >

(

)

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

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

Definition at line 2912 of file json.hpp.

{
    switch (static_cast<value_t>(j))
    {
        case value_t::number_unsigned:
        {
            val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_unsigned_t*>());
            break;
        }
        case value_t::number_integer:
        {
            val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_integer_t*>());
            break;
        }
        case value_t::number_float:
        {
            val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_float_t*>());
            break;
        }

        default:
            JSON_THROW(type_error::create(302, "type must be number, but is " + std::string(j.type_name())));
    }
}

template<typename string_type >

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

Definition at line 3293 of file json.hpp.

{
    target = std::to_string(value);
}

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

Definition at line 2877 of file json.hpp.

{
    static constexpr std::array<std::uint8_t, 8> order = {{
            0 /* null */, 3 /* object */, 4 /* array */, 5 /* string */,
            1 /* boolean */, 2 /* integer */, 2 /* unsigned */, 2 /* float */
        }
    };

    const auto l_index = static_cast<std::size_t>(lhs);
    const auto r_index = static_cast<std::size_t>(rhs);
    return l_index < order.size() and r_index < order.size() and order[l_index] < order[r_index];
}

template<typename FloatType >

JSON_HEDLEY_RETURNS_NON_NULL char* nlohmann::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.

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.

Definition at line 13709 of file json.hpp.

{
    static_cast<void>(last); // maybe unused - fix warning
    assert(std::isfinite(value));

    // Use signbit(value) instead of (value < 0) since signbit works for -0.
    if (std::signbit(value))
    {
        value = -value;
        *first++ = '-';
    }

    if (value == 0) // +-0
    {
        *first++ = '0';
        // Make it look like a floating-point number (#362, #378)
        *first++ = '.';
        *first++ = '0';
        return first;
    }

    assert(last - first >= std::numeric_limits<FloatType>::max_digits10);

    // Compute v = buffer * 10^decimal_exponent.
    // The decimal digits are stored in the buffer, which needs to be interpreted
    // as an unsigned decimal integer.
    // len is the length of the buffer, i.e. the number of decimal digits.
    int len = 0;
    int decimal_exponent = 0;
    dtoa_impl::grisu2(first, len, decimal_exponent, value);

    assert(len <= std::numeric_limits<FloatType>::max_digits10);

    // Format the buffer like printf("%.*g", prec, value)
    constexpr int kMinExp = -4;
    // Use digits10 here to increase compatibility with version 2.
    constexpr int kMaxExp = std::numeric_limits<FloatType>::digits10;

    assert(last - first >= kMaxExp + 2);
    assert(last - first >= 2 + (-kMinExp - 1) + std::numeric_limits<FloatType>::max_digits10);
    assert(last - first >= std::numeric_limits<FloatType>::max_digits10 + 6);

    return dtoa_impl::format_buffer(first, len, decimal_exponent, kMinExp, kMaxExp);
}

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

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

noexcept

Definition at line 3647 of file json.hpp.

{
    external_constructor<value_t::boolean>::construct(j, b);
}

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

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

Definition at line 3654 of file json.hpp.

{
    external_constructor<value_t::string>::construct(j, s);
}

template<typename BasicJsonType >

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

Definition at line 3660 of file json.hpp.

{
    external_constructor<value_t::string>::construct(j, std::move(s));
}

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

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

noexcept

Definition at line 3667 of file json.hpp.

{
    external_constructor<value_t::number_float>::construct(j, static_cast<typename BasicJsonType::number_float_t>(val));
}

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

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

noexcept

Definition at line 3674 of file json.hpp.

{
    external_constructor<value_t::number_unsigned>::construct(j, static_cast<typename BasicJsonType::number_unsigned_t>(val));
}

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

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

noexcept

Definition at line 3681 of file json.hpp.

{
    external_constructor<value_t::number_integer>::construct(j, static_cast<typename BasicJsonType::number_integer_t>(val));
}

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

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

noexcept

Definition at line 3688 of file json.hpp.

{
    using underlying_type = typename std::underlying_type<EnumType>::type;
    external_constructor<value_t::number_integer>::construct(j, static_cast<underlying_type>(e));
}

template<typename BasicJsonType >

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

Definition at line 3695 of file json.hpp.

{
    external_constructor<value_t::array>::construct(j, e);
}

template<typename BasicJsonType , typename CompatibleArrayType , enable_if_t< is_compatible_array_type< BasicJsonType, CompatibleArrayType >::value andnot is_compatible_object_type< BasicJsonType, CompatibleArrayType >::value andnot is_compatible_string_type< BasicJsonType, CompatibleArrayType >::value andnot is_basic_json< CompatibleArrayType >::value, int > = 0>

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

Definition at line 3708 of file json.hpp.

{
    external_constructor<value_t::array>::construct(j, arr);
}

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

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

Definition at line 3715 of file json.hpp.

{
    external_constructor<value_t::array>::construct(j, std::move(arr));
}

template<typename BasicJsonType >

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

Definition at line 3721 of file json.hpp.

{
    external_constructor<value_t::array>::construct(j, std::move(arr));
}

template<typename BasicJsonType , typename CompatibleObjectType , enable_if_t< is_compatible_object_type< BasicJsonType, CompatibleObjectType >::value and not is_basic_json< CompatibleObjectType >::value, int > = 0>

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

Definition at line 3728 of file json.hpp.

{
    external_constructor<value_t::object>::construct(j, obj);
}

template<typename BasicJsonType >

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

Definition at line 3734 of file json.hpp.

{
    external_constructor<value_t::object>::construct(j, std::move(obj));
}

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

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

Definition at line 3744 of file json.hpp.

{
    external_constructor<value_t::array>::construct(j, arr);
}

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 nlohmann::detail::to_json	(	BasicJsonType &	j,
		const std::pair< T1, T2 > &	p
	)

Definition at line 3750 of file json.hpp.

{
    j = { p.first, p.second };
}

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

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

Definition at line 3758 of file json.hpp.

{
    j = { {b.key(), b.value()} };
}

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

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

Definition at line 3764 of file json.hpp.

{
    j = { std::get<Idx>(t)... };
}

j template nlohmann::detail::void

(

)

Definition at line 3108 of file json.hpp.

{
    if (JSON_HEDLEY_UNLIKELY(not j.is_array()))
    {
        JSON_THROW(type_error::create(302, "type must be array, but is " +
                                      std::string(j.type_name())));
    }

    from_json_array_impl(j, arr, priority_tag<3> {});
}