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

Namespaces

 datetime
 
 DAW_JSON_VER
 
 details
 
 from_json_conv_details
 
 json_base
 
 json_details
 
 parse_policy_details
 
 parse_utils
 
 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_exact_class_mapping
 
struct  is_pointer_like
 
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_key_value
 
struct  json_key_value_array
 
struct  json_member_list
 
struct  json_member_name
 
struct  json_number
 
struct  json_ordered_member_list
 
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
 
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  ordered_json_member
 
struct  runtime_exec_tag
 
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, AllowEscapedNames::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 JsonElement , typename Container = std::vector< typename json_details::json_deduced_type<JsonElement>::parse_to_t>, typename Constructor = default_constructor<Container>, JsonNullable Nullable = JsonNullable::MustExist>
using json_array_no_name = json_base::json_array< JsonElement, Container, Constructor, Nullable >
 
template<JSONNAMETYPE Name, typename JsonElement , typename Container = std::vector< typename json_details::json_deduced_type<JsonElement>::parse_to_t>, typename Constructor = nullable_constructor<Container>>
using json_array_null = json_array< Name, JsonElement, Container, Constructor, JsonNullDefault >
 
template<typename JsonElement , typename Container = std::vector< typename json_details::json_deduced_type<JsonElement>::parse_to_t>, typename Constructor = nullable_constructor<Container>>
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 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 >
 
template<typename T >
using json_link_no_name = json_details::ensure_mapped_t< json_details::json_deduced_type< T > >
 
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 >
 
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 = std::vector< typename json_details::json_deduced_type<JsonElement>::parse_to_t>, typename Constructor = default_constructor<Container>, 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 = std::vector< typename json_details::json_deduced_type<JsonElement>::parse_to_t>, typename Constructor = nullable_constructor<Container>>
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_details:: determine_variant_element_types<JsonNullable::MustExist, T>, 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 T , typename TagMember , typename Switcher , typename JsonElements = json_details::determine_variant_element_types<JsonNullDefault, T>, typename Constructor = nullable_constructor<T>>
using json_tagged_variant_null = json_tagged_variant< Name, T, TagMember, Switcher, JsonElements, Constructor, JsonNullDefault >
 
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_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>
using json_tuple_no_name = json_base::json_tuple< Tuple, Constructor, Options >
 
template<JSONNAMETYPE Name, typename Tuple , typename Constructor = default_constructor<Tuple>, json_details::json_options_t Options = tuple_opts_def>
using json_tuple_null = json_tuple< Name, Tuple, Constructor, json_details::tuple_opts_set< Options, JsonNullDefault > >
 
template<typename Tuple , typename Constructor = default_constructor<Tuple>, json_details::json_options_t Options = tuple_opts_def>
using json_tuple_null_no_name = json_base::json_tuple< Tuple, Constructor, json_details::tuple_opts_set< Options, JsonNullDefault > >
 
using json_value = basic_json_value< NoCommentSkippingPolicyChecked >
 
using json_value_state = basic_stateful_json_value< NoCommentSkippingPolicyChecked >
 
template<typename T , typename JsonElements , typename Constructor = default_constructor<T>, JsonNullable Nullable = JsonNullable::MustExist>
using json_variant_no_name = json_base::json_variant< T, JsonElements, Constructor, JsonNullable::MustExist >
 
template<JSONNAMETYPE Name, typename T , typename JsonElements = json_details::determine_variant_element_types<JsonNullDefault, T>, typename Constructor = nullable_constructor<T>>
using json_variant_null = json_variant< Name, T, JsonElements, Constructor, JsonNullDefault >
 
template<typename T , typename JsonElements , typename Constructor = nullable_constructor<T>>
using json_variant_null_no_name = json_base::json_variant< T, 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 >
 
template<JsonParseTypes v>
using ParseTag = std::integral_constant< JsonParseTypes, 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  ForceFullNameCheck : unsigned { no , yes }
 
enum class  IEEE754Precise : unsigned { no , yes }
 
enum  json_parse_handler_result { Continue , SkipClassArray , Complete }
 
enum class  JsonBaseParseTypes : std::uint_fast8_t {
  Number , Bool , String , Class ,
  Array , Null , None
}
 
enum class  JsonCustomTypes : unsigned { String , Literal , Any }
 
enum class  JsonNullable : unsigned { MustExist , Nullable , NullVisible }
 
enum class  JsonParseTypes : std::uint_fast8_t {
  Real , Signed , Unsigned , Bool ,
  StringRaw , StringEscaped , Date , Class ,
  Array , SizedArray , Null , KeyValue ,
  KeyValueArray , Custom , Variant , VariantTagged ,
  Tuple , Unknown
}
 
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  PolicyCommentTypes : unsigned { none , cpp , hash }
 
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_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)
 
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 Real , typename OutputIterator >
constexpr OutputIterator real2string (Real const &value, OutputIterator out_it)
 
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 >
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 Container >
constexpr Result to_json_array (Container &&c)
 
template<typename JsonElement , typename Container , typename OutputIterator >
constexpr OutputIterator to_json_array (Container const &c, OutputIterator out_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_exact_class_mapping_v
 
template<typename >
constexpr bool is_zero_terminated_string_v = false
 
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 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