Loading...
Searching...
No Matches
detail Namespace Reference

detail namespace with internal helper functions More...

## Namespaces

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

## Classes

struct | make_void
struct | nonesuch
struct | detector
struct | detector< Default, void_t< Op< Args... > >, Op, Args... >
struct | is_detected_lazy
struct | position_t
| struct to capture the start position of the current token More...
struct | integer_sequence
struct | priority_tag
struct | priority_tag< 0 >
struct | static_const
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 | is_basic_json
struct | is_basic_json< NLOHMANN_BASIC_JSON_TPL >
struct | is_basic_json_context
class | json_ref
struct | is_json_ref
struct | is_json_ref< json_ref< T > >
struct | has_from_json
struct | is_getable
struct | has_from_json< BasicJsonType, T, enable_if_t< !is_basic_json< T >::value > >
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 | has_key_compare
struct | actual_object_comparator
struct | char_traits
struct | char_traits< unsigned char >
struct | char_traits< signed char >
struct | conjunction
struct | conjunction< B >
struct | conjunction< B, Bn... >
struct | negation
struct | is_default_constructible
struct | is_default_constructible< std::pair< T1, T2 > >
struct | is_default_constructible< const std::pair< T1, T2 > >
struct | is_default_constructible< std::tuple< Ts... > >
struct | is_default_constructible< const std::tuple< Ts... > >
struct | is_constructible
struct | is_constructible< std::pair< T1, T2 > >
struct | is_constructible< const std::pair< T1, T2 > >
struct | is_constructible< std::tuple< Ts... > >
struct | is_constructible< const std::tuple< Ts... > >
struct | is_iterator_traits
struct | is_iterator_traits< iterator_traits< T > >
struct | is_range
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 &&is_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 &&is_detected< key_type_t, ConstructibleObjectType >::value > >
struct | is_constructible_object_type
struct | is_compatible_string_type
struct | is_constructible_string_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_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< !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
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_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 | is_compatible_reference_type_impl
struct | is_compatible_reference_type
struct | is_constructible_tuple
struct | is_constructible_tuple< T1, std::tuple< Args... > >
struct | is_json_iterator_of
struct | is_json_iterator_of< BasicJsonType, typename BasicJsonType::iterator >
struct | is_json_iterator_of< BasicJsonType, typename BasicJsonType::const_iterator >
struct | is_specialization_of
struct | is_specialization_of< Primary, Primary< Args... > >
struct | is_json_pointer_of
struct | is_json_pointer_of< A, ::nlohmann::json_pointer< A > >
struct | is_json_pointer_of< A, ::nlohmann::json_pointer< A > & >
struct | is_comparable
struct | is_comparable< Compare, A, B, enable_if_t< !is_json_pointer_of< A, B >::value &&std::is_constructible< decltype(std::declval< Compare >()(std::declval< A >(), std::declval< B >()))>::value &&std::is_constructible< decltype(std::declval< Compare >()(std::declval< B >(), std::declval< A >()))>::value > >
struct | is_ordered_map
struct | value_in_range_of_impl2
struct | value_in_range_of_impl2< OfType, T, false, false >
struct | value_in_range_of_impl2< OfType, T, true, false >
struct | value_in_range_of_impl2< OfType, T, false, true >
struct | value_in_range_of_impl2< OfType, T, true, true >
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 | is_c_string
struct | is_transparent
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 | identity_tag
struct | cxpr_or_impl
struct | cxpr_or_impl< true, Booleans... >
struct | cxpr_or_impl< false, Booleans... >
struct | cxpr_and_impl
struct | cxpr_and_impl< true, Booleans... >
struct | cxpr_and_impl< false, Booleans... >
struct | cxpr_not
struct | cxpr_or
struct | cxpr_or_c
struct | cxpr_and
struct | cxpr_and_c
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::binary >
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
class | file_input_adapter
class | input_stream_adapter
class | iterator_input_adapter
struct | wide_string_input_helper
struct | wide_string_input_helper< BaseInputAdapter, 4 >
struct | wide_string_input_helper< BaseInputAdapter, 2 >
class | wide_string_input_adapter
struct | iterator_input_adapter_factory
struct | is_iterator_of_multibyte
struct | iterator_input_adapter_factory< IteratorType, enable_if_t< is_iterator_of_multibyte< IteratorType >::value > >
class | span_input_adapter
class | lexer_base
class | lexer
| lexical analysis More...
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 | parser
| syntax analysis More...
class | primitive_iterator_t
struct | internal_iterator
| an iterator value More...
class | iter_impl
class | json_reverse_iterator
struct | json_default_base
| Default base class of the basic_json class. More...
struct | output_adapter_protocol
class | output_vector_adapter
class | output_stream_adapter
class | output_string_adapter
class | output_adapter
class | binary_writer
| serialization to CBOR and MessagePack values More...
class | serializer

## Typedefs

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>
template<std::size_t PTagValue, typename BasicJsonType, typename... Types>
using | tuple_type = std::tuple < decltype(from_json_tuple_get_impl(std::declval<BasicJsonType>(), detail::identity_tag<Types> {}, detail::priority_tag<PTagValue> {}))... >
using | string_input_adapter_type = decltype(input_adapter(std::declval<std::string>()))
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>>

## Enumerations

enum class | value_t : std::uint8_t { null , object , array , string , boolean , number_integer , number_unsigned , number_float , binary , discarded }
| the JSON type enumeration More...
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 More...
enum class | parse_event_t : std::uint8_t { read , array_end , key , value }
enum class | bjdata_version_t { draft2 , draft3 }
enum class | error_handler_t { strict , replace , ignore }

## Functions

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>
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 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, 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 &&detect_string_can_append_data< OutStringType, Arg >::value, int > = 0>
void | concat_into (OutStringType &out, const Arg &arg, Args &&... rest)
template<typename OutStringType, typename Arg, typename... Args, enable_if_t< detect_string_can_append< OutStringType, Arg >::value, int > = 0>
void | concat_into (OutStringType &out, 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, typename T, std::size_t N1, std::size_t N2>
auto | from_json (const BasicJsonType &j, T(&arr)[N1][N2]) -> decltype(j.template get< T >(), void())
template<typename BasicJsonType, typename T, std::size_t N1, std::size_t N2, std::size_t N3>
auto | from_json (const BasicJsonType &j, T(&arr)[N1][N2][N3]) -> decltype(j.template get< T >(), void())
template<typename BasicJsonType, typename T, std::size_t N1, std::size_t N2, std::size_t N3, std::size_t N4>
auto | from_json (const BasicJsonType &j, T(&arr)[N1][N2][N3][N4]) -> 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 Type>
detail::uncvref_t< Type > | from_json_tuple_get_impl (BasicJsonType &&j, detail::identity_tag< Type >, detail::priority_tag< 0 >)
template<typename BasicJsonType, typename Type, detail::enable_if_t< detail::is_compatible_reference_type< BasicJsonType, Type >::value, int > = 0>
Type | from_json_tuple_get_impl (BasicJsonType &&j, detail::identity_tag< Type >, detail::priority_tag< 1 >)
template<typename BasicJsonType, typename Type, detail::enable_if_t< std::is_arithmetic< uncvref_t< Type > >::value, int > = 0>
detail::uncvref_t< Type > | from_json_tuple_get_impl (BasicJsonType &&j, detail::identity_tag< Type >, detail::priority_tag< 2 >)
template<std::size_t PTagValue, typename... Args, typename BasicJsonType, std::size_t... Idx>
tuple_type< PTagValue, BasicJsonType, Args... > | from_json_tuple_impl_base (BasicJsonType &&j, index_sequence< Idx... >)
template<std::size_t PTagValue, typename BasicJsonType>
std::tuple | from_json_tuple_impl_base (BasicJsonType &, index_sequence<>)
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 StringType>
void | int_to_string (StringType &target, std::size_t value)
template<typename StringType>
StringType | to_string (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<std::size_t N, typename IteratorType, enable_if_t< N==1, int > = 0>
auto | get (const nlohmann::detail::iteration_proxy_value< IteratorType > &i) -> decltype(i.value())
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... >)
template<typename BasicJsonType, typename Tuple>
void | to_json_tuple_impl (BasicJsonType &j, const Tuple &, index_sequence<>)
template<typename BasicJsonType, typename T, enable_if_t< is_constructible_tuple< BasicJsonType, T >::value, int > = 0>
void | to_json (BasicJsonType &j, const T &t)
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))
constexpr std::size_t | unknown_size ()
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).

## Variables

template<typename T>
constexpr T | static_const< T >::value
template<typename BasicJsonType, typename InputAdapterType, typename SAX>
constexpr std::size_t | binary_reader< BasicJsonType, InputAdapterType, SAX >::npos

## 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

## binary_function_t

template<typename T, typename Binary>

using detail::binary_function_t

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

## boolean_function_t

template<typename T>

using detail::boolean_function_t

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

## has_erase_with_key_type

template<typename BasicJsonType, typename KeyType>

using detail::has_erase_with_key_type

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

## is_detected_convertible

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

using detail::is_detected_convertible

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

## 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

Initial value:
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
detail::is_json_iterator_of
Definition json.hpp:4078

## 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

Initial value:
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
detail::is_comparable
Definition json.hpp:4108

## json_base_class

template<class T>

using detail::json_base_class

Initial value:
typename std::conditional <
std::is_same<T, void>::value,
json_default_base,
T
>::type
detail::json_default_base
Default base class of the basic_json class.
Definition json.hpp:13763

## key_function_t

template<typename T, typename String>

using detail::key_function_t

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

## never_out_of_range

template<typename OfType, typename T>

using detail::never_out_of_range

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

## number_float_function_t

template<typename T, typename Float, typename String>

using detail::number_float_function_t

Initial value:
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

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

## number_unsigned_function_t

template<typename T, typename Unsigned>

using detail::number_unsigned_function_t

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

## parse_error_function_t

template<typename T, typename Exception>

using detail::parse_error_function_t

Initial value:
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

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

## same_sign

template<typename... Types>

using detail::same_sign

Initial value:
std::integral_constant < bool,
all_signed<Types...>::value || all_unsigned<Types...>::value >

## start_array_function_t

template<typename T>

using detail::start_array_function_t

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

## start_object_function_t

template<typename T>

using detail::start_object_function_t

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

## string_function_t

template<typename T, typename String>

using detail::string_function_t

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

## Enumeration Type Documentation

## cbor_tag_handler_t

enum class detail::cbor_tag_handler_t

strong

how to treat CBOR tags

Enumerator
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

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

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

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

## Function Documentation

## escape()

template<typename StringType>

StringType detail::escape | ( | StringType | s | ) |

inline

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

Parameters

  [in] | s | string to escape

Returns
  escaped string

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

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

Template Parameters

  BasicJsonType | basic_json specialization

Parameters

  j | JSON value to hash

Returns
  hash value of j

## little_endianness()

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

inlinenoexcept

determine system byte order

Returns
  true if and only if system's byte order is little endian

Note
  from https://stackoverflow.com/a/1001328/266378

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

Since
  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

Parameters

  [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

Precondition
  The search string f must not be empty. This precondition is enforced with an assertion.

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

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.

## unescape()

template<typename StringType>

void detail::unescape | ( | StringType & | s | ) |

inline

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

Parameters

  [in] | s | string to unescape

Returns
  unescaped string

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