DAW JSON Link
Namespaces | Classes | Typedefs | Enumerations | Functions | Variables
daw::json::DAW_JSON_VER Namespace Reference

Namespaces

namespace  datetime
 
namespace  details
 
namespace  from_json_conv_details
 
namespace  json_base
 
namespace  json_details
 
namespace  parse_policy_details
 
namespace  parse_utils
 
namespace  utils
 

Classes

struct  basic_json_pair
 
class  basic_json_value
 
struct  basic_json_value_iterator
 
struct  basic_json_value_iterator_range
 
class  basic_stateful_json_value
 
struct  BasicParsePolicy
 
struct  can_single_allocation_string
 
struct  can_single_allocation_string< std::basic_string< Char, CharTrait, Allocator > >
 
struct  constexpr_exec_tag
 
struct  construct_from_iso8601_timestamp
 
struct  construct_from_iso8601_timestamp< JsonNullable::MustExist >
 
class  CppCommentSkippingPolicy
 
struct  default_constructor
 
struct  default_constructor< json_alt< T, I > >
 
struct  default_constructor< std::array< T, Sz > >
 
struct  default_constructor< std::vector< T, Alloc > >
 
struct  default_from_json_converter_t
 
struct  default_to_json_converter_t
 
class  DefaultJsonEventParserStackPolicy
 
class  HashCommentSkippingPolicy
 
struct  ignore_unknown_members
 
struct  is_default_constructor
 
struct  is_default_constructor< default_constructor< T > >
 
struct  is_exact_class_mapping
 
struct  is_pointer_like
 
struct  is_serialization_policy
 
struct  is_serialization_policy< serialization_policy< OutputIterator, PolicyFlags > >
 
struct  is_zero_terminated_string
 
struct  is_zero_terminated_string< std::basic_string< CharT, Traits, Alloc > >
 
struct  json_alt
 
struct  json_array
 
class  json_array_iterator
 
struct  json_array_range
 
struct  json_bool
 
struct  json_class
 
struct  json_class_map
 
struct  json_custom
 
struct  json_data_contract
 
struct  json_data_contract< basic_json_value< ParseState > >
 
struct  json_data_contract< tuple_json_mapping< Members... > >
 
struct  json_date
 
struct  json_intrusive_variant
 
struct  json_key_value
 
struct  json_key_value_array
 
struct  json_member_list
 
struct  json_member_name
 
struct  json_number
 
class  json_path_node
 
struct  json_raw
 
struct  json_sized_array
 
struct  json_string
 
struct  json_string_raw
 
struct  json_submember_tagged_variant
 
struct  json_tagged_variant
 
struct  json_tuple
 Map a tuple like type to a a JSON tuple/heterogeneous array. More...
 
struct  json_tuple_member
 
struct  json_tuple_member_list
 
struct  json_tuple_types_list
 
struct  json_variant
 
struct  json_variant_type_list
 
struct  JsonEventParserStackValue
 
struct  missing_json_data_contract_for
 
struct  NoCommentSkippingPolicy
 
struct  non_discriminated_variant_base_map
 
struct  non_discriminated_variant_base_map< json_variant_type_list< JsonElements... > >
 This ensures that we only map to up to one of each of the basic JSON types(Number, Bool, String, Array, Class) plus being optionally nullable. More...
 
struct  nullable_constructor
 
struct  nullable_constructor< std::optional< T > >
 
struct  nullable_constructor< std::unique_ptr< T, Deleter > >
 
struct  runtime_exec_tag
 
struct  serialization_policy
 
struct  simd_exec_tag
 
struct  tuple_elements_pack
 Allow tuple like types to be used in json_tuple. More...
 
struct  tuple_elements_pack< daw::fwd_pack< Ts... > >
 
struct  tuple_elements_pack< std::tuple< Ts... > >
 
struct  tuple_json_mapping
 

Typedefs

using bool_opts_t = json_details::JsonOptionList< JsonNullable, LiteralAsStringOpt >
 
using class_opts_t = json_details::JsonOptionList< JsonNullable >
 
using ConformancePolicy = BasicParsePolicy< parse_options(AllowEscapedNames::yes, MustVerifyEndOfDataIsValid::yes, IEEE754Precise::yes, ExcludeSpecialEscapes::yes)>
 
using CppCommentSkippingPolicyChecked = BasicParsePolicy< parse_options(PolicyCommentTypes::cpp)>
 
using CppCommentSkippingPolicyUnchecked = BasicParsePolicy< parse_options(CheckedParseMode::no, PolicyCommentTypes::cpp)>
 
using default_exec_tag = constexpr_exec_tag
 
using DefaultParsePolicy = BasicParsePolicy<>
 
template<typename T >
using force_aggregate_construction = std::bool_constant< std::disjunction_v< daw::is_detected< json_details::force_aggregate_construction_test, T >, daw::is_detected< json_details::force_aggregate_construction_test2, T > > >
 
using HashCommentSkippingPolicyChecked = BasicParsePolicy< parse_options(PolicyCommentTypes::hash)>
 
using HashCommentSkippingPolicyUnchecked = BasicParsePolicy< parse_options(CheckedParseMode::no, PolicyCommentTypes::hash)>
 
template<typename... Ts>
using is_empty_pack = std::bool_constant<(sizeof...(Ts)==0)>
 
template<typename JsonElement , typename Container = json_deduce_type, typename Constructor = json_deduce_type, JsonNullable Nullable = JsonNullable::MustExist>
using json_array_no_name = json_base::json_array< JsonElement, Container, Constructor, Nullable >
 
template<JSONNAMETYPE Name, typename JsonElement , typename Container = json_deduce_type, typename Constructor = json_deduce_type>
using json_array_null = json_array< Name, JsonElement, Container, Constructor, JsonNullDefault >
 
template<typename JsonElement , typename Container = json_deduce_type, typename Constructor = json_deduce_type>
using json_array_null_no_name = json_base::json_array< JsonElement, Container, Constructor, JsonNullDefault >
 
template<typename T = bool, json_details::json_options_t Options = bool_opts_def, typename Constructor = default_constructor<T>>
using json_bool_no_name = json_base::json_bool< T, Options, Constructor >
 
template<JSONNAMETYPE Name, typename T = std::optional<bool>, json_details::json_options_t Options = bool_opts_def, typename Constructor = default_constructor<T>>
using json_bool_null = json_bool< Name, T, json_details::bool_opts_set< Options, JsonNullDefault >, Constructor >
 
template<typename T = std::optional<bool>, json_details::json_options_t Options = bool_opts_def, typename Constructor = nullable_constructor<T>>
using json_bool_null_no_name = json_base::json_bool< T, json_details::bool_opts_set< Options, JsonNullDefault >, Constructor >
 
template<JSONNAMETYPE Name, typename T = double, json_details::json_options_t Options = number_opts_def, typename Constructor = default_constructor<T>>
using json_checked_number = json_number< Name, T, json_details::number_opts_set< Options, JsonRangeCheck::CheckForNarrowing >, Constructor >
 
template<typename T = double, json_details::json_options_t Options = number_opts_def, typename Constructor = default_constructor<T>>
using json_checked_number_no_name = json_base::json_number< T, json_details::number_opts_set< Options, JsonRangeCheck::CheckForNarrowing >, Constructor >
 
template<JSONNAMETYPE Name, typename T = std::optional<double>, json_details::json_options_t Options = number_opts_def, typename Constructor = nullable_constructor<T>>
using json_checked_number_null = json_number< Name, T, json_details::number_opts_set< Options, JsonRangeCheck::CheckForNarrowing, JsonNullDefault >, Constructor >
 
template<typename T = std::optional<double>, json_details::json_options_t Options = number_opts_def, typename Constructor = nullable_constructor<T>>
using json_checked_number_null_no_name = json_base::json_number< T, json_details::number_opts_set< Options, JsonRangeCheck::CheckForNarrowing, JsonNullDefault >, Constructor >
 
template<typename T , typename Constructor = default_constructor<T>, json_details::json_options_t Options = class_opts_def>
using json_class_no_name = json_base::json_class< T, Constructor, Options >
 
template<JSONNAMETYPE Name, typename T , typename Constructor = nullable_constructor<T>, json_details::json_options_t Options = class_opts_def>
using json_class_null = json_class< Name, T, Constructor, json_details::class_opts_set< Options, JsonNullDefault > >
 
template<typename T , typename Constructor = nullable_constructor<T>, json_details::json_options_t Options = class_opts_def>
using json_class_null_no_name = json_base::json_class< T, Constructor, json_details::class_opts_set< Options, JsonNullDefault > >
 
template<JSONNAMETYPE Name, typename T , typename FromJsonConverter = default_from_json_converter_t<T>, typename ToJsonConverter = default_to_json_converter_t<T>, json_details::json_options_t Options = json_custom_opts_def>
using json_custom_lit = json_custom< Name, T, FromJsonConverter, ToJsonConverter, json_details::json_custom_opts_set< Options, JsonCustomTypes::Literal > >
 
template<typename T , typename FromJsonConverter = default_from_json_converter_t<T>, typename ToJsonConverter = default_to_json_converter_t<T>, json_details::json_options_t Options = json_custom_opts_def>
using json_custom_lit_no_name = json_base::json_custom< T, FromJsonConverter, ToJsonConverter, json_details::json_custom_opts_set< Options, JsonCustomTypes::Literal > >
 
template<JSONNAMETYPE Name, typename T , typename FromJsonConverter = default_from_json_converter_t<T>, typename ToJsonConverter = default_to_json_converter_t<T>, json_details::json_options_t Options = json_custom_opts_def>
using json_custom_lit_null = json_custom< Name, T, FromJsonConverter, ToJsonConverter, json_details::json_custom_opts_set< Options, JsonCustomTypes::Literal, JsonNullDefault > >
 
template<typename T , typename FromJsonConverter = default_from_json_converter_t<T>, typename ToJsonConverter = default_to_json_converter_t<T>, json_details::json_options_t Options = json_custom_opts_def>
using json_custom_lit_null_no_name = json_base::json_custom< T, FromJsonConverter, ToJsonConverter, json_details::json_custom_opts_set< Options, JsonCustomTypes::Literal, JsonNullDefault > >
 
template<typename T , typename FromJsonConverter = default_from_json_converter_t<T>, typename ToJsonConverter = default_to_json_converter_t<T>, json_details::json_options_t Options = json_custom_opts_def>
using json_custom_no_name = json_base::json_custom< T, FromJsonConverter, ToJsonConverter, Options >
 
template<JSONNAMETYPE Name, typename T , typename FromJsonConverter = default_from_json_converter_t<T>, typename ToJsonConverter = default_to_json_converter_t<T>, json_details::json_options_t Options = json_custom_opts_def>
using json_custom_null = json_custom< Name, T, FromJsonConverter, ToJsonConverter, json_details::json_custom_opts_set< Options, JsonNullDefault > >
 
template<typename T , typename FromJsonConverter = default_from_json_converter_t<T>, typename ToJsonConverter = default_to_json_converter_t<T>, json_details::json_options_t Options = json_custom_opts_def>
using json_custom_null_no_name = json_base::json_custom< T, FromJsonConverter, ToJsonConverter, json_details::json_custom_opts_set< Options, JsonNullDefault > >
 
using json_custom_opts_t = json_details::JsonOptionList< JsonNullable, JsonCustomTypes >
 
template<typename T >
using json_data_contract_trait_t = typename json_data_contract< T >::type
 
template<typename T , typename Constructor = default_constructor<T>, JsonNullable Nullable = JsonNullable::MustExist>
using json_date_no_name = json_base::json_date< T, Constructor, Nullable >
 
template<JSONNAMETYPE Name, typename T = std::optional<std::chrono::time_point< std::chrono::system_clock, std::chrono::milliseconds>>, typename Constructor = construct_from_iso8601_timestamp<JsonNullDefault>>
using json_date_null = json_date< Name, T, Constructor, JsonNullDefault >
 
template<typename T , typename Constructor = nullable_constructor<T>>
using json_date_null_no_name = json_base::json_date< T, Constructor, JsonNullDefault >
 
template<JSONNAMETYPE Name, typename T = json_value, typename Constructor = default_constructor<T>, JsonNullable Nullable = JsonNullable::MustExist>
using json_delayed = json_raw< Name, T, Constructor, Nullable >
 
template<JSONNAMETYPE Name, typename T = std::optional<json_value>, typename Constructor = nullable_constructor<T>>
using json_delayed_null = json_raw_null< Name, T, Constructor >
 
template<typename T , typename TagMember , typename Switcher , typename JsonElements = json_details:: determine_variant_element_types<JsonNullable::MustExist, T>, typename Constructor = default_constructor<T>, JsonNullable Nullable = JsonNullable::MustExist>
using json_intrusive_variant_no_name = json_base::json_intrusive_variant< T, TagMember, Switcher, JsonElements, Constructor, Nullable >
 
template<typename T , typename TagMember , typename Switcher , typename JsonElements = json_details:: determine_variant_element_types<JsonNullable::MustExist, T>, typename Constructor = default_constructor<T>>
using json_intrusive_variant_null_no_name = json_base::json_intrusive_variant< T, TagMember, Switcher, JsonElements, Constructor, JsonNullDefault >
 
template<typename Container , typename JsonValueType = typename Container::mapped_type, typename JsonKeyType = typename Container::key_type, typename Constructor = default_constructor<Container>, JsonNullable Nullable = JsonNullable::MustExist>
using json_key_value_array_no_name = json_base::json_key_value_array< Container, JsonValueType, JsonKeyType, Constructor, Nullable >
 
template<JSONNAMETYPE Name, typename Container , typename JsonValueType = typename Container::mapped_type, typename JsonKeyType = typename Container::key_type, typename Constructor = nullable_constructor<Container>>
using json_key_value_array_null = json_key_value_array< Name, Container, JsonValueType, JsonKeyType, Constructor, JsonNullDefault >
 
template<typename Container , typename JsonValueType = typename Container::mapped_type, typename JsonKeyType = typename Container::key_type, typename Constructor = nullable_constructor<Container>>
using json_key_value_array_null_no_name = json_base::json_key_value_array< Container, JsonValueType, JsonKeyType, Constructor, JsonNullDefault >
 
template<typename Container , typename JsonValueType = typename Container::mapped_type, typename JsonKeyType = typename Container::key_type, typename Constructor = default_constructor<Container>, JsonNullable Nullable = JsonNullable::MustExist>
using json_key_value_no_name = json_base::json_key_value< Container, JsonValueType, JsonKeyType, Constructor, Nullable >
 
template<JSONNAMETYPE Name, typename Container , typename JsonValueType = typename Container::mapped_type, typename JsonKeyType = typename Container::key_type, typename Constructor = nullable_constructor<Container>>
using json_key_value_null = json_key_value< Name, Container, JsonValueType, JsonKeyType, Constructor, JsonNullDefault >
 
template<typename Container , typename JsonValueType = typename Container::mapped_type, typename JsonKeyType = typename Container::key_type, typename Constructor = nullable_constructor<Container>>
using json_key_value_null_no_name = json_base::json_key_value< Container, JsonValueType, JsonKeyType, Constructor, JsonNullDefault >
 
template<JSONNAMETYPE Name, typename T >
using json_link = typename json_details::ensure_mapped_t< json_details::json_deduced_type< T > >::template with_name< Name >
 Deduce the json type mapping based on common types and types already mapped. More...
 
template<typename T >
using json_link_no_name = json_details::ensure_mapped_t< json_details::json_deduced_type< T > >
 Deduce the json type mapping based on common types and types already mapped. This version is for when a name is unneeded, such as array element types. More...
 
template<typename T = double, json_details::json_options_t Options = number_opts_def, typename Constructor = default_constructor<T>>
using json_number_no_name = json_base::json_number< T, Options, Constructor >
 
template<JSONNAMETYPE Name, typename T = std::optional<double>, json_details::json_options_t Options = number_opts_def, typename Constructor = nullable_constructor<T>>
using json_number_null = json_number< Name, T, json_details::number_opts_set< Options, JsonNullDefault >, Constructor >
 
template<typename T = std::optional<double>, json_details::json_options_t Options = number_opts_def, typename Constructor = nullable_constructor<T>>
using json_number_null_no_name = json_base::json_number< T, json_details::number_opts_set< Options, JsonNullDefault >, Constructor >
 
template<typename... JsonMembers>
using json_ordered_member_list = json_tuple_member_list< JsonMembers... >
 
using json_pair = basic_json_pair< NoCommentSkippingPolicyChecked >
 
template<typename T = json_value, typename Constructor = default_constructor<T>, JsonNullable Nullable = JsonNullable::MustExist>
using json_raw_no_name = json_base::json_raw< T, Constructor, Nullable >
 
template<JSONNAMETYPE Name, typename T = std::optional<json_value>, typename Constructor = nullable_constructor<T>>
using json_raw_null = json_raw< Name, T, Constructor, JsonNullDefault >
 
template<typename T = std::optional<json_value>, typename Constructor = nullable_constructor<T>>
using json_raw_null_no_name = json_base::json_raw< T, Constructor, JsonNullDefault >
 
template<typename JsonElement , typename SizeMember , typename Container = json_deduce_type, typename Constructor = json_deduce_type, JsonNullable Nullable = JsonNullable::MustExist>
using json_sized_array_no_name = json_base::json_sized_array< JsonElement, SizeMember, Container, Constructor, Nullable >
 
template<typename JsonElement , typename SizeMember , typename Container = json_deduce_type, typename Constructor = json_deduce_type>
using json_sized_array_null_no_name = json_base::json_sized_array< JsonElement, SizeMember, Container, Constructor, JsonNullDefault >
 
template<typename T = std::string, json_details::json_options_t Options = string_opts_def, typename Constructor = default_constructor<T>>
using json_string_no_name = json_base::json_string< T, Options, Constructor >
 
template<JSONNAMETYPE Name, typename String = std::optional<std::string>, json_details::json_options_t Options = string_opts_def, typename Constructor = nullable_constructor<String>>
using json_string_null = json_string< Name, String, json_details::string_opts_set< Options, JsonNullDefault >, Constructor >
 
template<typename T = std::optional<std::string>, json_details::json_options_t Options = string_opts_def, typename Constructor = nullable_constructor<T>>
using json_string_null_no_name = json_base::json_string< T, json_details::string_opts_set< Options, JsonNullDefault >, Constructor >
 
template<typename T = std::string, json_details::json_options_t Options = string_raw_opts_def, typename Constructor = default_constructor<T>>
using json_string_raw_no_name = json_base::json_string_raw< T, Options, Constructor >
 
template<JSONNAMETYPE Name, typename String = std::optional<std::string>, json_details::json_options_t Options = string_raw_opts_def, typename Constructor = nullable_constructor<String>>
using json_string_raw_null = json_string_raw< Name, String, json_details::string_raw_opts_set< Options, JsonNullDefault >, Constructor >
 
template<typename T = std::optional<std::string>, json_details::json_options_t Options = string_raw_opts_def, typename Constructor = nullable_constructor<T>>
using json_string_raw_null_no_name = json_base::json_string_raw< T, json_details::string_raw_opts_set< Options, JsonNullDefault >, Constructor >
 
template<typename T , typename TagMember , typename Switcher , typename JsonElements = json_deduce_type, typename Constructor = default_constructor<T>, JsonNullable Nullable = JsonNullable::MustExist>
using json_tagged_variant_no_name = json_base::json_tagged_variant< T, TagMember, Switcher, JsonElements, Constructor, Nullable >
 
template<JSONNAMETYPE Name, typename Variant , typename TagMember , typename Switcher , typename JsonElements = json_deduce_type, typename Constructor = nullable_constructor<Variant>>
using json_tagged_variant_null = json_tagged_variant< Name, Variant, TagMember, Switcher, JsonElements, Constructor, JsonNullDefault >
 
template<typename T , typename TagMember , typename Switcher , typename JsonElements = json_deduce_type, typename Constructor = default_constructor<T>>
using json_tagged_variant_null_no_name = json_base::json_tagged_variant< T, TagMember, Switcher, JsonElements, Constructor, JsonNullDefault >
 
template<typename... JsonElements>
using json_tagged_variant_type_list = json_variant_type_list< JsonElements... >
 
template<typename Tuple , typename Constructor = default_constructor<Tuple>, json_details::json_options_t Options = tuple_opts_def, typename JsonTupleTypesList = json_deduce_type>
using json_tuple_no_name = json_base::json_tuple< Tuple, Constructor, Options, JsonTupleTypesList >
 
template<JSONNAMETYPE Name, typename Tuple , typename Constructor = json_deduce_type, json_details::json_options_t Options = tuple_opts_def, typename JsonTupleTypesList = json_deduce_type>
using json_tuple_null = json_tuple< Name, Tuple, Constructor, json_details::tuple_opts_set< Options, JsonNullDefault >, JsonTupleTypesList >
 
template<typename Tuple , typename Constructor = default_constructor<Tuple>, json_details::json_options_t Options = tuple_opts_def, typename JsonTupleTypesList = json_deduce_type>
using json_tuple_null_no_name = json_base::json_tuple< Tuple, Constructor, json_details::tuple_opts_set< Options, JsonNullDefault >, JsonTupleTypesList >
 
using json_value = basic_json_value< NoCommentSkippingPolicyChecked >
 
using json_value_state = basic_stateful_json_value< NoCommentSkippingPolicyChecked >
 
template<typename Variant , typename JsonElements = json_deduce_type, typename Constructor = default_constructor<Variant>, JsonNullable Nullable = JsonNullable::MustExist>
using json_variant_no_name = json_base::json_variant< Variant, JsonElements, Constructor, JsonNullable::MustExist >
 
template<JSONNAMETYPE Name, typename Variant , typename JsonElements = json_deduce_type, typename Constructor = nullable_constructor<Variant>>
using json_variant_null = json_variant< Name, Variant, JsonElements, Constructor, JsonNullDefault >
 
template<typename Variant , typename JsonElements = json_deduce_type, typename Constructor = nullable_constructor<Variant>>
using json_variant_null_no_name = json_base::json_variant< Variant, JsonElements, Constructor, JsonNullDefault >
 
using NoCommentSkippingPolicyChecked = BasicParsePolicy<>
 
using NoCommentSkippingPolicyUnchecked = BasicParsePolicy< parse_options(CheckedParseMode::no)>
 
using NoCommentZeroSkippingPolicyChecked = BasicParsePolicy< parse_options(ZeroTerminatedString::yes)>
 
using NoCommentZeroSkippingPolicyUnchecked = BasicParsePolicy< parse_options(CheckedParseMode::no, ZeroTerminatedString::yes)>
 
using number_opts_t = json_details::JsonOptionList< JsonNullable, LiteralAsStringOpt, JsonRangeCheck, JsonNumberErrors, FPOutputFormat >
 
template<std::size_t Index, typename JsonMember >
using ordered_json_member = json_tuple_member< Index, JsonMember >
 
template<JsonParseTypes v>
using ParseTag = daw::constant< v >
 
template<typename ExecTag , typename Allocator = json_details::NoAllocator>
using SIMDCppCommentSkippingPolicyChecked = BasicParsePolicy< parse_options(PolicyCommentTypes::cpp, json_details::exec_mode_from_tag< ExecTag >), Allocator >
 
template<typename ExecTag , typename Allocator = json_details::NoAllocator>
using SIMDCppCommentSkippingPolicyUnchecked = BasicParsePolicy< parse_options(CheckedParseMode::no, PolicyCommentTypes::cpp, json_details::exec_mode_from_tag< ExecTag >), Allocator >
 
template<typename ExecTag , typename Allocator = json_details::NoAllocator>
using SIMDHashCommentSkippingPolicyChecked = BasicParsePolicy< parse_options(PolicyCommentTypes::hash, json_details::exec_mode_from_tag< ExecTag >), Allocator >
 
template<typename ExecTag , typename Allocator = json_details::NoAllocator>
using SIMDHashCommentSkippingPolicyUnchecked = BasicParsePolicy< parse_options(CheckedParseMode::no, PolicyCommentTypes::hash, json_details::exec_mode_from_tag< ExecTag >), Allocator >
 
template<typename ExecTag , typename Allocator = json_details::NoAllocator>
using SIMDNoCommentSkippingPolicyChecked = BasicParsePolicy< parse_options(json_details::exec_mode_from_tag< ExecTag >), Allocator >
 
template<typename ExecTag , typename Allocator = json_details::NoAllocator>
using SIMDNoCommentSkippingPolicyUnchecked = BasicParsePolicy< parse_options(CheckedParseMode::no, json_details::exec_mode_from_tag< ExecTag >), Allocator >
 
using string_opts_t = json_details::JsonOptionList< JsonNullable, EightBitModes, EmptyStringNull >
 
using string_raw_opts_t = json_details::JsonOptionList< JsonNullable, EightBitModes, EmptyStringNull, AllowEscapeCharacter >
 
template<typename T >
using test_valid_json_data_contract_trait_t = typename json_data_contract_trait_t< T >::i_am_a_json_member_list
 
using tuple_opts_t = json_details::JsonOptionList< JsonNullable >
 

Enumerations

enum class  AllowEscapeCharacter : unsigned { Allow , NotBeforeDblQuote }
 
enum class  AllowEscapedNames : unsigned { no , yes }
 
enum class  CheckedParseMode : unsigned { yes , no }
 
enum class  EightBitModes : unsigned { DisallowHigh = false , AllowFull = true }
 
enum class  EmptyStringNull : unsigned { no , yes }
 
enum class  ExcludeSpecialEscapes : unsigned { no , yes }
 
enum class  ExecModeTypes : unsigned { compile_time , runtime , simd }
 
enum class  ExpectLongStrings : unsigned { no , yes }
 
enum class  ForceFullNameCheck : unsigned { no , yes }
 
enum class  FPOutputFormat : unsigned { Auto , Scientific }
 
enum class  IEEE754Precise : unsigned { no , yes }
 
enum class  IndentationType : unsigned {
  Tab , Space0 , Space1 , Space2 ,
  Space3 , Space4 , Space5 , Space8
}
 
enum  json_parse_handler_result { Continue , SkipClassArray , Complete }
 
enum class  JsonBaseParseTypes : std::uint_fast8_t {
  Number , Bool , String , Class ,
  Array , Null , None
}
 The fundamental JSON types. More...
 
enum class  JsonCustomTypes : unsigned { String , Literal , Any }
 
enum class  JsonNullable : unsigned { MustExist , Nullable , NullVisible }
 
enum class  JsonNumberErrors : unsigned { None , AllowNaN , AllowInf , AllowNanInf }
 
enum class  JsonParseTypes : std::uint_fast8_t {
  Real , Signed , Unsigned , Bool ,
  StringRaw , StringEscaped , Date , Class ,
  Array , SizedArray , Null , KeyValue ,
  KeyValueArray , Custom , Variant , VariantTagged ,
  VariantIntrusive , Tuple , Unknown
}
 The tags used by the parser to determine what parser to call. More...
 
enum class  JsonRangeCheck : unsigned { Never , CheckForNarrowing }
 
enum class  LiteralAsStringOpt : unsigned { Never , Maybe , Always }
 
enum class  MinifiedDocument : unsigned { no , yes }
 
enum class  MustVerifyEndOfDataIsValid : unsigned { no , yes }
 
enum class  NewLineDelimiter : unsigned { n , rn }
 
enum class  OutputTrailingComma : unsigned { No , Yes }
 
enum class  PolicyCommentTypes : unsigned { none , cpp , hash }
 
enum class  RestrictedStringOutput : unsigned { None , OnlyAllow7bitsStrings }
 
enum class  SerializationFormat : unsigned { Minified , Pretty }
 
enum class  StackParseStateType { Class , Array }
 
enum class  TemporarilyMutateBuffer : unsigned { no , yes }
 
enum class  UseExactMappingsByDefault : unsigned { no , yes }
 
enum class  ZeroTerminatedString : unsigned { no , yes }
 

Functions

template<typename ParseState >
 basic_json_value (ParseState) -> basic_json_value< ParseState >
 
template<typename ParseState >
 basic_json_value_iterator_range (basic_json_value_iterator< ParseState >, basic_json_value_iterator< ParseState >) -> basic_json_value_iterator_range< ParseState >
 
template<typename... Options>
constexpr json_details::json_options_t bool_opt (Options... options)
 
template<typename... Options>
constexpr json_details::json_options_t class_opt (Options... options)
 
template<bool ShouldThrow = use_daw_json_exceptions_v>
DAW_ATTRIB_NOINLINE void daw_json_error (ErrorReason reason)
 
template<bool ShouldThrow = use_daw_json_exceptions_v, typename ParseState >
static DAW_ATTRIB_NOINLINE void daw_json_error (ErrorReason reason, ParseState const &location)
 
template<bool ShouldThrow = use_daw_json_exceptions_v>
static DAW_ATTRIB_NOINLINE void daw_json_error (json_details::missing_member reason)
 
template<bool ShouldThrow = use_daw_json_exceptions_v, typename ParseState >
static DAW_ATTRIB_NOINLINE void daw_json_error (json_details::missing_member reason, ParseState const &location)
 
template<bool ShouldThrow = use_daw_json_exceptions_v>
static DAW_ATTRIB_NOINLINE void daw_json_error (json_details::missing_token reason)
 
template<bool ShouldThrow = use_daw_json_exceptions_v, typename ParseState >
static DAW_ATTRIB_NOINLINE void daw_json_error (json_details::missing_token reason, ParseState const &location)
 
constexpr std::size_t find_column_number_of (char const *doc_pos, char const *doc_start)
 
constexpr std::size_t find_column_number_of (json_path_node const &node, char const *doc_start)
 
std::vector< json_path_nodefind_json_path_stack_to (char const *parse_location, char const *doc_start)
 Get the json_path_nodes representing the path to the nearest value's position in the document. More...
 
std::vector< json_path_nodefind_json_path_stack_to (json_exception const &jex, char const *doc_start)
 
std::string find_json_path_to (char const *parse_location, char const *doc_start)
 
std::string find_json_path_to (json_exception const &jex, char const *doc_start)
 
constexpr std::size_t find_line_number_of (char const *doc_pos, char const *doc_start)
 
constexpr std::size_t find_line_number_of (json_path_node const &node, char const *doc_start)
 
template<typename JsonMember , typename ParsePolicy , bool KnownBounds, typename Result , typename ParseState >
constexpr Result from_json (basic_json_value< ParseState > value)
 
template<typename JsonMember , typename ParsePolicy , bool KnownBounds, typename Result , typename ParseState >
constexpr Result from_json (basic_json_value< ParseState > value, std::string_view member_path)
 
template<typename JsonMember , typename ParsePolicy , bool KnownBounds, typename Result , typename String >
constexpr auto from_json (String &&json_data) -> std::enable_if_t< json_details::is_string_view_like_v< String >, Result >
 
template<typename JsonMember , typename ParsePolicy , bool KnownBounds, typename Result , typename String >
constexpr auto from_json (String &&json_data, std::string_view member_path) -> std::enable_if_t< json_details::is_string_view_like_v< String >, Result >
 
template<typename JsonMember , typename ParsePolicy , bool KnownBounds, typename Result , typename String , typename Allocator >
constexpr auto from_json_alloc (String &&json_data, Allocator const &alloc) -> std::enable_if_t< json_details::is_string_view_like_v< String >, Result >
 
template<typename JsonMember , typename ParsePolicy , bool KnownBounds, typename Result , typename String , typename Allocator >
constexpr auto from_json_alloc (String &&json_data, std::string_view member_path, Allocator const &alloc) -> std::enable_if_t< json_details::is_string_view_like_v< String >, Result >
 
template<typename JsonElement , typename Container , typename ParsePolicy , typename Constructor , bool KnownBounds, typename String >
constexpr auto from_json_array (String &&json_data, std::string_view member_path) -> std::enable_if_t< json_details::is_string_view_like_v< String >, Container >
 
template<std::size_t Idx, typename ParseState >
constexpr decltype(auto) get (basic_json_pair< ParseState > &&parse_state)
 
template<std::size_t Idx, typename ParseState >
constexpr decltype(auto) get (basic_json_pair< ParseState > &parse_state)
 
template<std::size_t Idx, typename ParseState >
constexpr decltype(auto) get (basic_json_pair< ParseState > const &parse_state)
 
template<typename... Options>
constexpr json_details::json_options_t json_custom_opt (Options... options)
 
template<typename ParseState = NoCommentSkippingPolicyChecked, typename StackContainerPolicy = DefaultJsonEventParserStackPolicy< JsonEventParserStackValue<ParseState>>, typename Handler >
constexpr void json_event_parser (basic_json_value< ParseState > jvalue, Handler &&handler)
 
template<typename ParsePolicy = NoCommentSkippingPolicyChecked, typename Handler >
void json_event_parser (std::string_view json_document, Handler &&handler)
 
constexpr std::string_view json_link_version ()
 
template<typename... Options>
constexpr json_details::json_options_t number_opt (Options... options)
 
template<typename... Policies>
constexpr json_details::json_options_t parse_options (Policies... policies)
 
template<typename... Policies>
constexpr json_details::json_options_t serialize_options (Policies... policies)
 
template<typename... Options>
constexpr json_details::json_options_t string_opt (Options... options)
 
template<typename... Options>
constexpr json_details::json_options_t string_raw_opt (Options... options)
 
template<typename Result , typename Value , typename JsonClass , typename SerializationPolicy >
constexpr Result to_json (Value const &value)
 
template<typename Value , typename JsonClass , typename OutputIterator >
constexpr OutputIterator to_json (Value const &value, OutputIterator out_it)
 
template<typename Result , typename JsonElement , typename SerializationPolicy , typename Container >
constexpr Result to_json_array (Container &&c)
 
template<typename JsonElement , typename Container , typename OutputIterator >
constexpr OutputIterator to_json_array (Container const &c, OutputIterator it)
 
std::string to_json_path_string (std::vector< json_path_node > const &path_stack)
 Convert a json_path_node stack to a JSON Path string. More...
 
constexpr std::string_view to_string (JsonBaseParseTypes pt)
 
template<typename... Options>
constexpr json_details::json_options_t tuple_opt (Options... options)
 

Variables

constexpr auto bool_opts = bool_opts_t{ }
 
constexpr json_details::json_options_t bool_opts_def
 
constexpr auto class_opts = class_opts_t{ }
 
constexpr json_details::json_options_t class_opts_def
 
template<typename T >
constexpr bool force_aggregate_construction_v
 
template<JsonParseTypes ParseType, JsonNullable Nullable>
constexpr JsonParseTypes get_parse_type_v
 
template<typename T >
constexpr bool ignore_unknown_members_v
 
template<typename T >
constexpr bool is_default_constructor_v
 
template<typename... Ts>
constexpr bool is_empty_pack_v = is_empty_pack<Ts...>::value
 
template<typename T >
constexpr bool is_exact_class_mapping_v
 
template<typename T >
constexpr bool is_zero_terminated_string_v
 
constexpr auto json_custom_opts = json_custom_opts_t{ }
 
constexpr json_details::json_options_t json_custom_opts_def
 
constexpr JsonNullable JsonNullDefault = JsonNullable::Nullable
 
constexpr char const no_name [] = "\a"
 
constexpr daw::string_view no_name_sv = daw::string_view( no_name )
 
constexpr auto number_opts = number_opts_t{ }
 
constexpr json_details::json_options_t number_opts_def
 
constexpr auto string_opts = string_opts_t{ }
 
constexpr json_details::json_options_t string_opts_def
 
constexpr auto string_raw_opts = string_raw_opts_t{ }
 
constexpr json_details::json_options_t string_raw_opts_def
 
constexpr auto tuple_opts = tuple_opts_t{ }
 
constexpr json_details::json_options_t tuple_opts_def
 

Typedef Documentation

◆ bool_opts_t

◆ class_opts_t

◆ ConformancePolicy

◆ CppCommentSkippingPolicyChecked

◆ CppCommentSkippingPolicyUnchecked

◆ default_exec_tag

◆ DefaultParsePolicy

◆ force_aggregate_construction

template<typename T >
using daw::json::DAW_JSON_VER::force_aggregate_construction = typedef std::bool_constant<std::disjunction_v< daw::is_detected<json_details::force_aggregate_construction_test, T>, daw::is_detected<json_details::force_aggregate_construction_test2, T> >>

◆ HashCommentSkippingPolicyChecked

◆ HashCommentSkippingPolicyUnchecked

◆ is_empty_pack

template<typename... Ts>
using daw::json::DAW_JSON_VER::is_empty_pack = typedef std::bool_constant<( sizeof...( Ts ) == 0 )>

◆ json_array_no_name

template<typename JsonElement , typename Container = json_deduce_type, typename Constructor = json_deduce_type, JsonNullable Nullable = JsonNullable::MustExist>
using daw::json::DAW_JSON_VER::json_array_no_name = typedef json_base::json_array<JsonElement, Container, Constructor, Nullable>

◆ json_array_null

template<JSONNAMETYPE Name, typename JsonElement , typename Container = json_deduce_type, typename Constructor = json_deduce_type>
using daw::json::DAW_JSON_VER::json_array_null = typedef json_array<Name, JsonElement, Container, Constructor, JsonNullDefault>

Link to a nullable JSON array

Template Parameters
Namename of JSON member to link to
Containertype of C++ container being constructed(e.g. vector<int>)
JsonElementJson type being parsed e.g. json_number, json_string...
ConstructorA callable used to make Container, default will use the Containers constructor. Both normal and aggregate are supported

◆ json_array_null_no_name

template<typename JsonElement , typename Container = json_deduce_type, typename Constructor = json_deduce_type>
using daw::json::DAW_JSON_VER::json_array_null_no_name = typedef json_base::json_array<JsonElement, Container, Constructor, JsonNullDefault>

◆ json_bool_no_name

template<typename T = bool, json_details::json_options_t Options = bool_opts_def, typename Constructor = default_constructor<T>>
using daw::json::DAW_JSON_VER::json_bool_no_name = typedef json_base::json_bool<T, Options, Constructor>

◆ json_bool_null

template<JSONNAMETYPE Name, typename T = std::optional<bool>, json_details::json_options_t Options = bool_opts_def, typename Constructor = default_constructor<T>>
using daw::json::DAW_JSON_VER::json_bool_null = typedef json_bool<Name, T, json_details::bool_opts_set<Options, JsonNullDefault>, Constructor>

The member is a nullable boolean

Template Parameters
Namename of json member
Tresult type to pass to Constructor
LiteralAsStringCould this number be embedded in a string
ConstructorCallable used to construct result

◆ json_bool_null_no_name

template<typename T = std::optional<bool>, json_details::json_options_t Options = bool_opts_def, typename Constructor = nullable_constructor<T>>
using daw::json::DAW_JSON_VER::json_bool_null_no_name = typedef json_base::json_bool< T, json_details::bool_opts_set<Options, JsonNullDefault>, Constructor>

◆ json_checked_number

template<JSONNAMETYPE Name, typename T = double, json_details::json_options_t Options = number_opts_def, typename Constructor = default_constructor<T>>
using daw::json::DAW_JSON_VER::json_checked_number = typedef json_number< Name, T, json_details::number_opts_set<Options, JsonRangeCheck::CheckForNarrowing>, Constructor>

The member is a range checked number

Template Parameters
Namename of json member
Ttype of number(e.g. double, int, unsigned...) to pass to Constructor
LiteralAsStringCould this number be embedded in a string
ConstructorCallable used to construct result
NullableCan the member be missing or have a null value

◆ json_checked_number_no_name

template<typename T = double, json_details::json_options_t Options = number_opts_def, typename Constructor = default_constructor<T>>
using daw::json::DAW_JSON_VER::json_checked_number_no_name = typedef json_base::json_number< T, json_details::number_opts_set<Options, JsonRangeCheck::CheckForNarrowing>, Constructor>

The member is a range checked number

Template Parameters
Ttype of number(e.g. double, int, unsigned...) to pass to Constructor
LiteralAsStringCould this number be embedded in a string
ConstructorCallable used to construct result
NullableCan the member be missing or have a null value

◆ json_checked_number_null

template<JSONNAMETYPE Name, typename T = std::optional<double>, json_details::json_options_t Options = number_opts_def, typename Constructor = nullable_constructor<T>>
using daw::json::DAW_JSON_VER::json_checked_number_null = typedef json_number< Name, T, json_details::number_opts_set<Options, JsonRangeCheck::CheckForNarrowing, JsonNullDefault>, Constructor>

The member is a nullable range checked number

Template Parameters
Namename of json member
Ttype of number(e.g. optional<double>, optional<int>, optional<unsigned>...) to pass to Constructor
LiteralAsStringCould this number be embedded in a string
ConstructorCallable used to construct result

◆ json_checked_number_null_no_name

template<typename T = std::optional<double>, json_details::json_options_t Options = number_opts_def, typename Constructor = nullable_constructor<T>>
using daw::json::DAW_JSON_VER::json_checked_number_null_no_name = typedef json_base::json_number< T, json_details::number_opts_set<Options, JsonRangeCheck::CheckForNarrowing, JsonNullDefault>, Constructor>

The member is a nullable range checked number

Template Parameters
Namename of json member
Ttype of number(e.g. optional<double>, optional<int>, optional<unsigned>...) to pass to Constructor
LiteralAsStringCould this number be embedded in a string
ConstructorCallable used to construct result

◆ json_class_no_name

template<typename T , typename Constructor = default_constructor<T>, json_details::json_options_t Options = class_opts_def>
using daw::json::DAW_JSON_VER::json_class_no_name = typedef json_base::json_class<T, Constructor, Options>

◆ json_class_null

template<JSONNAMETYPE Name, typename T , typename Constructor = nullable_constructor<T>, json_details::json_options_t Options = class_opts_def>
using daw::json::DAW_JSON_VER::json_class_null = typedef json_class<Name, T, Constructor, json_details::class_opts_set<Options, JsonNullDefault> >

Link to a nullable JSON class

Template Parameters
Namename of JSON member to link to
Ttype that has specialization of daw::json::json_data_contract
ConstructorA callable used to construct T. The default supports normal and aggregate construction

◆ json_class_null_no_name

template<typename T , typename Constructor = nullable_constructor<T>, json_details::json_options_t Options = class_opts_def>
using daw::json::DAW_JSON_VER::json_class_null_no_name = typedef json_base::json_class< T, Constructor, json_details::class_opts_set<Options, JsonNullDefault> >

◆ json_custom_lit

template<JSONNAMETYPE Name, typename T , typename FromJsonConverter = default_from_json_converter_t<T>, typename ToJsonConverter = default_to_json_converter_t<T>, json_details::json_options_t Options = json_custom_opts_def>
using daw::json::DAW_JSON_VER::json_custom_lit = typedef json_custom< Name, T, FromJsonConverter, ToJsonConverter, json_details::json_custom_opts_set<Options, JsonCustomTypes::Literal> >

◆ json_custom_lit_no_name

template<typename T , typename FromJsonConverter = default_from_json_converter_t<T>, typename ToJsonConverter = default_to_json_converter_t<T>, json_details::json_options_t Options = json_custom_opts_def>
using daw::json::DAW_JSON_VER::json_custom_lit_no_name = typedef json_base::json_custom< T, FromJsonConverter, ToJsonConverter, json_details::json_custom_opts_set<Options, JsonCustomTypes::Literal> >

◆ json_custom_lit_null

template<JSONNAMETYPE Name, typename T , typename FromJsonConverter = default_from_json_converter_t<T>, typename ToJsonConverter = default_to_json_converter_t<T>, json_details::json_options_t Options = json_custom_opts_def>
using daw::json::DAW_JSON_VER::json_custom_lit_null = typedef json_custom<Name, T, FromJsonConverter, ToJsonConverter, json_details::json_custom_opts_set< Options, JsonCustomTypes::Literal, JsonNullDefault> >

◆ json_custom_lit_null_no_name

template<typename T , typename FromJsonConverter = default_from_json_converter_t<T>, typename ToJsonConverter = default_to_json_converter_t<T>, json_details::json_options_t Options = json_custom_opts_def>
using daw::json::DAW_JSON_VER::json_custom_lit_null_no_name = typedef json_base::json_custom< T, FromJsonConverter, ToJsonConverter, json_details::json_custom_opts_set<Options, JsonCustomTypes::Literal, JsonNullDefault> >

◆ json_custom_no_name

template<typename T , typename FromJsonConverter = default_from_json_converter_t<T>, typename ToJsonConverter = default_to_json_converter_t<T>, json_details::json_options_t Options = json_custom_opts_def>
using daw::json::DAW_JSON_VER::json_custom_no_name = typedef json_base::json_custom<T, FromJsonConverter, ToJsonConverter, Options>

◆ json_custom_null

template<JSONNAMETYPE Name, typename T , typename FromJsonConverter = default_from_json_converter_t<T>, typename ToJsonConverter = default_to_json_converter_t<T>, json_details::json_options_t Options = json_custom_opts_def>
using daw::json::DAW_JSON_VER::json_custom_null = typedef json_custom<Name, T, FromJsonConverter, ToJsonConverter, json_details::json_custom_opts_set<Options, JsonNullDefault> >

Allow parsing of a nullable type that does not fit

Template Parameters
NameName of JSON member to link to
Ttype of value being constructed
FromJsonConverterCallable that accepts a std::string_view of the range to parse
ToJsonConverterReturns a string from the value
JsonRawTypeJSON type value is encoded as literal/string

◆ json_custom_null_no_name

template<typename T , typename FromJsonConverter = default_from_json_converter_t<T>, typename ToJsonConverter = default_to_json_converter_t<T>, json_details::json_options_t Options = json_custom_opts_def>
using daw::json::DAW_JSON_VER::json_custom_null_no_name = typedef json_base::json_custom< T, FromJsonConverter, ToJsonConverter, json_details::json_custom_opts_set<Options, JsonNullDefault> >

◆ json_custom_opts_t

◆ json_data_contract_trait_t

template<typename T >
using daw::json::DAW_JSON_VER::json_data_contract_trait_t = typedef typename json_data_contract<T>::type

◆ json_date_no_name

template<typename T , typename Constructor = default_constructor<T>, JsonNullable Nullable = JsonNullable::MustExist>
using daw::json::DAW_JSON_VER::json_date_no_name = typedef json_base::json_date<T, Constructor, Nullable>

◆ json_date_null

template<JSONNAMETYPE Name, typename T = std::optional<std::chrono::time_point< std::chrono::system_clock, std::chrono::milliseconds>>, typename Constructor = construct_from_iso8601_timestamp<JsonNullDefault>>
using daw::json::DAW_JSON_VER::json_date_null = typedef json_date<Name, T, Constructor, JsonNullDefault>

Link to a JSON string representing a nullable date

Template Parameters
Namename of JSON member to link to
TC++ type to construct, by default is a time_point
ConstructorA Callable used to construct a T. Must accept a char pointer and size as argument to the date/time string.

◆ json_date_null_no_name

template<typename T , typename Constructor = nullable_constructor<T>>
using daw::json::DAW_JSON_VER::json_date_null_no_name = typedef json_base::json_date<T, Constructor, JsonNullDefault>

◆ json_delayed

template<JSONNAMETYPE Name, typename T = json_value, typename Constructor = default_constructor<T>, JsonNullable Nullable = JsonNullable::MustExist>
using daw::json::DAW_JSON_VER::json_delayed = typedef json_raw<Name, T, Constructor, Nullable>

◆ json_delayed_null

template<JSONNAMETYPE Name, typename T = std::optional<json_value>, typename Constructor = nullable_constructor<T>>
using daw::json::DAW_JSON_VER::json_delayed_null = typedef json_raw_null<Name, T, Constructor>

◆ json_intrusive_variant_no_name

template<typename T , typename TagMember , typename Switcher , typename JsonElements = json_details:: determine_variant_element_types<JsonNullable::MustExist, T>, typename Constructor = default_constructor<T>, JsonNullable Nullable = JsonNullable::MustExist>
using daw::json::DAW_JSON_VER::json_intrusive_variant_no_name = typedef json_base::json_intrusive_variant<T, TagMember, Switcher, JsonElements, Constructor, Nullable>

◆ json_intrusive_variant_null_no_name

template<typename T , typename TagMember , typename Switcher , typename JsonElements = json_details:: determine_variant_element_types<JsonNullable::MustExist, T>, typename Constructor = default_constructor<T>>
using daw::json::DAW_JSON_VER::json_intrusive_variant_null_no_name = typedef json_base::json_intrusive_variant<T, TagMember, Switcher, JsonElements, Constructor, JsonNullDefault>

◆ json_key_value_array_no_name

template<typename Container , typename JsonValueType = typename Container::mapped_type, typename JsonKeyType = typename Container::key_type, typename Constructor = default_constructor<Container>, JsonNullable Nullable = JsonNullable::MustExist>
using daw::json::DAW_JSON_VER::json_key_value_array_no_name = typedef json_base::json_key_value_array<Container, JsonValueType, JsonKeyType, Constructor, Nullable>

◆ json_key_value_array_null

template<JSONNAMETYPE Name, typename Container , typename JsonValueType = typename Container::mapped_type, typename JsonKeyType = typename Container::key_type, typename Constructor = nullable_constructor<Container>>
using daw::json::DAW_JSON_VER::json_key_value_array_null = typedef json_key_value_array<Name, Container, JsonValueType, JsonKeyType, Constructor, JsonNullDefault>

Map a nullable KV type json array [ {"key": ValueOfKeyType, "value": ValueOfValueType},... ] to a c++ class. needs to be constructable with a pointer, size

Template Parameters
Namename of JSON member to link to
Containertype to put values in
JsonValueTypeJson type of value in kv pair( e.g. json_number, json_string, ... ). If specific json member type isn't specified, the member name defaults to "value"
JsonKeyTypetype of key in kv pair. If specific json member type isn't specified, the key name defaults to "key"
ConstructorA callable used to make Container, default will use the Containers constructor. Both normal and aggregate are supported

◆ json_key_value_array_null_no_name

template<typename Container , typename JsonValueType = typename Container::mapped_type, typename JsonKeyType = typename Container::key_type, typename Constructor = nullable_constructor<Container>>
using daw::json::DAW_JSON_VER::json_key_value_array_null_no_name = typedef json_base::json_key_value_array<Container, JsonValueType, JsonKeyType, Constructor, JsonNullDefault>

◆ json_key_value_no_name

template<typename Container , typename JsonValueType = typename Container::mapped_type, typename JsonKeyType = typename Container::key_type, typename Constructor = default_constructor<Container>, JsonNullable Nullable = JsonNullable::MustExist>
using daw::json::DAW_JSON_VER::json_key_value_no_name = typedef json_base::json_key_value<Container, JsonValueType, JsonKeyType, Constructor, Nullable>

◆ json_key_value_null

template<JSONNAMETYPE Name, typename Container , typename JsonValueType = typename Container::mapped_type, typename JsonKeyType = typename Container::key_type, typename Constructor = nullable_constructor<Container>>
using daw::json::DAW_JSON_VER::json_key_value_null = typedef json_key_value<Name, Container, JsonValueType, JsonKeyType, Constructor, JsonNullDefault>

Map a nullable KV type json class { "Key StringRaw": ValueType, ... } to a c++ class. Keys are Always string like and the destination needs to be constructable with a pointer, size

Template Parameters
Namename of JSON member to link to
Containertype to put values in
JsonValueTypeJson type of value in kv pair( e.g. json_number, json_string, ... ). It also supports basic types like numbers, bool, and mapped classes and enums(mapped to numbers)
JsonKeyTypetype of key in kv pair. As with value it supports basic types too
ConstructorA callable used to make Container, default will use the Containers constructor. Both normal and aggregate are supported

◆ json_key_value_null_no_name

template<typename Container , typename JsonValueType = typename Container::mapped_type, typename JsonKeyType = typename Container::key_type, typename Constructor = nullable_constructor<Container>>
using daw::json::DAW_JSON_VER::json_key_value_null_no_name = typedef json_base::json_key_value<Container, JsonValueType, JsonKeyType, Constructor, JsonNullDefault>

◆ json_link

template<JSONNAMETYPE Name, typename T >
using daw::json::DAW_JSON_VER::json_link = typedef typename json_details::ensure_mapped_t< json_details::json_deduced_type<T> >::template with_name<Name>

Deduce the json type mapping based on common types and types already mapped.

◆ json_link_no_name

Deduce the json type mapping based on common types and types already mapped. This version is for when a name is unneeded, such as array element types.

◆ json_number_no_name

template<typename T = double, json_details::json_options_t Options = number_opts_def, typename Constructor = default_constructor<T>>
using daw::json::DAW_JSON_VER::json_number_no_name = typedef json_base::json_number<T, Options, Constructor>

◆ json_number_null

template<JSONNAMETYPE Name, typename T = std::optional<double>, json_details::json_options_t Options = number_opts_def, typename Constructor = nullable_constructor<T>>
using daw::json::DAW_JSON_VER::json_number_null = typedef json_number<Name, T, json_details::number_opts_set<Options, JsonNullDefault>, Constructor>

The member is a nullable number

Template Parameters
Namename of json member
Ttype of number(e.g. double, int, unsigned...) to pass to Constructor
LiteralAsStringCould this number be embedded in a string
ConstructorCallable used to construct result
RangeCheckCheck if the value will fit in the result

◆ json_number_null_no_name

template<typename T = std::optional<double>, json_details::json_options_t Options = number_opts_def, typename Constructor = nullable_constructor<T>>
using daw::json::DAW_JSON_VER::json_number_null_no_name = typedef json_base::json_number< T, json_details::number_opts_set<Options, JsonNullDefault>, Constructor>

◆ json_ordered_member_list

template<typename... JsonMembers>
using daw::json::DAW_JSON_VER::json_ordered_member_list = typedef json_tuple_member_list<JsonMembers...>

◆ json_pair

◆ json_raw_no_name

template<typename T = json_value, typename Constructor = default_constructor<T>, JsonNullable Nullable = JsonNullable::MustExist>
using daw::json::DAW_JSON_VER::json_raw_no_name = typedef json_base::json_raw<T, Constructor, Nullable>

◆ json_raw_null

template<JSONNAMETYPE Name, typename T = std::optional<json_value>, typename Constructor = nullable_constructor<T>>
using daw::json::DAW_JSON_VER::json_raw_null = typedef json_raw<Name, T, Constructor, JsonNullDefault>

◆ json_raw_null_no_name

template<typename T = std::optional<json_value>, typename Constructor = nullable_constructor<T>>
using daw::json::DAW_JSON_VER::json_raw_null_no_name = typedef json_base::json_raw<T, Constructor, JsonNullDefault>

◆ json_sized_array_no_name

template<typename JsonElement , typename SizeMember , typename Container = json_deduce_type, typename Constructor = json_deduce_type, JsonNullable Nullable = JsonNullable::MustExist>
using daw::json::DAW_JSON_VER::json_sized_array_no_name = typedef json_base::json_sized_array<JsonElement, SizeMember, Container, Constructor, Nullable>

◆ json_sized_array_null_no_name

template<typename JsonElement , typename SizeMember , typename Container = json_deduce_type, typename Constructor = json_deduce_type>
using daw::json::DAW_JSON_VER::json_sized_array_null_no_name = typedef json_base::json_sized_array<JsonElement, SizeMember, Container, Constructor, JsonNullDefault>

◆ json_string_no_name

template<typename T = std::string, json_details::json_options_t Options = string_opts_def, typename Constructor = default_constructor<T>>
using daw::json::DAW_JSON_VER::json_string_no_name = typedef json_base::json_string<T, Options, Constructor>

◆ json_string_null

template<JSONNAMETYPE Name, typename String = std::optional<std::string>, json_details::json_options_t Options = string_opts_def, typename Constructor = nullable_constructor<String>>
using daw::json::DAW_JSON_VER::json_string_null = typedef json_string<Name, String, json_details::string_opts_set<Options, JsonNullDefault>, Constructor>

Member is a nullable escaped string and requires unescaping and escaping of string data

Template Parameters
Nameof json member
Stringresult type constructed by Constructor
Constructora callable taking as arguments ( InputIterator, InputIterator ). If others are needed use the Constructor callable convert
EmptyStringNullif string is empty, call Constructor with no arguments
EightBitModeAllow filtering of characters with the MSB set

◆ json_string_null_no_name

template<typename T = std::optional<std::string>, json_details::json_options_t Options = string_opts_def, typename Constructor = nullable_constructor<T>>
using daw::json::DAW_JSON_VER::json_string_null_no_name = typedef json_base::json_string< T, json_details::string_opts_set<Options, JsonNullDefault>, Constructor>

◆ json_string_raw_no_name

template<typename T = std::string, json_details::json_options_t Options = string_raw_opts_def, typename Constructor = default_constructor<T>>
using daw::json::DAW_JSON_VER::json_string_raw_no_name = typedef json_base::json_string_raw<T, Options, Constructor>

◆ json_string_raw_null

template<JSONNAMETYPE Name, typename String = std::optional<std::string>, json_details::json_options_t Options = string_raw_opts_def, typename Constructor = nullable_constructor<String>>
using daw::json::DAW_JSON_VER::json_string_raw_null = typedef json_string_raw< Name, String, json_details::string_raw_opts_set<Options, JsonNullDefault>, Constructor>

Member is a nullable escaped string and requires unescaping and escaping of string data. Not all invalid codepoints are detected

Template Parameters
Nameof json member
Stringresult type constructed by Constructor
Constructora callable taking as arguments ( char const *, std::size_t )
EmptyStringNullif string is empty, call Constructor with no arguments
EightBitModeAllow filtering of characters with the MSB set arguments
AllowEscapeTell parser if we know a \ or escape will be in the data

◆ json_string_raw_null_no_name

template<typename T = std::optional<std::string>, json_details::json_options_t Options = string_raw_opts_def, typename Constructor = nullable_constructor<T>>
using daw::json::DAW_JSON_VER::json_string_raw_null_no_name = typedef json_base::json_string_raw< T, json_details::string_raw_opts_set<Options, JsonNullDefault>, Constructor>

◆ json_tagged_variant_no_name

template<typename T , typename TagMember , typename Switcher , typename JsonElements = json_deduce_type, typename Constructor = default_constructor<T>, JsonNullable Nullable = JsonNullable::MustExist>
using daw::json::DAW_JSON_VER::json_tagged_variant_no_name = typedef json_base::json_tagged_variant<T, TagMember, Switcher, JsonElements, Constructor, Nullable>

◆ json_tagged_variant_null

template<JSONNAMETYPE Name, typename Variant , typename TagMember , typename Switcher , typename JsonElements = json_deduce_type, typename Constructor = nullable_constructor<Variant>>
using daw::json::DAW_JSON_VER::json_tagged_variant_null = typedef json_tagged_variant<Name, Variant, TagMember, Switcher, JsonElements, Constructor, JsonNullDefault>

◆ json_tagged_variant_null_no_name

template<typename T , typename TagMember , typename Switcher , typename JsonElements = json_deduce_type, typename Constructor = default_constructor<T>>
using daw::json::DAW_JSON_VER::json_tagged_variant_null_no_name = typedef json_base::json_tagged_variant<T, TagMember, Switcher, JsonElements, Constructor, JsonNullDefault>

◆ json_tagged_variant_type_list

template<typename... JsonElements>
using daw::json::DAW_JSON_VER::json_tagged_variant_type_list = typedef json_variant_type_list<JsonElements...>

◆ json_tuple_no_name

template<typename Tuple , typename Constructor = default_constructor<Tuple>, json_details::json_options_t Options = tuple_opts_def, typename JsonTupleTypesList = json_deduce_type>
using daw::json::DAW_JSON_VER::json_tuple_no_name = typedef json_base::json_tuple<Tuple, Constructor, Options, JsonTupleTypesList>

◆ json_tuple_null

template<JSONNAMETYPE Name, typename Tuple , typename Constructor = json_deduce_type, json_details::json_options_t Options = tuple_opts_def, typename JsonTupleTypesList = json_deduce_type>
using daw::json::DAW_JSON_VER::json_tuple_null = typedef json_tuple<Name, Tuple, Constructor, json_details::tuple_opts_set<Options, JsonNullDefault>, JsonTupleTypesList>

◆ json_tuple_null_no_name

template<typename Tuple , typename Constructor = default_constructor<Tuple>, json_details::json_options_t Options = tuple_opts_def, typename JsonTupleTypesList = json_deduce_type>
using daw::json::DAW_JSON_VER::json_tuple_null_no_name = typedef json_base::json_tuple< Tuple, Constructor, json_details::tuple_opts_set<Options, JsonNullDefault>, JsonTupleTypesList>

◆ json_value

◆ json_value_state

◆ json_variant_no_name

template<typename Variant , typename JsonElements = json_deduce_type, typename Constructor = default_constructor<Variant>, JsonNullable Nullable = JsonNullable::MustExist>
using daw::json::DAW_JSON_VER::json_variant_no_name = typedef json_base::json_variant<Variant, JsonElements, Constructor, JsonNullable::MustExist>

◆ json_variant_null

template<JSONNAMETYPE Name, typename Variant , typename JsonElements = json_deduce_type, typename Constructor = nullable_constructor<Variant>>
using daw::json::DAW_JSON_VER::json_variant_null = typedef json_variant<Name, Variant, JsonElements, Constructor, JsonNullDefault>

◆ json_variant_null_no_name

template<typename Variant , typename JsonElements = json_deduce_type, typename Constructor = nullable_constructor<Variant>>
using daw::json::DAW_JSON_VER::json_variant_null_no_name = typedef json_base::json_variant<Variant, JsonElements, Constructor, JsonNullDefault>

◆ NoCommentSkippingPolicyChecked

◆ NoCommentSkippingPolicyUnchecked

◆ NoCommentZeroSkippingPolicyChecked

◆ NoCommentZeroSkippingPolicyUnchecked

◆ number_opts_t

◆ ordered_json_member

template<std::size_t Index, typename JsonMember >
using daw::json::DAW_JSON_VER::ordered_json_member = typedef json_tuple_member<Index, JsonMember>

◆ ParseTag

template<JsonParseTypes v>
using daw::json::DAW_JSON_VER::ParseTag = typedef daw::constant<v>

Tag lookup for parsing overload selection

◆ SIMDCppCommentSkippingPolicyChecked

template<typename ExecTag , typename Allocator = json_details::NoAllocator>
using daw::json::DAW_JSON_VER::SIMDCppCommentSkippingPolicyChecked = typedef BasicParsePolicy<parse_options( PolicyCommentTypes::cpp, json_details::exec_mode_from_tag<ExecTag> ), Allocator>

◆ SIMDCppCommentSkippingPolicyUnchecked

template<typename ExecTag , typename Allocator = json_details::NoAllocator>
using daw::json::DAW_JSON_VER::SIMDCppCommentSkippingPolicyUnchecked = typedef BasicParsePolicy<parse_options( CheckedParseMode::no, PolicyCommentTypes::cpp, json_details::exec_mode_from_tag<ExecTag> ), Allocator>

◆ SIMDHashCommentSkippingPolicyChecked

template<typename ExecTag , typename Allocator = json_details::NoAllocator>
using daw::json::DAW_JSON_VER::SIMDHashCommentSkippingPolicyChecked = typedef BasicParsePolicy<parse_options( PolicyCommentTypes::hash, json_details::exec_mode_from_tag<ExecTag> ), Allocator>

◆ SIMDHashCommentSkippingPolicyUnchecked

template<typename ExecTag , typename Allocator = json_details::NoAllocator>
using daw::json::DAW_JSON_VER::SIMDHashCommentSkippingPolicyUnchecked = typedef BasicParsePolicy<parse_options( CheckedParseMode::no, PolicyCommentTypes::hash, json_details::exec_mode_from_tag<ExecTag> ), Allocator>

◆ SIMDNoCommentSkippingPolicyChecked

template<typename ExecTag , typename Allocator = json_details::NoAllocator>
using daw::json::DAW_JSON_VER::SIMDNoCommentSkippingPolicyChecked = typedef BasicParsePolicy< parse_options( json_details::exec_mode_from_tag<ExecTag> ), Allocator>

◆ SIMDNoCommentSkippingPolicyUnchecked

template<typename ExecTag , typename Allocator = json_details::NoAllocator>
using daw::json::DAW_JSON_VER::SIMDNoCommentSkippingPolicyUnchecked = typedef BasicParsePolicy<parse_options( CheckedParseMode::no, json_details::exec_mode_from_tag<ExecTag> ), Allocator>

◆ string_opts_t

◆ string_raw_opts_t

◆ test_valid_json_data_contract_trait_t

template<typename T >
using daw::json::DAW_JSON_VER::test_valid_json_data_contract_trait_t = typedef typename json_data_contract_trait_t<T>::i_am_a_json_member_list

◆ tuple_opts_t

Enumeration Type Documentation

◆ AllowEscapeCharacter

enum class daw::json::DAW_JSON_VER::AllowEscapeCharacter : unsigned
strong
Enumerator
Allow 
NotBeforeDblQuote 

Full string processing to skip escaped characters.

◆ AllowEscapedNames

enum class daw::json::DAW_JSON_VER::AllowEscapedNames : unsigned
strong
Enumerator
no 
yes 

◆ CheckedParseMode

enum class daw::json::DAW_JSON_VER::CheckedParseMode : unsigned
strong
Enumerator
yes 
no 

◆ EightBitModes

enum class daw::json::DAW_JSON_VER::EightBitModes : unsigned
strong
Enumerator
DisallowHigh 
AllowFull 

◆ EmptyStringNull

enum class daw::json::DAW_JSON_VER::EmptyStringNull : unsigned
strong
Enumerator
no 
yes 

◆ ExcludeSpecialEscapes

enum class daw::json::DAW_JSON_VER::ExcludeSpecialEscapes : unsigned
strong
Enumerator
no 
yes 

◆ ExecModeTypes

enum class daw::json::DAW_JSON_VER::ExecModeTypes : unsigned
strong
Enumerator
compile_time 
runtime 
simd 

◆ ExpectLongStrings

enum class daw::json::DAW_JSON_VER::ExpectLongStrings : unsigned
strong
Enumerator
no 
yes 

◆ ForceFullNameCheck

enum class daw::json::DAW_JSON_VER::ForceFullNameCheck : unsigned
strong
Enumerator
no 
yes 

◆ FPOutputFormat

enum class daw::json::DAW_JSON_VER::FPOutputFormat : unsigned
strong
Enumerator
Auto 
Scientific 

◆ IEEE754Precise

enum class daw::json::DAW_JSON_VER::IEEE754Precise : unsigned
strong
Enumerator
no 
yes 

◆ IndentationType

enum class daw::json::DAW_JSON_VER::IndentationType : unsigned
strong
Enumerator
Tab 
Space0 
Space1 
Space2 
Space3 
Space4 
Space5 
Space8 

◆ json_parse_handler_result

Enumerator
Continue 
SkipClassArray 
Complete 

◆ JsonBaseParseTypes

enum class daw::json::DAW_JSON_VER::JsonBaseParseTypes : std::uint_fast8_t
strong

The fundamental JSON types.

Enumerator
Number 
Bool 
String 
Class 
Array 
Null 
None 

◆ JsonCustomTypes

enum class daw::json::DAW_JSON_VER::JsonCustomTypes : unsigned
strong
Enumerator
String 
Literal 
Any 

◆ JsonNullable

enum class daw::json::DAW_JSON_VER::JsonNullable : unsigned
strong
Enumerator
MustExist 
Nullable 
NullVisible 

◆ JsonNumberErrors

enum class daw::json::DAW_JSON_VER::JsonNumberErrors : unsigned
strong
Enumerator
None 
AllowNaN 
AllowInf 
AllowNanInf 

◆ JsonParseTypes

enum class daw::json::DAW_JSON_VER::JsonParseTypes : std::uint_fast8_t
strong

The tags used by the parser to determine what parser to call.

Enumerator
Real 
Signed 

Number - Floating Point.

Unsigned 

Number - Signed Integer.

Bool 

Number - Unsigned Integer.

StringRaw 

Boolean.

StringEscaped 

String - A raw string as is. Escapes are left in.

Date 

String - Fully processed string.

Class 

ISO 8601 Timestamp.

Array 

A class type with named members.

SizedArray 

An array type with homogenous members.

Null 

An array with a fixed size. This allows for size_t/ptr like combinations.

KeyValue 

A null member.

KeyValueArray 

Class - Member names form the string key into a key/value,map, or dictionary like type.

Custom 

Array - Each element has a key and a value submember.

Variant 

Can be a literal, string, or either and allows for some customized parsing.

VariantTagged 

Any one of the basic json types class/array/boolean/number/string.

VariantIntrusive 

A variant with up to N types and a Switcher callable that takes uses another member to determine what type to parse. This is often a type/value like pair.

Tuple 

A variant type where the Switcher is based on a submember of the class being parsed.

Unknown 

Array - An array type where each element is mapped to the member of a C++ class.

◆ JsonRangeCheck

enum class daw::json::DAW_JSON_VER::JsonRangeCheck : unsigned
strong
Enumerator
Never 
CheckForNarrowing 

◆ LiteralAsStringOpt

enum class daw::json::DAW_JSON_VER::LiteralAsStringOpt : unsigned
strong

Allows having literals parse that are encoded as strings. It allows one to have it be Never true, Maybe true or Always true. This controls whether the parser will Never remove quotes, check if quotes exist, or Always remove quotes around the literal

Enumerator
Never 
Maybe 
Always 

◆ MinifiedDocument

enum class daw::json::DAW_JSON_VER::MinifiedDocument : unsigned
strong
Enumerator
no 
yes 

◆ MustVerifyEndOfDataIsValid

Enumerator
no 
yes 

◆ NewLineDelimiter

enum class daw::json::DAW_JSON_VER::NewLineDelimiter : unsigned
strong
Enumerator
rn 

◆ OutputTrailingComma

enum class daw::json::DAW_JSON_VER::OutputTrailingComma : unsigned
strong
Enumerator
No 
Yes 

◆ PolicyCommentTypes

enum class daw::json::DAW_JSON_VER::PolicyCommentTypes : unsigned
strong
Enumerator
none 
cpp 
hash 

◆ RestrictedStringOutput

Enumerator
None 
OnlyAllow7bitsStrings 

◆ SerializationFormat

enum class daw::json::DAW_JSON_VER::SerializationFormat : unsigned
strong
Enumerator
Minified 
Pretty 

◆ StackParseStateType

Enumerator
Class 
Array 

◆ TemporarilyMutateBuffer

Enumerator
no 
yes 

◆ UseExactMappingsByDefault

Enumerator
no 
yes 

◆ ZeroTerminatedString

enum class daw::json::DAW_JSON_VER::ZeroTerminatedString : unsigned
strong
Enumerator
no 
yes 

Function Documentation

◆ basic_json_value()

template<typename ParseState >
daw::json::DAW_JSON_VER::basic_json_value ( ParseState  ) -> basic_json_value< ParseState >

◆ basic_json_value_iterator_range()

template<typename ParseState >
daw::json::DAW_JSON_VER::basic_json_value_iterator_range ( basic_json_value_iterator< ParseState >  ,
basic_json_value_iterator< ParseState >   
) -> basic_json_value_iterator_range< ParseState >

◆ bool_opt()

template<typename... Options>
constexpr json_details::json_options_t daw::json::DAW_JSON_VER::bool_opt ( Options...  options)
constexpr

◆ class_opt()

template<typename... Options>
constexpr json_details::json_options_t daw::json::DAW_JSON_VER::class_opt ( Options...  options)
constexpr

◆ daw_json_error() [1/6]

template<bool ShouldThrow = use_daw_json_exceptions_v>
DAW_ATTRIB_NOINLINE void daw::json::DAW_JSON_VER::daw_json_error ( ErrorReason  reason)

◆ daw_json_error() [2/6]

template<bool ShouldThrow = use_daw_json_exceptions_v, typename ParseState >
static DAW_ATTRIB_NOINLINE void daw::json::DAW_JSON_VER::daw_json_error ( ErrorReason  reason,
ParseState const &  location 
)
static

◆ daw_json_error() [3/6]

template<bool ShouldThrow = use_daw_json_exceptions_v>
static DAW_ATTRIB_NOINLINE void daw::json::DAW_JSON_VER::daw_json_error ( json_details::missing_member  reason)
static

◆ daw_json_error() [4/6]

template<bool ShouldThrow = use_daw_json_exceptions_v, typename ParseState >
static DAW_ATTRIB_NOINLINE void daw::json::DAW_JSON_VER::daw_json_error ( json_details::missing_member  reason,
ParseState const &  location 
)
static

◆ daw_json_error() [5/6]

template<bool ShouldThrow = use_daw_json_exceptions_v>
static DAW_ATTRIB_NOINLINE void daw::json::DAW_JSON_VER::daw_json_error ( json_details::missing_token  reason)
static

◆ daw_json_error() [6/6]

template<bool ShouldThrow = use_daw_json_exceptions_v, typename ParseState >
static DAW_ATTRIB_NOINLINE void daw::json::DAW_JSON_VER::daw_json_error ( json_details::missing_token  reason,
ParseState const &  location 
)
static

◆ find_column_number_of() [1/2]

constexpr std::size_t daw::json::DAW_JSON_VER::find_column_number_of ( char const *  doc_pos,
char const *  doc_start 
)
constexpr

◆ find_column_number_of() [2/2]

constexpr std::size_t daw::json::DAW_JSON_VER::find_column_number_of ( json_path_node const &  node,
char const *  doc_start 
)
constexpr

◆ find_json_path_stack_to() [1/2]

std::vector< json_path_node > daw::json::DAW_JSON_VER::find_json_path_stack_to ( char const *  parse_location,
char const *  doc_start 
)
inline

Get the json_path_nodes representing the path to the nearest value's position in the document.

Parameters
parse_locationThe position in the document to find
doc_startA pointer to the stat of the JSON document

◆ find_json_path_stack_to() [2/2]

std::vector< json_path_node > daw::json::DAW_JSON_VER::find_json_path_stack_to ( json_exception const &  jex,
char const *  doc_start 
)
inline

◆ find_json_path_to() [1/2]

std::string daw::json::DAW_JSON_VER::find_json_path_to ( char const *  parse_location,
char const *  doc_start 
)
inline

◆ find_json_path_to() [2/2]

std::string daw::json::DAW_JSON_VER::find_json_path_to ( json_exception const &  jex,
char const *  doc_start 
)
inline

◆ find_line_number_of() [1/2]

constexpr std::size_t daw::json::DAW_JSON_VER::find_line_number_of ( char const *  doc_pos,
char const *  doc_start 
)
constexpr

◆ find_line_number_of() [2/2]

constexpr std::size_t daw::json::DAW_JSON_VER::find_line_number_of ( json_path_node const &  node,
char const *  doc_start 
)
constexpr

◆ from_json() [1/4]

template<typename JsonMember , typename ParsePolicy , bool KnownBounds, typename Result , typename ParseState >
constexpr Result daw::json::DAW_JSON_VER::from_json ( basic_json_value< ParseState >  value)
inlineconstexpr

◆ from_json() [2/4]

template<typename JsonMember , typename ParsePolicy , bool KnownBounds, typename Result , typename ParseState >
constexpr Result daw::json::DAW_JSON_VER::from_json ( basic_json_value< ParseState >  value,
std::string_view  member_path 
)
constexpr

◆ from_json() [3/4]

template<typename JsonMember , typename ParsePolicy , bool KnownBounds, typename Result , typename String >
constexpr auto daw::json::DAW_JSON_VER::from_json ( String &&  json_data) -> std::enable_if_t< json_details::is_string_view_like_v< String >, Result >
constexpr

Construct the JSONMember from the JSON document argument.

Template Parameters
JsonMemberany bool, arithmetic, string, string_view, daw::json::json_data_contract
Parameters
json_dataJSON string data
Template Parameters
KnownBoundsThe bounds of the json_data are known to contain the whole value
Returns
A reified T constructed from JSON data
Exceptions
daw::json::json_exception

Construct the JSONMember from the JSON document argument.

Template Parameters
JsonMemberany bool, arithmetic, string, string_view, daw::json::json_data_contract
Parameters
json_dataJSON string data
Template Parameters
KnownBoundsThe bounds of the json_data are known to contain the whole value
ParsePolicyParse policy used while parsing. Default is with checking and no comments
Returns
A reified JSONMember constructed from JSON data
Exceptions
daw::json::json_exception

◆ from_json() [4/4]

template<typename JsonMember , typename ParsePolicy , bool KnownBounds, typename Result , typename String >
constexpr auto daw::json::DAW_JSON_VER::from_json ( String &&  json_data,
std::string_view  member_path 
) -> std::enable_if_t< json_details::is_string_view_like_v< String >, Result >
constexpr

◆ from_json_alloc() [1/2]

template<typename JsonMember , typename ParsePolicy , bool KnownBounds, typename Result , typename String , typename Allocator >
constexpr auto daw::json::DAW_JSON_VER::from_json_alloc ( String &&  json_data,
Allocator const &  alloc 
) -> std::enable_if_t< json_details::is_string_view_like_v< String >, Result >
constexpr

Construct the JSONMember from the JSON document argument.

Template Parameters
JsonMemberany bool, arithmetic, string, string_view, daw::json::json_data_contract
Parameters
json_dataJSON string data
Template Parameters
KnownBoundsThe bounds of the json_data are known to contain the whole value
Returns
A reified T constructed from JSON data
Exceptions
daw::json::json_exception

◆ from_json_alloc() [2/2]

template<typename JsonMember , typename ParsePolicy , bool KnownBounds, typename Result , typename String , typename Allocator >
constexpr auto daw::json::DAW_JSON_VER::from_json_alloc ( String &&  json_data,
std::string_view  member_path,
Allocator const &  alloc 
) -> std::enable_if_t< json_details::is_string_view_like_v< String >, Result >
constexpr

◆ from_json_array()

template<typename JsonElement , typename Container , typename ParsePolicy , typename Constructor , bool KnownBounds, typename String >
constexpr auto daw::json::DAW_JSON_VER::from_json_array ( String &&  json_data,
std::string_view  member_path 
) -> std::enable_if_t< json_details::is_string_view_like_v< String >, Container >
constexpr

Parse JSON data where the root item is an array

Template Parameters
JsonElementThe type of each element in array. Must be one of the above json_XXX classes. This version is checked
ContainerContainer to store values in
ConstructorCallable to construct Container with no arguments
Parameters
json_dataJSON string data containing array
member_pathA dot separated path of member names to start parsing from. Array indices are specified with square brackets e.g. [5] is the 6th item
Template Parameters
KnownBoundsThe bounds of the json_data are known to contain the whole value
Returns
A Container containing parsed data from JSON string
Exceptions
daw::json::json_exception

◆ get() [1/3]

template<std::size_t Idx, typename ParseState >
constexpr decltype(auto) daw::json::DAW_JSON_VER::get ( basic_json_pair< ParseState > &&  parse_state)
constexpr

◆ get() [2/3]

template<std::size_t Idx, typename ParseState >
constexpr decltype(auto) daw::json::DAW_JSON_VER::get ( basic_json_pair< ParseState > &  parse_state)
constexpr

◆ get() [3/3]

template<std::size_t Idx, typename ParseState >
constexpr decltype(auto) daw::json::DAW_JSON_VER::get ( basic_json_pair< ParseState > const &  parse_state)
constexpr

◆ json_custom_opt()

template<typename... Options>
constexpr json_details::json_options_t daw::json::DAW_JSON_VER::json_custom_opt ( Options...  options)
constexpr

◆ json_event_parser() [1/2]

template<typename ParseState = NoCommentSkippingPolicyChecked, typename StackContainerPolicy = DefaultJsonEventParserStackPolicy< JsonEventParserStackValue<ParseState>>, typename Handler >
constexpr void daw::json::DAW_JSON_VER::json_event_parser ( basic_json_value< ParseState >  jvalue,
Handler &&  handler 
)
inlineconstexpr

◆ json_event_parser() [2/2]

template<typename ParsePolicy = NoCommentSkippingPolicyChecked, typename Handler >
void daw::json::DAW_JSON_VER::json_event_parser ( std::string_view  json_document,
Handler &&  handler 
)
inline

◆ json_link_version()

constexpr std::string_view daw::json::DAW_JSON_VER::json_link_version ( )
constexpr

◆ number_opt()

template<typename... Options>
constexpr json_details::json_options_t daw::json::DAW_JSON_VER::number_opt ( Options...  options)
constexpr

◆ parse_options()

template<typename... Policies>
constexpr json_details::json_options_t daw::json::DAW_JSON_VER::parse_options ( Policies...  policies)
constexpr

◆ serialize_options()

template<typename... Policies>
constexpr json_details::json_options_t daw::json::DAW_JSON_VER::serialize_options ( Policies...  policies)
constexpr

◆ string_opt()

template<typename... Options>
constexpr json_details::json_options_t daw::json::DAW_JSON_VER::string_opt ( Options...  options)
constexpr

◆ string_raw_opt()

template<typename... Options>
constexpr json_details::json_options_t daw::json::DAW_JSON_VER::string_raw_opt ( Options...  options)
constexpr

◆ to_json() [1/2]

template<typename Result , typename Value , typename JsonClass , typename SerializationPolicy >
constexpr Result daw::json::DAW_JSON_VER::to_json ( Value const &  value)
constexpr

Serialize a value to JSON. Some types(std::string, string_view. integer's and floating point numbers do not need a mapping setup). For user classes, a json_data_contract specialization is needed.

Template Parameters
Resultstd::string like type to put result into
JsonClassType that has json_parser_description and to_json_data function overloads
Parameters
valuevalue to serialize
Returns
JSON string data

◆ to_json() [2/2]

template<typename Value , typename JsonClass , typename OutputIterator >
constexpr OutputIterator daw::json::DAW_JSON_VER::to_json ( Value const &  value,
OutputIterator  out_it 
)
constexpr
Template Parameters
OutputIteratorIterator to character data to
JsonClassType that has json_parser_description and to_json_data function overloads
Parameters
valuevalue to serialize
out_itresult to serialize to

◆ to_json_array() [1/2]

template<typename Result , typename JsonElement , typename SerializationPolicy , typename Container >
constexpr Result daw::json::DAW_JSON_VER::to_json_array ( Container &&  c)
constexpr

Serialize a container to JSON. This convenience method allows for easier serialization of containers when the root of the document is an array Serialize Container

Template Parameters
ContainerType of Container to serialize the elements of
Parameters
cContainer containing data to serialize.
Returns
A std::string containing the serialized elements of c

◆ to_json_array() [2/2]

template<typename JsonElement , typename Container , typename OutputIterator >
constexpr OutputIterator daw::json::DAW_JSON_VER::to_json_array ( Container const &  c,
OutputIterator  out_it 
)
constexpr

Serialize a container to JSON. This convenience method allows for easier serialization of containers when the root of the document is an array Serialize Container

Template Parameters
ContainerType of Container to serialize the elements of
OutputIteratorIterator to write data to
Parameters
cContainer containing data to serialize.
Returns
OutputIterator with final state of iterator

◆ to_json_path_string()

std::string daw::json::DAW_JSON_VER::to_json_path_string ( std::vector< json_path_node > const &  path_stack)
inline

Convert a json_path_node stack to a JSON Path string.

Parameters
path_stackA vector with json_path_nodes representing the path in the JSON document tree
Returns
A string in JSON Path format

◆ to_string()

constexpr std::string_view daw::json::DAW_JSON_VER::to_string ( JsonBaseParseTypes  pt)
constexpr

◆ tuple_opt()

template<typename... Options>
constexpr json_details::json_options_t daw::json::DAW_JSON_VER::tuple_opt ( Options...  options)
constexpr

Variable Documentation

◆ bool_opts

constexpr auto daw::json::DAW_JSON_VER::bool_opts = bool_opts_t{ }
inlineconstexpr

◆ bool_opts_def

constexpr json_details::json_options_t daw::json::DAW_JSON_VER::bool_opts_def
inlineconstexpr
Initial value:
=
static constexpr json_options_t default_option_flag
Definition: daw_json_option_bits.h:208

◆ class_opts

constexpr auto daw::json::DAW_JSON_VER::class_opts = class_opts_t{ }
inlineconstexpr

◆ class_opts_def

constexpr json_details::json_options_t daw::json::DAW_JSON_VER::class_opts_def
inlineconstexpr

◆ force_aggregate_construction_v

template<typename T >
constexpr bool daw::json::DAW_JSON_VER::force_aggregate_construction_v
inlineconstexpr
Initial value:
=
std::bool_constant< std::disjunction_v< daw::is_detected< json_details::force_aggregate_construction_test, T >, daw::is_detected< json_details::force_aggregate_construction_test2, T > > > force_aggregate_construction
Definition: daw_json_traits.h:176

◆ ignore_unknown_members_v

template<typename T >
constexpr bool daw::json::DAW_JSON_VER::ignore_unknown_members_v
inlineconstexpr
Initial value:
= std::disjunction<
daw::is_detected<
typename json_data_contract< T >::ignore_unknown_members has_ignore_unknown_members_trait_in_class_map
Definition: daw_json_traits.h:617
Definition: daw_json_traits.h:608

◆ is_default_constructor_v

template<typename T >
constexpr bool daw::json::DAW_JSON_VER::is_default_constructor_v
inlineconstexpr

◆ is_empty_pack_v

template<typename... Ts>
constexpr bool daw::json::DAW_JSON_VER::is_empty_pack_v = is_empty_pack<Ts...>::value
inlineconstexpr

◆ is_exact_class_mapping_v

template<typename T >
constexpr bool daw::json::DAW_JSON_VER::is_exact_class_mapping_v
inlineconstexpr
Initial value:
= std::disjunction<
T>>::value
typename json_data_contract< T >::exact_class_mapping has_exact_mapping_trait_in_class_map
Definition: daw_json_traits.h:613
Definition: daw_json_traits.h:601

◆ is_zero_terminated_string_v

template<typename T >
constexpr bool daw::json::DAW_JSON_VER::is_zero_terminated_string_v
inlineconstexpr

◆ json_custom_opts

constexpr auto daw::json::DAW_JSON_VER::json_custom_opts = json_custom_opts_t{ }
inlineconstexpr

◆ json_custom_opts_def

constexpr json_details::json_options_t daw::json::DAW_JSON_VER::json_custom_opts_def
inlineconstexpr

◆ JsonNullDefault

constexpr JsonNullable daw::json::DAW_JSON_VER::JsonNullDefault = JsonNullable::Nullable
inlineconstexpr

◆ no_name

constexpr char const daw::json::DAW_JSON_VER::no_name[] = "\a"
inlineconstexpr

◆ no_name_sv

constexpr daw::string_view daw::json::DAW_JSON_VER::no_name_sv = daw::string_view( no_name )
inlineconstexpr

◆ number_opts

constexpr auto daw::json::DAW_JSON_VER::number_opts = number_opts_t{ }
inlineconstexpr

◆ number_opts_def

constexpr json_details::json_options_t daw::json::DAW_JSON_VER::number_opts_def
inlineconstexpr

◆ string_opts

constexpr auto daw::json::DAW_JSON_VER::string_opts = string_opts_t{ }
inlineconstexpr

◆ string_opts_def

constexpr json_details::json_options_t daw::json::DAW_JSON_VER::string_opts_def
inlineconstexpr

◆ string_raw_opts

constexpr auto daw::json::DAW_JSON_VER::string_raw_opts = string_raw_opts_t{ }
inlineconstexpr

◆ string_raw_opts_def

constexpr json_details::json_options_t daw::json::DAW_JSON_VER::string_raw_opts_def
inlineconstexpr

◆ tuple_opts

constexpr auto daw::json::DAW_JSON_VER::tuple_opts = tuple_opts_t{ }
inlineconstexpr

◆ tuple_opts_def

constexpr json_details::json_options_t daw::json::DAW_JSON_VER::tuple_opts_def
inlineconstexpr