Template
|
detail namespace with internal helper functions More...
Namespaces | |
namespace | container_input_adapter_factory_impl |
namespace | dtoa_impl |
implements the Grisu2 algorithm for binary to decimal floating-point conversion. | |
namespace | impl |
namespace | utility_internal |
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 = std::is_convertible< detected_t< Op, Args... >, To > |
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 = 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 |
template<typename BasicJsonType , typename KeyTypeCVRef , bool RequireTransparentComparator = true, bool ExcludeObjectKeyType = RequireTransparentComparator, typename KeyType = uncvref_t<KeyTypeCVRef>> | |
using | is_usable_as_basic_json_key_type = typename std::conditional< is_usable_as_key_type< typename BasicJsonType::object_comparator_t, typename BasicJsonType::object_t::key_type, KeyTypeCVRef, RequireTransparentComparator, ExcludeObjectKeyType >::value &&!is_json_iterator_of< BasicJsonType, KeyType >::value, std::true_type, std::false_type >::type |
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 = typename std::conditional< is_detected< detect_erase_with_key_type, typename BasicJsonType::object_t, KeyType >::value, std::true_type, std::false_type >::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 = std::integral_constant< bool, all_signed< Types... >::value||all_unsigned< Types... >::value > |
template<typename OfType , typename T > | |
using | never_out_of_range = std::integral_constant< bool,(std::is_signed< OfType >::value &&(sizeof(T)< sizeof(OfType)))||(same_sign< OfType, T >::value &&sizeof(OfType)==sizeof(T)) > |
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<class T > | |
using | json_base_class = typename std::conditional< std::is_same< T, void >::value, json_default_base, T >::type |
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 | cbor_tag_handler_t { error , ignore , store } |
how to treat CBOR tags More... | |
enum class | error_handler_t { strict , replace , ignore } |
how to treat decoding errors More... | |
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 T , typename... Args> | |
constexpr std::array< T, sizeof...(Args)> | make_array (Args &&... args) |
template<typename T , typename U , enable_if_t< !std::is_same< T, U >::value, int > = 0> | |
T | conditional_static_cast (U value) |
template<typename OfType , typename T > | |
constexpr bool | value_in_range_of (T val) |
std::size_t | concat_length () |
template<typename... Args> | |
std::size_t | concat_length (const char *cstr, const Args &... rest) |
template<typename StringType , typename... Args> | |
std::size_t | concat_length (const StringType &str, const Args &... rest) |
template<typename... Args> | |
std::size_t | concat_length (const char, const Args &... rest) |
template<typename OutStringType > | |
void | concat_into (OutStringType &) |
template<typename OutStringType , typename Arg , typename... Args, enable_if_t< !detect_string_can_append< OutStringType, Arg >::value &&detect_string_can_append_op< OutStringType, Arg >::value, int > = 0> | |
void | concat_into (OutStringType &out, Arg &&arg, Args &&... rest) |
template<typename OutStringType , typename Arg , typename... Args, enable_if_t< !detect_string_can_append< OutStringType, Arg >::value &&!detect_string_can_append_op< OutStringType, Arg >::value &&detect_string_can_append_iter< OutStringType, Arg >::value, int > = 0> | |
void | concat_into (OutStringType &out, const Arg &arg, Args &&... rest) |
template<typename OutStringType = std::string, typename... Args> | |
OutStringType | concat (Args &&... args) |
template<typename string_type > | |
void | int_to_string (string_type &target, std::size_t value) |
template<std::size_t N, typename IteratorType , enable_if_t< N==0, int > = 0> | |
auto | get (const nlohmann::detail::iteration_proxy_value< IteratorType > &i) -> decltype(i.key()) |
template<typename BasicJsonType , typename T , enable_if_t< std::is_same< T, typename BasicJsonType::boolean_t >::value, int > = 0> | |
void | to_json (BasicJsonType &j, T b) noexcept |
template<typename BasicJsonType , typename BoolRef , enable_if_t<((std::is_same< std::vector< bool >::reference, BoolRef >::value &&!std::is_same< std::vector< bool >::reference, typename BasicJsonType::boolean_t & >::value)||(std::is_same< std::vector< bool >::const_reference, BoolRef >::value &&!std::is_same< detail::uncvref_t< std::vector< bool >::const_reference >, typename BasicJsonType::boolean_t >::value)) &&std::is_convertible< const BoolRef &, typename BasicJsonType::boolean_t >::value, int > = 0> | |
void | to_json (BasicJsonType &j, const BoolRef &b) noexcept |
template<typename BasicJsonType , typename CompatibleString , enable_if_t< std::is_constructible< typename BasicJsonType::string_t, CompatibleString >::value, int > = 0> | |
void | to_json (BasicJsonType &j, const CompatibleString &s) |
template<typename BasicJsonType > | |
void | to_json (BasicJsonType &j, typename BasicJsonType::string_t &&s) |
template<typename BasicJsonType , typename FloatType , enable_if_t< std::is_floating_point< FloatType >::value, int > = 0> | |
void | to_json (BasicJsonType &j, FloatType val) noexcept |
template<typename BasicJsonType , typename CompatibleNumberUnsignedType , enable_if_t< is_compatible_integer_type< typename BasicJsonType::number_unsigned_t, CompatibleNumberUnsignedType >::value, int > = 0> | |
void | to_json (BasicJsonType &j, CompatibleNumberUnsignedType val) noexcept |
template<typename BasicJsonType , typename CompatibleNumberIntegerType , enable_if_t< is_compatible_integer_type< typename BasicJsonType::number_integer_t, CompatibleNumberIntegerType >::value, int > = 0> | |
void | to_json (BasicJsonType &j, CompatibleNumberIntegerType val) noexcept |
template<typename BasicJsonType , typename EnumType , enable_if_t< std::is_enum< EnumType >::value, int > = 0> | |
void | to_json (BasicJsonType &j, EnumType e) noexcept |
template<typename BasicJsonType > | |
void | to_json (BasicJsonType &j, const std::vector< bool > &e) |
template<typename BasicJsonType , typename CompatibleArrayType , enable_if_t< is_compatible_array_type< BasicJsonType, CompatibleArrayType >::value &&!is_compatible_object_type< BasicJsonType, CompatibleArrayType >::value &&!is_compatible_string_type< BasicJsonType, CompatibleArrayType >::value &&!std::is_same< typename BasicJsonType::binary_t, CompatibleArrayType >::value &&!is_basic_json< CompatibleArrayType >::value, int > = 0> | |
void | to_json (BasicJsonType &j, const CompatibleArrayType &arr) |
template<typename BasicJsonType > | |
void | to_json (BasicJsonType &j, const typename BasicJsonType::binary_t &bin) |
template<typename BasicJsonType , typename T , enable_if_t< std::is_convertible< T, BasicJsonType >::value, int > = 0> | |
void | to_json (BasicJsonType &j, const std::valarray< T > &arr) |
template<typename BasicJsonType > | |
void | to_json (BasicJsonType &j, typename BasicJsonType::array_t &&arr) |
template<typename BasicJsonType , typename CompatibleObjectType , enable_if_t< is_compatible_object_type< BasicJsonType, CompatibleObjectType >::value &&!is_basic_json< CompatibleObjectType >::value, int > = 0> | |
void | to_json (BasicJsonType &j, const CompatibleObjectType &obj) |
template<typename BasicJsonType > | |
void | to_json (BasicJsonType &j, typename BasicJsonType::object_t &&obj) |
template<typename BasicJsonType , typename T , std::size_t N, enable_if_t< !std::is_constructible< typename BasicJsonType::string_t, const T(&)[N]>::value, int > = 0> | |
void | to_json (BasicJsonType &j, const T(&arr)[N]) |
template<typename BasicJsonType , typename T1 , typename T2 , enable_if_t< std::is_constructible< BasicJsonType, T1 >::value &&std::is_constructible< BasicJsonType, T2 >::value, int > = 0> | |
void | to_json (BasicJsonType &j, const std::pair< T1, T2 > &p) |
template<typename BasicJsonType , typename T , enable_if_t< std::is_same< T, iteration_proxy_value< typename BasicJsonType::iterator > >::value, int > = 0> | |
void | to_json (BasicJsonType &j, const T &b) |
template<typename BasicJsonType , typename Tuple , std::size_t... Idx> | |
void | to_json_tuple_impl (BasicJsonType &j, const Tuple &t, index_sequence< Idx... >) |
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
◆ actual_object_comparator_t
using detail::actual_object_comparator_t = typedef typename actual_object_comparator<BasicJsonType>::type |
◆ all_integral
using detail::all_integral = typedef conjunction<std::is_integral<Types>...> |
◆ all_signed
using detail::all_signed = typedef conjunction<std::is_signed<Types>...> |
◆ all_unsigned
using detail::all_unsigned = typedef conjunction<std::is_unsigned<Types>...> |
◆ bool_constant
using detail::bool_constant = typedef std::integral_constant<bool, Value> |
◆ detect_erase_with_key_type
using detail::detect_erase_with_key_type = typedef decltype(std::declval<ObjectType&>().erase(std::declval<KeyType>())) |
◆ detect_is_transparent
using detail::detect_is_transparent = typedef typename T::is_transparent |
◆ detect_key_compare
using detail::detect_key_compare = typedef typename T::key_compare |
◆ detect_string_can_append
using detail::detect_string_can_append = typedef is_detected<string_can_append, StringType, Arg> |
◆ detect_string_can_append_data
using detail::detect_string_can_append_data = typedef is_detected<string_can_append_data, StringType, Arg> |
◆ detect_string_can_append_iter
using detail::detect_string_can_append_iter = typedef is_detected<string_can_append_iter, StringType, Arg> |
◆ detect_string_can_append_op
using detail::detect_string_can_append_op = typedef is_detected<string_can_append_op, StringType, Arg> |
◆ detected_or
using detail::detected_or = typedef detector<Default, void, Op, Args...> |
◆ detected_or_t
using detail::detected_or_t = typedef typename detected_or<Default, Op, Args...>::type |
◆ detected_t
using detail::detected_t = typedef typename detector<nonesuch, void, Op, Args...>::type |
◆ difference_type_t
using detail::difference_type_t = typedef typename T::difference_type |
◆ enable_if_t
using detail::enable_if_t = typedef typename std::enable_if<B, T>::type |
◆ from_json_function
using detail::from_json_function = typedef decltype(T::from_json(std::declval<Args>()...)) |
◆ get_template_function
using detail::get_template_function = typedef decltype(std::declval<T>().template get<U>()) |
◆ has_erase_with_key_type
using detail::has_erase_with_key_type = typedef typename std::conditional < is_detected < detect_erase_with_key_type, typename BasicJsonType::object_t, KeyType >::value, std::true_type, std::false_type >::type |
◆ index_sequence
using detail::index_sequence = typedef integer_sequence<size_t, Ints...> |
◆ index_sequence_for
using detail::index_sequence_for = typedef make_index_sequence<sizeof...(Ts)> |
◆ is_c_string_uncvref
using detail::is_c_string_uncvref = typedef is_c_string<uncvref_t<T> > |
◆ is_detected
using detail::is_detected = typedef typename detector<nonesuch, void, Op, Args...>::value_t |
◆ is_detected_convertible
using detail::is_detected_convertible = typedef std::is_convertible<detected_t<Op, Args...>, To> |
◆ is_detected_exact
using detail::is_detected_exact = typedef std::is_same<Expected, detected_t<Op, Args...> > |
◆ is_json_pointer
using detail::is_json_pointer = typedef is_specialization_of<::nlohmann::json_pointer, uncvref_t<T> > |
◆ is_usable_as_basic_json_key_type
using detail::is_usable_as_basic_json_key_type = typedef typename std::conditional < is_usable_as_key_type<typename BasicJsonType::object_comparator_t, typename BasicJsonType::object_t::key_type, KeyTypeCVRef, RequireTransparentComparator, ExcludeObjectKeyType>::value && !is_json_iterator_of<BasicJsonType, KeyType>::value, std::true_type, std::false_type >::type |
◆ is_usable_as_key_type
using detail::is_usable_as_key_type = typedef typename std::conditional < is_comparable<Comparator, ObjectKeyType, KeyTypeCVRef>::value && !(ExcludeObjectKeyType && std::is_same<KeyType, ObjectKeyType>::value) && (!RequireTransparentComparator || is_detected <detect_is_transparent, Comparator>::value) && !is_json_pointer<KeyType>::value, std::true_type, std::false_type >::type |
◆ iterator_category_t
using detail::iterator_category_t = typedef typename T::iterator_category |
◆ iterator_t
using detail::iterator_t = typedef enable_if_t<is_range<R>::value, result_of_begin<decltype(std::declval<R&>())> > |
◆ json_base_class
using detail::json_base_class = typedef typename std::conditional < std::is_same<T, void>::value, json_default_base, T >::type |
◆ key_type_t
using detail::key_type_t = typedef typename T::key_type |
◆ make_index_sequence
using detail::make_index_sequence = typedef make_integer_sequence<size_t, N> |
◆ make_integer_sequence
using detail::make_integer_sequence = typedef typename utility_internal::Gen<T, N>::type |
◆ mapped_type_t
using detail::mapped_type_t = typedef typename T::mapped_type |
◆ never_out_of_range
using detail::never_out_of_range = typedef std::integral_constant < bool, (std::is_signed<OfType>::value && (sizeof(T) < sizeof(OfType))) || (same_sign<OfType, T>::value && sizeof(OfType) == sizeof(T)) > |
◆ pointer_t
using detail::pointer_t = typedef typename T::pointer |
◆ range_value_t
using detail::range_value_t = typedef value_type_t<iterator_traits<iterator_t<T> >> |
◆ reference_t
using detail::reference_t = typedef typename T::reference |
◆ same_sign
using detail::same_sign = typedef std::integral_constant < bool, all_signed<Types...>::value || all_unsigned<Types...>::value > |
◆ string_can_append
using detail::string_can_append = typedef decltype(std::declval<StringType&>().append(std::declval < Arg && > ())) |
◆ string_can_append_data
using detail::string_can_append_data = typedef decltype(std::declval<StringType&>().append(std::declval<const Arg&>().data(), std::declval<const Arg&>().size())) |
◆ string_can_append_iter
using detail::string_can_append_iter = typedef decltype(std::declval<StringType&>().append(std::declval<const Arg&>().begin(), std::declval<const Arg&>().end())) |
◆ string_can_append_op
using detail::string_can_append_op = typedef decltype(std::declval<StringType&>() += std::declval < Arg && > ()) |
◆ to_json_function
using detail::to_json_function = typedef decltype(T::to_json(std::declval<Args>()...)) |
◆ uncvref_t
using detail::uncvref_t = typedef typename std::remove_cv<typename std::remove_reference<T>::type>::type |
◆ value_type_t
using detail::value_type_t = typedef typename T::value_type |
◆ void_t
using detail::void_t = typedef typename make_void<Ts...>::type |
Enumeration Type Documentation
◆ 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
|
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 |
◆ value_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
Function Documentation
◆ concat()
|
inline |
◆ concat_into() [1/3]
|
inline |
◆ concat_into() [2/3]
|
inline |
◆ concat_into() [3/3]
|
inline |
◆ concat_length() [1/4]
◆ concat_length() [2/4]
|
inline |
◆ concat_length() [3/4]
|
inline |
◆ concat_length() [4/4]
|
inline |
◆ conditional_static_cast()
T detail::conditional_static_cast | ( | U | value | ) |
◆ escape()
|
inline |
◆ get()
auto detail::get | ( | const nlohmann::detail::iteration_proxy_value< IteratorType > & | i | ) | -> decltype(i.key()) |
◆ int_to_string()
void detail::int_to_string | ( | string_type & | target, |
std::size_t | value | ||
) |
◆ make_array()
|
inlineconstexpr |
◆ operator<()
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()
|
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_json() [1/18]
|
inlinenoexcept |
◆ to_json() [2/18]
|
inlinenoexcept |
◆ to_json() [3/18]
|
inlinenoexcept |
◆ to_json() [4/18]
|
inline |
◆ to_json() [5/18]
|
inline |
◆ to_json() [6/18]
|
inline |
◆ to_json() [7/18]
|
inline |
◆ to_json() [8/18]
|
inline |
◆ to_json() [9/18]
|
inline |
◆ to_json() [10/18]
|
inline |
◆ to_json() [11/18]
|
inline |
◆ to_json() [12/18]
|
inline |
◆ to_json() [13/18]
|
inlinenoexcept |
◆ to_json() [14/18]
|
inlinenoexcept |
◆ to_json() [15/18]
|
inlinenoexcept |
◆ to_json() [16/18]
|
inline |
◆ to_json() [17/18]
|
inline |
◆ to_json() [18/18]
|
inline |
◆ to_json_tuple_impl()
|
inline |
◆ value_in_range_of()
Generated by