Arkanjo 0.1
A tool for find code duplicated functions in codebases
Loading...
Searching...
No Matches
detail Namespace Reference

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
 

Classes

struct  actual_object_comparator
 
class  binary_reader
 deserialization of CBOR, MessagePack, and UBJSON values More...
 
class  binary_writer
 serialization to CBOR and MessagePack values More...
 
struct  char_traits
 
struct  char_traits< signed char >
 
struct  char_traits< unsigned char >
 
struct  conjunction
 
struct  conjunction< B >
 
struct  conjunction< B, Bn... >
 
struct  detector
 
struct  detector< Default, void_t< Op< Args... > >, Op, Args... >
 
class  exception
 general exception of the basic_json class More...
 
struct  external_constructor
 
struct  external_constructor< value_t::array >
 
struct  external_constructor< value_t::binary >
 
struct  external_constructor< value_t::boolean >
 
struct  external_constructor< value_t::number_float >
 
struct  external_constructor< value_t::number_integer >
 
struct  external_constructor< value_t::number_unsigned >
 
struct  external_constructor< value_t::object >
 
struct  external_constructor< value_t::string >
 
class  file_input_adapter
 
struct  from_json_fn
 
struct  has_from_json
 
struct  has_from_json< BasicJsonType, T, enable_if_t< !is_basic_json< T >::value > >
 
struct  has_key_compare
 
struct  has_non_default_from_json
 
struct  has_non_default_from_json< BasicJsonType, T, enable_if_t< !is_basic_json< T >::value > >
 
struct  has_to_json
 
struct  has_to_json< BasicJsonType, T, enable_if_t< !is_basic_json< T >::value > >
 
struct  identity_tag
 
class  input_stream_adapter
 
struct  integer_sequence
 
struct  internal_iterator
 an iterator value More...
 
class  invalid_iterator
 exception indicating errors with iterators More...
 
struct  is_basic_json
 
struct  is_basic_json< NLOHMANN_BASIC_JSON_TPL >
 
struct  is_basic_json_context
 
struct  is_c_string
 
struct  is_comparable
 
struct  is_comparable< Compare, A, B, void_t< decltype(std::declval< Compare >()(std::declval< A >(), std::declval< B >())), decltype(std::declval< Compare >()(std::declval< B >(), std::declval< A >()))> >
 
struct  is_compatible_array_type
 
struct  is_compatible_array_type_impl
 
struct  is_compatible_array_type_impl< BasicJsonType, CompatibleArrayType, enable_if_t< is_detected< iterator_t, CompatibleArrayType >::value &&is_iterator_traits< iterator_traits< detected_t< iterator_t, CompatibleArrayType > > >::value &&!std::is_same< CompatibleArrayType, detected_t< range_value_t, CompatibleArrayType > >::value > >
 
struct  is_compatible_integer_type
 
struct  is_compatible_integer_type_impl
 
struct  is_compatible_integer_type_impl< RealIntegerType, CompatibleNumberIntegerType, enable_if_t< std::is_integral< RealIntegerType >::value &&std::is_integral< CompatibleNumberIntegerType >::value &&!std::is_same< bool, CompatibleNumberIntegerType >::value > >
 
struct  is_compatible_object_type
 
struct  is_compatible_object_type_impl
 
struct  is_compatible_object_type_impl< BasicJsonType, CompatibleObjectType, enable_if_t< is_detected< mapped_type_t, CompatibleObjectType >::value &&is_detected< key_type_t, CompatibleObjectType >::value > >
 
struct  is_compatible_string_type
 
struct  is_compatible_type
 
struct  is_compatible_type_impl
 
struct  is_compatible_type_impl< BasicJsonType, CompatibleType, enable_if_t< is_complete_type< CompatibleType >::value > >
 
struct  is_complete_type
 
struct  is_complete_type< T, decltype(void(sizeof(T)))>
 
struct  is_constructible
 
struct  is_constructible< const std::pair< T1, T2 > >
 
struct  is_constructible< const std::tuple< Ts... > >
 
struct  is_constructible< std::pair< T1, T2 > >
 
struct  is_constructible< std::tuple< Ts... > >
 
struct  is_constructible_array_type
 
struct  is_constructible_array_type_impl
 
struct  is_constructible_array_type_impl< BasicJsonType, ConstructibleArrayType, enable_if_t< !std::is_same< ConstructibleArrayType, typename BasicJsonType::value_type >::value &&!is_compatible_string_type< BasicJsonType, ConstructibleArrayType >::value &&is_default_constructible< ConstructibleArrayType >::value &&(std::is_move_assignable< ConstructibleArrayType >::value||std::is_copy_assignable< ConstructibleArrayType >::value)&&is_detected< iterator_t, ConstructibleArrayType >::value &&is_iterator_traits< iterator_traits< detected_t< iterator_t, ConstructibleArrayType > > >::value &&is_detected< range_value_t, ConstructibleArrayType >::value &&!std::is_same< ConstructibleArrayType, detected_t< range_value_t, ConstructibleArrayType > >::value &&is_complete_type< detected_t< range_value_t, ConstructibleArrayType > >::value > >
 
struct  is_constructible_array_type_impl< BasicJsonType, ConstructibleArrayType, enable_if_t< std::is_same< ConstructibleArrayType, typename BasicJsonType::value_type >::value > >
 
struct  is_constructible_object_type
 
struct  is_constructible_object_type_impl
 
struct  is_constructible_object_type_impl< BasicJsonType, ConstructibleObjectType, enable_if_t< is_detected< mapped_type_t, ConstructibleObjectType >::value &&is_detected< key_type_t, ConstructibleObjectType >::value > >
 
struct  is_constructible_string_type
 
struct  is_constructible_tuple
 
struct  is_constructible_tuple< T1, std::tuple< Args... > >
 
struct  is_default_constructible
 
struct  is_default_constructible< const std::pair< T1, T2 > >
 
struct  is_default_constructible< const std::tuple< Ts... > >
 
struct  is_default_constructible< std::pair< T1, T2 > >
 
struct  is_default_constructible< std::tuple< Ts... > >
 
struct  is_detected_lazy
 
struct  is_getable
 
struct  is_iterator_of_multibyte
 
struct  is_iterator_traits
 
struct  is_iterator_traits< iterator_traits< T > >
 
struct  is_json_iterator_of
 
struct  is_json_iterator_of< BasicJsonType, typename BasicJsonType::const_iterator >
 
struct  is_json_iterator_of< BasicJsonType, typename BasicJsonType::iterator >
 
struct  is_json_ref
 
struct  is_json_ref< json_ref< T > >
 
struct  is_ordered_map
 
struct  is_range
 
struct  is_sax
 
struct  is_sax_static_asserts
 
struct  is_specialization_of
 
struct  is_specialization_of< Primary, Primary< Args... > >
 
struct  is_transparent
 
class  iter_impl
 a template for a bidirectional iterator for the basic_json class This class implements a both iterators (iterator and const_iterator) for the basic_json class. More...
 
class  iteration_proxy
 proxy class for the items() function More...
 
class  iteration_proxy_value
 
class  iterator_input_adapter
 
struct  iterator_input_adapter_factory
 
struct  iterator_input_adapter_factory< IteratorType, enable_if_t< is_iterator_of_multibyte< IteratorType >::value > >
 
struct  iterator_traits
 
struct  iterator_traits< T *, enable_if_t< std::is_object< T >::value > >
 
struct  iterator_traits< T, enable_if_t< !std::is_pointer< T >::value > >
 
struct  iterator_types
 
struct  iterator_types< It, void_t< typename It::difference_type, typename It::value_type, typename It::pointer, typename It::reference, typename It::iterator_category > >
 
struct  json_default_base
 Default base class of the basic_json class. More...
 
class  json_ref
 
class  json_reverse_iterator
 a template for a reverse iterator class More...
 
class  json_sax_acceptor
 
class  json_sax_dom_callback_parser
 
class  json_sax_dom_parser
 SAX implementation to create a JSON value from SAX events. More...
 
class  lexer
 lexical analysis More...
 
class  lexer_base
 
struct  make_void
 
struct  negation
 
struct  nonesuch
 
class  other_error
 exception indicating other library errors More...
 
class  out_of_range
 exception indicating access out of the defined range More...
 
class  output_adapter
 
struct  output_adapter_protocol
 abstract output adapter interface More...
 
class  output_stream_adapter
 output adapter for output streams More...
 
class  output_string_adapter
 output adapter for basic_string More...
 
class  output_vector_adapter
 output adapter for byte vectors More...
 
class  parse_error
 exception indicating a parse error More...
 
class  parser
 syntax analysis More...
 
struct  position_t
 struct to capture the start position of the current token More...
 
class  primitive_iterator_t
 
struct  priority_tag
 
struct  priority_tag< 0 >
 
class  serializer
 
class  span_input_adapter
 
struct  static_const
 
struct  to_json_fn
 
class  type_error
 exception indicating executing a member function with a wrong type More...
 
struct  value_in_range_of_impl1
 
struct  value_in_range_of_impl1< OfType, T, false >
 
struct  value_in_range_of_impl1< OfType, T, true >
 
struct  value_in_range_of_impl2
 
struct  value_in_range_of_impl2< OfType, T, false, false >
 
struct  value_in_range_of_impl2< OfType, T, false, true >
 
struct  value_in_range_of_impl2< OfType, T, true, false >
 
struct  value_in_range_of_impl2< OfType, T, true, true >
 
class  wide_string_input_adapter
 
struct  wide_string_input_helper
 
struct  wide_string_input_helper< BaseInputAdapter, 2 >
 
struct  wide_string_input_helper< BaseInputAdapter, 4 >
 

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>
 
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>>
 a type to simplify interfaces
 

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 More...
 
enum class  cbor_tag_handler_t { error , ignore , store }
 how to treat CBOR tags More...
 
enum class  parse_event_t : std::uint8_t {
  object_start , object_end , array_start , array_end ,
  key , value
}
 
enum class  bjdata_version_t { draft2 , draft3 }
 how to encode BJData 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 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>
conditional_static_cast (U value)
 
template<typename OfType , typename T >
constexpr bool value_in_range_of (T val)
 
std::size_t concat_length ()
 
template<typename... Args>
std::size_t concat_length (const char *cstr, const Args &... rest)
 
template<typename StringType , typename... Args>
std::size_t concat_length (const StringType &str, const Args &... rest)
 
template<typename... Args>
std::size_t concat_length (const char, const Args &... rest)
 
template<typename OutStringType >
void concat_into (OutStringType &)
 
template<typename OutStringType , typename Arg , typename... Args, enable_if_t< !detect_string_can_append< OutStringType, Arg >::value &&detect_string_can_append_op< OutStringType, Arg >::value, int > = 0>
void concat_into (OutStringType &out, Arg &&arg, Args &&... rest)
 
template<typename OutStringType , typename Arg , typename... Args, enable_if_t< !detect_string_can_append< OutStringType, Arg >::value &&!detect_string_can_append_op< OutStringType, Arg >::value &&detect_string_can_append_iter< OutStringType, Arg >::value, int > = 0>
void concat_into (OutStringType &out, const Arg &arg, Args &&... rest)
 
template<typename OutStringType = std::string, typename... Args>
OutStringType concat (Args &&... args)
 
template<typename BasicJsonType >
void from_json (const BasicJsonType &j, typename std::nullptr_t &n)
 
template<typename BasicJsonType , typename ArithmeticType , enable_if_t< std::is_arithmetic< ArithmeticType >::value &&!std::is_same< ArithmeticType, typename BasicJsonType::boolean_t >::value, int > = 0>
void get_arithmetic_value (const BasicJsonType &j, ArithmeticType &val)
 
template<typename BasicJsonType >
void from_json (const BasicJsonType &j, typename BasicJsonType::boolean_t &b)
 
template<typename BasicJsonType >
void from_json (const BasicJsonType &j, typename BasicJsonType::string_t &s)
 
template<typename BasicJsonType , typename StringType , enable_if_t< std::is_assignable< StringType &, const typename BasicJsonType::string_t >::value &&is_detected_exact< typename BasicJsonType::string_t::value_type, value_type_t, StringType >::value &&!std::is_same< typename BasicJsonType::string_t, StringType >::value &&!is_json_ref< StringType >::value, int > = 0>
void from_json (const BasicJsonType &j, StringType &s)
 
template<typename BasicJsonType >
void from_json (const BasicJsonType &j, typename BasicJsonType::number_float_t &val)
 
template<typename BasicJsonType >
void from_json (const BasicJsonType &j, typename BasicJsonType::number_unsigned_t &val)
 
template<typename BasicJsonType >
void from_json (const BasicJsonType &j, typename BasicJsonType::number_integer_t &val)
 
template<typename BasicJsonType , typename EnumType , enable_if_t< std::is_enum< EnumType >::value, int > = 0>
void from_json (const BasicJsonType &j, EnumType &e)
 
template<typename BasicJsonType , typename T , typename Allocator , enable_if_t< is_getable< BasicJsonType, T >::value, int > = 0>
void from_json (const BasicJsonType &j, std::forward_list< T, Allocator > &l)
 
template<typename BasicJsonType , typename T , enable_if_t< is_getable< BasicJsonType, T >::value, int > = 0>
void from_json (const BasicJsonType &j, std::valarray< T > &l)
 
template<typename BasicJsonType , typename T , std::size_t N>
auto from_json (const BasicJsonType &j, T(&arr)[N]) -> decltype(j.template get< T >(), void())
 
template<typename BasicJsonType , 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... Args, std::size_t... Idx>
std::tuple< Args... > from_json_tuple_impl_base (BasicJsonType &&j, index_sequence< Idx... >)
 
template<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<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<>)
 
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).
 

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

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

Definition at line 3728 of file json.hpp.

◆ all_integral

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

Definition at line 4218 of file json.hpp.

◆ all_signed

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

Definition at line 4221 of file json.hpp.

◆ all_unsigned

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

Definition at line 4224 of file json.hpp.

◆ binary_function_t

template<typename T , typename Binary >
using detail::binary_function_t
Initial value:
decltype(std::declval<T&>().binary(std::declval<Binary&>()))

Definition at line 9737 of file json.hpp.

◆ bool_constant

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

Definition at line 4312 of file json.hpp.

◆ boolean_function_t

template<typename T >
using detail::boolean_function_t
Initial value:
decltype(std::declval<T&>().boolean(std::declval<bool>()))

Definition at line 9717 of file json.hpp.

◆ contiguous_bytes_input_adapter

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

Definition at line 6983 of file json.hpp.

◆ detect_erase_with_key_type

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

Definition at line 4175 of file json.hpp.

◆ detect_is_transparent

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

Definition at line 4142 of file json.hpp.

◆ detect_key_compare

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

Definition at line 3712 of file json.hpp.

◆ detect_string_can_append

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

Definition at line 4428 of file json.hpp.

◆ detect_string_can_append_data

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

Definition at line 4446 of file json.hpp.

◆ detect_string_can_append_iter

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

Definition at line 4440 of file json.hpp.

◆ detect_string_can_append_op

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

Definition at line 4434 of file json.hpp.

◆ detected_or

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

Definition at line 314 of file json.hpp.

◆ detected_or_t

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

Definition at line 317 of file json.hpp.

◆ detected_t

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

Definition at line 311 of file json.hpp.

◆ difference_type_t

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

Definition at line 3637 of file json.hpp.

◆ enable_if_t

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

Definition at line 3225 of file json.hpp.

◆ end_array_function_t

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

Definition at line 9756 of file json.hpp.

◆ end_object_function_t

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

Definition at line 9749 of file json.hpp.

◆ from_json_function

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

Definition at line 3652 of file json.hpp.

◆ get_template_function

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

Definition at line 3655 of file json.hpp.

◆ has_erase_with_key_type

template<typename BasicJsonType , typename KeyType >
using detail::has_erase_with_key_type
Initial value:
typename std::conditional <
is_detected <
typename BasicJsonType::object_t, KeyType >::value,
std::true_type,
std::false_type >::type
decltype(std::declval< ObjectType & >().erase(std::declval< KeyType >())) detect_erase_with_key_type
Definition json.hpp:4175

Definition at line 4179 of file json.hpp.

◆ index_sequence

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

Definition at line 3267 of file json.hpp.

◆ index_sequence_for

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

Definition at line 3329 of file json.hpp.

◆ is_c_string_uncvref

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

Definition at line 4340 of file json.hpp.

◆ is_detected

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

Definition at line 305 of file json.hpp.

◆ 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>
typename detector< nonesuch, void, Op, Args... >::type detected_t
Definition json.hpp:311

Definition at line 323 of file json.hpp.

◆ is_detected_exact

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

Definition at line 320 of file json.hpp.

◆ is_json_pointer

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

Definition at line 4129 of file json.hpp.

◆ 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
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 is_usable_as_key_type
Definition json.hpp:4148

Definition at line 4166 of file json.hpp.

◆ 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

Definition at line 4148 of file json.hpp.

◆ iterator_category_t

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

Definition at line 3646 of file json.hpp.

◆ iterator_t

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

Definition at line 3900 of file json.hpp.

◆ 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

Definition at line 14565 of file json.hpp.

◆ key_function_t

template<typename T , typename String >
using detail::key_function_t
Initial value:
decltype(std::declval<T&>().key(std::declval<String&>()))

Definition at line 9745 of file json.hpp.

◆ key_type_t

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

Definition at line 3631 of file json.hpp.

◆ make_index_sequence

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

Definition at line 3321 of file json.hpp.

◆ make_integer_sequence

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

Definition at line 3313 of file json.hpp.

◆ mapped_type_t

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

Definition at line 3628 of file json.hpp.

◆ 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)) >

Definition at line 4232 of file json.hpp.

◆ null_function_t

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

Definition at line 9714 of file json.hpp.

◆ 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&>()))

Definition at line 9729 of file json.hpp.

◆ 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>()))

Definition at line 9721 of file json.hpp.

◆ 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>()))

Definition at line 9725 of file json.hpp.

◆ output_adapter_t

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

a type to simplify interfaces

Definition at line 15735 of file json.hpp.

◆ 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&>()))

Definition at line 9759 of file json.hpp.

◆ parser_callback_t

template<typename BasicJsonType >
using detail::parser_callback_t
Initial value:
std::function<bool(int , parse_event_t , BasicJsonType& )>

Definition at line 12967 of file json.hpp.

◆ pointer_t

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

Definition at line 3640 of file json.hpp.

◆ range_value_t

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

Definition at line 3903 of file json.hpp.

◆ reference_t

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

Definition at line 3643 of file json.hpp.

◆ same_sign

template<typename... Types>
using detail::same_sign
Initial value:
std::integral_constant < bool,
all_signed<Types...>::value || all_unsigned<Types...>::value >
conjunction< std::is_unsigned< Types >... > all_unsigned
Definition json.hpp:4224
conjunction< std::is_signed< Types >... > all_signed
Definition json.hpp:4221

Definition at line 4228 of file json.hpp.

◆ 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>()))

Definition at line 9752 of file json.hpp.

◆ 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>()))

Definition at line 9741 of file json.hpp.

◆ string_can_append

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

Definition at line 4425 of file json.hpp.

◆ string_can_append_data

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

Definition at line 4443 of file json.hpp.

◆ string_can_append_iter

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

Definition at line 4437 of file json.hpp.

◆ string_can_append_op

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

Definition at line 4431 of file json.hpp.

◆ string_function_t

template<typename T , typename String >
using detail::string_function_t
Initial value:
decltype(std::declval<T&>().string(std::declval<String&>()))

Definition at line 9733 of file json.hpp.

◆ string_input_adapter_type

using detail::string_input_adapter_type = decltype(input_adapter(std::declval<std::string>()))

Definition at line 6959 of file json.hpp.

◆ to_json_function

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

Definition at line 3649 of file json.hpp.

◆ uncvref_t

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

Definition at line 3211 of file json.hpp.

◆ value_type_t

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

Definition at line 3634 of file json.hpp.

◆ void_t

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

Definition at line 266 of file json.hpp.

Enumeration Type Documentation

◆ bjdata_version_t

enum class detail::bjdata_version_t
strong

how to encode BJData

Enumerator
draft2 
draft3 

Definition at line 15847 of file json.hpp.

◆ 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

Definition at line 9863 of file json.hpp.

◆ error_handler_t

enum class 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 18852 of file json.hpp.

◆ input_format_t

enum class detail::input_format_t
strong

the supported input formats

Enumerator
json 
cbor 
msgpack 
ubjson 
bson 
bjdata 

Definition at line 6529 of file json.hpp.

◆ parse_event_t

enum class detail::parse_event_t : std::uint8_t
strong
Enumerator
object_start 

the parser read { and started to process a JSON object

object_end 

the parser read } and finished processing a JSON object

array_start 

the parser read [ and started to process a JSON array

array_end 

the parser read ] and finished processing a JSON array

key 

the parser read a key of a value in an object

value 

the parser finished reading a JSON value

Definition at line 12950 of file json.hpp.

◆ 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

Definition at line 3002 of file json.hpp.

Function Documentation

◆ combine()

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

Definition at line 6352 of file json.hpp.

◆ concat()

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

Definition at line 4505 of file json.hpp.

◆ concat_into() [1/3]

template<typename OutStringType >
void detail::concat_into ( OutStringType & )

Definition at line 4421 of file json.hpp.

◆ concat_into() [2/3]

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

Definition at line 4468 of file json.hpp.

◆ concat_into() [3/3]

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

Definition at line 4487 of file json.hpp.

◆ concat_length() [1/4]

std::size_t detail::concat_length ( )

Definition at line 4390 of file json.hpp.

◆ concat_length() [2/4]

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

Definition at line 4408 of file json.hpp.

◆ concat_length() [3/4]

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

Definition at line 4402 of file json.hpp.

◆ concat_length() [4/4]

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

Definition at line 4415 of file json.hpp.

◆ conditional_static_cast()

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

Definition at line 4206 of file json.hpp.

◆ escape()

template<typename StringType >
StringType detail::escape ( StringType s)

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

Parameters
[in]sstring to escape
Returns
escaped string

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

Definition at line 3120 of file json.hpp.

◆ from_json() [1/22]

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

Definition at line 5173 of file json.hpp.

◆ from_json() [2/22]

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

Definition at line 5303 of file json.hpp.

◆ from_json() [3/22]

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

Definition at line 5229 of file json.hpp.

◆ from_json() [4/22]

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

Definition at line 5152 of file json.hpp.

◆ from_json() [5/22]

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

Definition at line 5197 of file json.hpp.

◆ from_json() [6/22]

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

Definition at line 4982 of file json.hpp.

◆ from_json() [7/22]

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

Definition at line 4993 of file json.hpp.

◆ from_json() [8/22]

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

Definition at line 5317 of file json.hpp.

◆ from_json() [9/22]

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

Definition at line 5337 of file json.hpp.

◆ from_json() [10/22]

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

Definition at line 5010 of file json.hpp.

◆ from_json() [11/22]

template<typename BasicJsonType , typename StringType , enable_if_t< std::is_assignable< StringType &, const typename BasicJsonType::string_t >::value &&is_detected_exact< typename BasicJsonType::string_t::value_type, value_type_t, StringType >::value &&!std::is_same< typename BasicJsonType::string_t, StringType >::value &&!is_json_ref< StringType >::value, int > = 0>
void detail::from_json ( const BasicJsonType & j,
StringType & s )

Definition at line 4951 of file json.hpp.

◆ from_json() [12/22]

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

Definition at line 5035 of file json.hpp.

◆ from_json() [13/22]

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

Definition at line 5048 of file json.hpp.

◆ from_json() [14/22]

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

Definition at line 5064 of file json.hpp.

◆ from_json() [15/22]

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

Definition at line 5025 of file json.hpp.

◆ from_json() [16/22]

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

Definition at line 5185 of file json.hpp.

◆ from_json() [17/22]

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

Definition at line 4925 of file json.hpp.

◆ from_json() [18/22]

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

Definition at line 4962 of file json.hpp.

◆ from_json() [19/22]

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

Definition at line 4974 of file json.hpp.

◆ from_json() [20/22]

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

Definition at line 4968 of file json.hpp.

◆ from_json() [21/22]

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

Definition at line 4935 of file json.hpp.

◆ from_json() [22/22]

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

Definition at line 4863 of file json.hpp.

◆ from_json_array_impl() [1/4]

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

Definition at line 5127 of file json.hpp.

◆ from_json_array_impl() [2/4]

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

Definition at line 5103 of file json.hpp.

◆ from_json_array_impl() [3/4]

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

Definition at line 5089 of file json.hpp.

◆ from_json_array_impl() [4/4]

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

Definition at line 5083 of file json.hpp.

◆ from_json_inplace_array_impl()

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

Definition at line 5166 of file json.hpp.

◆ from_json_tuple_impl() [1/4]

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

Definition at line 5278 of file json.hpp.

◆ from_json_tuple_impl() [2/4]

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

Definition at line 5291 of file json.hpp.

◆ from_json_tuple_impl() [3/4]

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

Definition at line 5285 of file json.hpp.

◆ from_json_tuple_impl() [4/4]

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

Definition at line 5297 of file json.hpp.

◆ from_json_tuple_impl_base() [1/2]

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

Definition at line 5266 of file json.hpp.

◆ from_json_tuple_impl_base() [2/2]

template<typename BasicJsonType >
std::tuple detail::from_json_tuple_impl_base ( BasicJsonType & ,
index_sequence<>  )

Definition at line 5272 of file json.hpp.

◆ get()

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

Definition at line 5657 of file json.hpp.

◆ get_arithmetic_value()

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

Definition at line 4892 of file json.hpp.

◆ 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
BasicJsonTypebasic_json specialization
Parameters
jJSON value to hash
Returns
hash value of j

Definition at line 6370 of file json.hpp.

◆ input_adapter() [1/7]

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

Definition at line 6993 of file json.hpp.

◆ input_adapter() [2/7]

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

Definition at line 6953 of file json.hpp.

◆ input_adapter() [3/7]

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

Definition at line 6919 of file json.hpp.

◆ input_adapter() [4/7]

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

Definition at line 6963 of file json.hpp.

◆ input_adapter() [5/7]

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

Definition at line 6977 of file json.hpp.

◆ input_adapter() [6/7]

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

Definition at line 6972 of file json.hpp.

◆ input_adapter() [7/7]

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

Definition at line 7005 of file json.hpp.

◆ int_to_string()

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

Definition at line 5475 of file json.hpp.

◆ little_endianness()

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

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

Definition at line 9877 of file json.hpp.

◆ make_array()

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

Definition at line 3352 of file json.hpp.

◆ operator<()

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

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

Definition at line 3032 of file json.hpp.

◆ replace_substring()

template<typename StringType >
void detail::replace_substring ( StringType & s,
const StringType & f,
const StringType & t )

replace all occurrences of a substring by another string

Parameters
[in,out]sthe string to manipulate; changed so that all occurrences of f are replaced with t
[in]fthe substring to replace with t
[in]tthe 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

Definition at line 3101 of file json.hpp.

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

Definition at line 18773 of file json.hpp.

◆ to_json() [1/18]

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

Definition at line 6018 of file json.hpp.

◆ to_json() [2/18]

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

Definition at line 6011 of file json.hpp.

◆ to_json() [3/18]

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

Definition at line 5984 of file json.hpp.

◆ to_json() [4/18]

template<typename BasicJsonType , typename CompatibleArrayType , enable_if_t< is_compatible_array_type< BasicJsonType, CompatibleArrayType >::value &&!is_compatible_object_type< BasicJsonType, CompatibleArrayType >::value &&!is_compatible_string_type< BasicJsonType, CompatibleArrayType >::value &&!std::is_same< typename BasicJsonType::binary_t, CompatibleArrayType >::value &&!is_basic_json< CompatibleArrayType >::value, int > = 0>
void detail::to_json ( BasicJsonType & j,
const CompatibleArrayType & arr )

Definition at line 6048 of file json.hpp.

◆ to_json() [5/18]

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

Definition at line 6074 of file json.hpp.

◆ to_json() [6/18]

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

Definition at line 5991 of file json.hpp.

◆ to_json() [7/18]

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

Definition at line 6096 of file json.hpp.

◆ to_json() [8/18]

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

Definition at line 6061 of file json.hpp.

◆ to_json() [9/18]

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

Definition at line 6035 of file json.hpp.

◆ to_json() [10/18]

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

Definition at line 6104 of file json.hpp.

◆ to_json() [11/18]

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

Definition at line 6090 of file json.hpp.

◆ to_json() [12/18]

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

Definition at line 6054 of file json.hpp.

◆ to_json() [13/18]

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

Definition at line 6026 of file json.hpp.

◆ to_json() [14/18]

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

Definition at line 6004 of file json.hpp.

◆ to_json() [15/18]

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

Definition at line 5971 of file json.hpp.

◆ to_json() [16/18]

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

Definition at line 6067 of file json.hpp.

◆ to_json() [17/18]

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

Definition at line 6080 of file json.hpp.

◆ to_json() [18/18]

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

Definition at line 5997 of file json.hpp.

◆ to_json_tuple_impl() [1/2]

template<typename BasicJsonType , typename Tuple >
void detail::to_json_tuple_impl ( BasicJsonType & j,
const Tuple & ,
index_sequence<>  )

Definition at line 6116 of file json.hpp.

◆ to_json_tuple_impl() [2/2]

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

Definition at line 6110 of file json.hpp.

◆ to_string()

template<typename StringType >
StringType detail::to_string ( std::size_t value)

Definition at line 5483 of file json.hpp.

◆ unescape()

template<typename StringType >
void detail::unescape ( StringType & s)

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

Parameters
[in]sstring to unescape
Returns
unescaped string

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

Definition at line 3135 of file json.hpp.

◆ unknown_size()

std::size_t detail::unknown_size ( )
constexpr

Definition at line 8843 of file json.hpp.

◆ value_in_range_of()

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

Definition at line 4306 of file json.hpp.