Customization point traits. More...

Namespaces
	anonymous_namespace{daw_container_traits.h}

	anonymous_namespace{daw_container_traits_fwd.h}

	anonymous_namespace{daw_count_digits.h}

	anonymous_namespace{daw_fp_fallback.h}

	anonymous_namespace{daw_from_json.h}

	anonymous_namespace{daw_from_json_fwd.h}

	anonymous_namespace{daw_json_allocator_wrapper.h}

	anonymous_namespace{daw_json_alternate_mapping.h}

	anonymous_namespace{daw_json_apply.h}

	anonymous_namespace{daw_json_arrow_proxy.h}

	anonymous_namespace{daw_json_assert.h}

	anonymous_namespace{daw_json_container_appender.h}

	anonymous_namespace{daw_json_data_contract.h}

	anonymous_namespace{daw_json_default_constuctor.h}

	anonymous_namespace{daw_json_default_constuctor_fwd.h}

	anonymous_namespace{daw_json_enums.h}

	anonymous_namespace{daw_json_event_parser.h}

	anonymous_namespace{daw_json_exec_modes.h}

	anonymous_namespace{daw_json_find_path.h}

	anonymous_namespace{daw_json_find_result.h}

	anonymous_namespace{daw_json_iostream.h}

	anonymous_namespace{daw_json_iterator.h}

	anonymous_namespace{daw_json_lines_iterator.h}

	anonymous_namespace{daw_json_link.h}

	anonymous_namespace{daw_json_link_types.h}

	anonymous_namespace{daw_json_link_types_aggregate.h}

	anonymous_namespace{daw_json_link_types_fwd.h}

	anonymous_namespace{daw_json_link_types_iso8601.h}

	anonymous_namespace{daw_json_location_info.h}

	anonymous_namespace{daw_json_name.h}

	anonymous_namespace{daw_json_option_bits.h}

	anonymous_namespace{daw_json_parse_array_iterator.h}

	anonymous_namespace{daw_json_parse_class.h}

	anonymous_namespace{daw_json_parse_common.h}

	anonymous_namespace{daw_json_parse_digit.h}

	anonymous_namespace{daw_json_parse_iso8601_utils.h}

	anonymous_namespace{daw_json_parse_kv_array_iterator.h}

	anonymous_namespace{daw_json_parse_kv_class_iterator.h}

	anonymous_namespace{daw_json_parse_name.h}

	anonymous_namespace{daw_json_parse_options.h}

	anonymous_namespace{daw_json_parse_options_impl.h}

	anonymous_namespace{daw_json_parse_policy.h}

	anonymous_namespace{daw_json_parse_policy_cpp_comments.h}

	anonymous_namespace{daw_json_parse_policy_hash_comments.h}

	anonymous_namespace{daw_json_parse_policy_no_comments.h}

	anonymous_namespace{daw_json_parse_policy_policy_details.h}

	anonymous_namespace{daw_json_parse_real.h}

	anonymous_namespace{daw_json_parse_real_power10.h}

	anonymous_namespace{daw_json_parse_std_string.h}

	anonymous_namespace{daw_json_parse_string_need_slow.h}

	anonymous_namespace{daw_json_parse_string_quote.h}

	anonymous_namespace{daw_json_parse_unsigned_int.h}

	anonymous_namespace{daw_json_parse_value.h}

	anonymous_namespace{daw_json_parse_value_fwd.h}

	anonymous_namespace{daw_json_serialize_impl.h}

	anonymous_namespace{daw_json_serialize_options.h}

	anonymous_namespace{daw_json_serialize_options_impl.h}

	anonymous_namespace{daw_json_serialize_policy.h}

	anonymous_namespace{daw_json_serialize_policy_details.h}

	anonymous_namespace{daw_json_skip.h}

	anonymous_namespace{daw_json_string_util.h}

	anonymous_namespace{daw_json_traits.h}

	anonymous_namespace{daw_json_type_options.h}

	anonymous_namespace{daw_json_value.h}

	anonymous_namespace{daw_json_value_fwd.h}

	anonymous_namespace{daw_json_value_state.h}

	anonymous_namespace{daw_not_const_ex_functions.h}

	anonymous_namespace{daw_nullable_value.h}

	anonymous_namespace{daw_nullable_value_fwd.h}

	anonymous_namespace{daw_to_json.h}

	anonymous_namespace{daw_to_json_fwd.h}

	anonymous_namespace{daw_writable_output_basics.h}

	anonymous_namespace{daw_writable_output_cstdio.h}

	anonymous_namespace{daw_writable_output_details.h}

	anonymous_namespace{daw_writable_output_fwd.h}

	anonymous_namespace{daw_writable_output_ostream.h}

	anonymous_namespace{power_of_five_128_table.h}

	anonymous_namespace{to_daw_json_string.h}

	concepts

	datetime

	inline

	json_base

	literals

	options

	parse_utils

	utils

Classes
struct	basic_appender

struct	basic_json_pair
	A name/value pair of string_view/json_value. More...

struct	basic_json_value
	A non-owning container for arbitrary JSON values that allows movement/iteration through. More...

struct	basic_json_value_iterator
	Iterator for iterating over arbitrary JSON members and array elements. More...

struct	basic_json_value_iterator_range
	a rudimentary range object for holding basic_json_value_iterator More...

class	basic_stateful_json_value

struct	BasicParsePolicy
	Handles the bounds and policy items for parsing execution and comments. More...

struct	constexpr_exec_tag

struct	construct_from_iso8601_timestamp

struct	construct_from_iso8601_timestamp< std::chrono::time_point< Clock, Duration > >

class	CppCommentSkippingPolicy

struct	default_constructor
	Default Constructor for a type. It accounts for aggregate types and uses brace construction for them. More...

struct	default_constructor< json_alt< T, I > >
	Default constructor for json_alt is to construct the base type. More...

struct	default_constructor< std::array< T, Sz > >
	Default constructor type for std::array and allows (Iterator, Iterator) construction. More...

struct	default_constructor< std::unordered_map< Key, T, Hash, CompareEqual, Alloc > >
	default constructor for std::unordered_map. Allows construction via (Iterator, Iterator, Allocator) More...

struct	default_constructor< std::vector< T, Alloc > >
	Default constructor type for std::vector. It will reserve up front for non-random iterators. More...

struct	default_from_json_converter_t

struct	default_to_json_converter_t

class	DefaultJsonEventParserStackPolicy

struct	DefaultParsePolicy

class	HashCommentSkippingPolicy

struct	json_alt
	Allows for alternate/multiple mappings of types that already have mappings. More...

struct	json_array

class	json_array_iterator_once
	Iterator for iterating over JSON array's. Requires that op op++ be called in that sequence one time until end is reached. More...

class	json_array_iterator_t

struct	json_array_range
	A range of json_array_iterators. More...

struct	json_array_range_once
	A range of json_array_iterator_onces. Requires that op*‍/op++ be called in that sequence one time untl end is reached. More...

struct	json_bool

struct	json_class

struct	json_custom
	Allow parsing of a type that does not fit. More...

struct	json_data_contract
	Mapping class for JSON data structures to C++. It must be specialized in order to parse to a user class. More...

struct	json_data_contract< basic_json_value< PolicyFlags, Allocator > >

struct	json_data_contract< T >

struct	json_data_contract< tuple_json_mapping< Members... > >

struct	json_date

struct	json_intrusive_variant

struct	json_key_value

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

class	json_lines_iterator
	Iterator for iterating over JSON array's. More...

struct	json_lines_range
	A range of json_lines_iterators. More...

struct	json_member_list

struct	json_member_name

struct	json_nullable

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

struct	json_tuple_member

struct	json_tuple_member_list
	Allow extracting elements from a JSON array and constructing from it. Members can be either normal C++ no_name members, or an ordered_member with a position. All ordered members must have a value greater than the previous. The first element in the list, unless it is specified as an ordered_member, is 0. A non-ordered_member item will be 1 more than the previous item in the list. All items must have an index greater than the previous. In Javascript these are also called tuples. More...

struct	json_tuple_types_list

struct	json_type_alias

struct	json_variant

struct	json_variant_type_list

struct	JsonEventParserStackValue

struct	missing_json_data_contract_for_or_unknown_type
	This class is used as a way to indicate that a json_data_contract specialization has not been done for a user class. More...

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
	Default constructor for nullable types. Specializations must accept accept an operator( )( ) that signifies a JSON null. Any other arguments only need to be valid to construct the type. More...

struct	nullable_constructor< T DAW_JSON_ENABLEIF_S(concepts::is_nullable_value_v< T >)>
	Default constructor for readable nullable types. More...

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< options::LiteralAsStringOpt >

template<typename T >
using	can_single_allocation_string = std::bool_constant< can_single_allocation_string_v< T > >

using	daw_json_error_handler_t = daw::not_null< void()(json_exception &&, void )>

using	default_exec_tag = constexpr_exec_tag

template<json_options_t PolicyFlags = json_details::default_policy_flag, typename Allocator = json_details::NoAllocator>
using	GetParsePolicy = daw::conditional_t<(PolicyFlags==json_details::default_policy_flag and std::is_same_v< Allocator, json_details::NoAllocator >), DefaultParsePolicy, BasicParsePolicy< PolicyFlags, Allocator > >

template<typename T >
using	is_zero_terminated_string = std::bool_constant< is_zero_terminated_string_v< T > >

template<typename JsonElement , auto... PolicyFlags>
using	json_array_iterator = json_array_iterator_t< JsonElement, TryDefaultParsePolicy< BasicParsePolicy< options::details::make_parse_flags< PolicyFlags... >().value > >>

template<typename JsonElement , typename Container = use_default, typename Constructor = use_default>
using	json_array_no_name = json_base::json_array< JsonElement, Container, Constructor >

template<char const * Name, typename WrappedContainer , typename JsonElement = typename json_details::unwrapped_t<WrappedContainer>::value_type, JsonNullable NullableType = JsonNullable::Nullable, typename Constructor = use_default>
using	json_array_null = json_nullable< Name, WrappedContainer, json_base::json_array< JsonElement, json_details::unwrapped_t< WrappedContainer > >, NullableType, Constructor >

template<typename JsonElement , typename WrappedContainer , JsonNullable NullableType = JsonNullable::Nullable, typename Constructor = use_default>
using	json_array_null_no_name = json_base::json_nullable< WrappedContainer, json_base::json_array< JsonElement, json_details::unwrapped_t< WrappedContainer > >, NullableType, Constructor >

template<typename T = bool, json_options_t Options = bool_opts_def, typename Constructor = use_default>
using	json_bool_no_name = json_base::json_bool< T, Options, Constructor >

template<char const * Name, typename T = std::optional<bool>, json_options_t Options = bool_opts_def, JsonNullable NullableType = JsonNullable::Nullable, typename Constructor = use_default>
using	json_bool_null = json_nullable< Name, T, json_base::json_bool< json_details::unwrapped_t< T >, Options >, NullableType, Constructor >

template<typename T = std::optional<bool>, json_options_t Options = bool_opts_def, JsonNullable NullableType = JsonNullable::Nullable, typename Constructor = use_default>
using	json_bool_null_no_name = json_base::json_nullable< T, json_base::json_bool< json_details::unwrapped_t< T >, Options >, NullableType, Constructor >

template<char const * Name, typename T = double, json_options_t Options = number_opts_def, typename Constructor = use_default>
using	json_checked_number = json_number< Name, T, json_details::number_opts_set< Options, options::JsonRangeCheck::CheckForNarrowing >, Constructor >

template<typename T = double, json_options_t Options = number_opts_def, typename Constructor = use_default>
using	json_checked_number_no_name = json_base::json_number< T, json_details::number_opts_set< Options, options::JsonRangeCheck::CheckForNarrowing >, Constructor >

template<char const * Name, typename T = std::optional<double>, json_options_t Options = number_opts_def, JsonNullable NullableType = JsonNullable::Nullable, typename Constructor = use_default>
using	json_checked_number_null = json_nullable< Name, T, json_base::json_number< json_details::unwrapped_t< T >, json_details::number_opts_set< Options, options::JsonRangeCheck::CheckForNarrowing > >, NullableType, Constructor >

template<typename T = std::optional<double>, json_options_t Options = number_opts_def, JsonNullable NullableType = JsonNullable::Nullable, typename Constructor = use_default>
using	json_checked_number_null_no_name = json_base::json_nullable< T, json_base::json_number< json_details::unwrapped_t< T >, json_details::number_opts_set< Options, options::JsonRangeCheck::CheckForNarrowing > >, NullableType, Constructor >

template<typename T , typename Constructor = use_default>
using	json_class_no_name = json_base::json_class< T, Constructor >

template<char const * Name, typename T , JsonNullable NullableType = JsonNullable::Nullable, typename Constructor = use_default>
using	json_class_null = json_nullable< Name, T, json_base::json_class< json_details::unwrapped_t< T > >, NullableType, Constructor >

template<typename T , JsonNullable NullableType = JsonNullable::Nullable, typename Constructor = use_default>
using	json_class_null_no_name = json_base::json_nullable< T, json_base::json_class< json_details::unwrapped_t< T > >, NullableType, Constructor >

template<char const * Name, typename T , typename FromJsonConverter = use_default, typename ToJsonConverter = use_default, 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, options::JsonCustomTypes::Literal > >

template<typename T , typename FromJsonConverter = use_default, typename ToJsonConverter = use_default, 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, options::JsonCustomTypes::Literal > >

template<char const * Name, typename WrappedT , typename FromJsonConverter = use_default, typename ToJsonConverter = use_default, json_options_t Options = json_custom_opts_def, JsonNullable NullableType = JsonNullable::Nullable, typename Constructor = use_default>
using	json_custom_lit_null = json_nullable< Name, WrappedT, json_base::json_custom< json_details::unwrapped_t< WrappedT >, FromJsonConverter, ToJsonConverter, json_details::json_custom_opts_set< Options, options::JsonCustomTypes::Literal > >, NullableType, Constructor >

template<typename T , typename FromJsonConverter = use_default, typename ToJsonConverter = use_default, json_options_t Options = json_custom_opts_def, JsonNullable NullableType = JsonNullable::Nullable, typename Constructor = use_default>
using	json_custom_lit_null_no_name = json_base::json_nullable< T, json_base::json_custom< json_details::unwrapped_t< T >, FromJsonConverter, ToJsonConverter, json_details::json_custom_opts_set< Options, options::JsonCustomTypes::Literal > >, NullableType, Constructor >

template<typename T , typename FromJsonConverter = use_default, typename ToJsonConverter = use_default, json_options_t Options = json_custom_opts_def>
using	json_custom_no_name = json_base::json_custom< T, FromJsonConverter, ToJsonConverter, Options >

template<char const * Name, typename WrappedT , typename FromJsonConverter = use_default, typename ToJsonConverter = use_default, json_options_t Options = json_custom_opts_def, JsonNullable NullableType = JsonNullable::Nullable, typename Constructor = use_default>
using	json_custom_null = json_nullable< Name, WrappedT, json_base::json_custom< json_details::unwrapped_t< WrappedT >, FromJsonConverter, ToJsonConverter, Options >, NullableType, Constructor >

template<typename T , typename FromJsonConverter = use_default, typename ToJsonConverter = use_default, json_options_t Options = json_custom_opts_def, JsonNullable NullableType = JsonNullable::Nullable, typename Constructor = use_default>
using	json_custom_null_no_name = json_base::json_nullable< T, json_base::json_custom< json_details::unwrapped_t< T >, FromJsonConverter, ToJsonConverter, Options >, NullableType, Constructor >

using	json_custom_opts_t = json_details::JsonOptionList< options::JsonCustomTypes >

template<typename T >
using	json_data_contract_trait_t = typename json_data_contract< T >::type
	This trait gets us the mapping type from the contract. More...

template<typename T , typename Constructor = use_default>
using	json_date_no_name = json_base::json_date< T, Constructor >

template<char const * Name, typename T = std::optional<std::chrono::time_point< std::chrono::system_clock, std::chrono::milliseconds>>, JsonNullable NullableType = JsonNullable::Nullable, typename Constructor = use_default>
using	json_date_null = json_nullable< Name, T, json_base::json_date< json_details::unwrapped_t< T > >, NullableType, Constructor >

template<typename T , JsonNullable NullableType = JsonNullable::Nullable, typename Constructor = use_default>
using	json_date_null_no_name = json_base::json_nullable< T, json_base::json_date< json_details::unwrapped_t< T > >, NullableType, Constructor >

template<char const * Name, typename T = json_value, typename Constructor = use_default, auto... >
using	json_delayed = json_raw< Name, T, Constructor >

template<char const * Name, typename T = std::optional<json_value>, JsonNullable NullableType = JsonNullable::Nullable, typename Constructor = use_default>
using	json_delayed_null = json_raw_null< Name, T, NullableType, Constructor >

template<typename T , typename TagMember , typename Switcher , typename JsonElements = use_default, typename Constructor = use_default>
using	json_intrusive_variant_no_name = json_base::json_intrusive_variant< T, TagMember, Switcher, JsonElements, Constructor >

template<typename T , typename TagMember , typename Switcher , typename JsonElements = use_default, JsonNullable NullableType = JsonNullable::Nullable, typename Constructor = use_default>
using	json_intrusive_variant_null_no_name = json_base::json_nullable< T, json_base::json_intrusive_variant< json_details::unwrapped_t< T >, TagMember, Switcher, JsonElements >, NullableType, Constructor >

template<typename Container , typename JsonValueType = use_default, typename JsonKeyType = use_default, typename Constructor = use_default>
using	json_key_value_array_no_name = json_base::json_key_value_array< Container, JsonValueType, JsonKeyType, Constructor >

template<char const * Name, typename WrappedContainer , typename JsonValueType = use_default, typename JsonKeyType = use_default, JsonNullable NullableType = JsonNullable::Nullable, typename Constructor = use_default>
using	json_key_value_array_null = json_nullable< Name, WrappedContainer, json_base::json_key_value_array< json_details::unwrapped_t< WrappedContainer >, JsonValueType, JsonKeyType >, NullableType, Constructor >

template<typename WrappedContainer , typename JsonValueType = use_default, typename JsonKeyType = use_default, JsonNullable NullableType = JsonNullable::Nullable, typename Constructor = use_default>
using	json_key_value_array_null_no_name = json_base::json_nullable< WrappedContainer, json_base::json_key_value_array< json_details::unwrapped_t< WrappedContainer >, JsonValueType, JsonKeyType >, NullableType, Constructor >

template<typename Container , typename JsonValueType = typename Container::mapped_type, typename JsonKeyType = typename Container::key_type, typename Constructor = use_default>
using	json_key_value_no_name = json_base::json_key_value< Container, JsonValueType, JsonKeyType, Constructor >

template<char const * Name, typename Container , typename JsonValueType = use_default, typename JsonKeyType = use_default, JsonNullable NullableType = JsonNullable::Nullable, typename Constructor = use_default>
using	json_key_value_null = json_nullable< Name, Container, json_base::json_key_value< json_details::unwrapped_t< Container >, JsonValueType, JsonKeyType >, NullableType, Constructor >

template<typename WrappedContainer , typename JsonValueType = typename json_details::unwrapped_t< WrappedContainer>::mapped_type, typename JsonKeyType = typename json_details::unwrapped_t<WrappedContainer>::key_type, JsonNullable NullableType = JsonNullable::Nullable, typename Constructor = use_default>
using	json_key_value_null_no_name = json_base::json_nullable< WrappedContainer, json_base::json_key_value< json_details::unwrapped_t< WrappedContainer >, JsonValueType, JsonKeyType >, NullableType, Constructor >

template<char const * 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_options_t Options = number_opts_def, typename Constructor = use_default>
using	json_number_no_name = json_base::json_number< T, Options, Constructor >

template<char const * Name, typename T = std::optional<double>, json_options_t Options = number_opts_def, JsonNullable NullableType = JsonNullable::Nullable, typename Constructor = use_default>
using	json_number_null = json_nullable< Name, T, json_base::json_number< json_details::unwrapped_t< T >, Options >, NullableType, Constructor >

template<typename T = std::optional<double>, json_options_t Options = number_opts_def, JsonNullable NullableType = JsonNullable::Nullable, typename Constructor = use_default>
using	json_number_null_no_name = json_base::json_nullable< T, json_base::json_number< json_details::unwrapped_t< T >, Options >, NullableType, Constructor >

using	json_options_t = std::uint32_t

template<typename... JsonMembers>
using	json_ordered_member_list = json_tuple_member_list< JsonMembers... >

using	json_pair = basic_json_pair<>

template<typename T = json_value, typename Constructor = use_default>
using	json_raw_no_name = json_base::json_raw< T, Constructor >

template<char const * Name, typename T = std::optional<json_value>, JsonNullable NullableType = JsonNullable::Nullable, typename Constructor = use_default>
using	json_raw_null = json_nullable< Name, T, json_base::json_raw< json_details::unwrapped_t< T > >, NullableType, Constructor >

template<typename T = std::optional<json_value>, JsonNullable NullableType = JsonNullable::Nullable, typename Constructor = use_default>
using	json_raw_null_no_name = json_base::json_nullable< T, json_base::json_raw< json_details::unwrapped_t< T > >, NullableType, Constructor >

template<typename JsonElement , typename SizeMember , typename Container = use_default, typename Constructor = use_default>
using	json_sized_array_no_name = json_base::json_sized_array< JsonElement, SizeMember, Container, Constructor >

template<typename JsonElement , typename SizeMember , typename WrappedContainer , JsonNullable NullableType = JsonNullable::Nullable, typename Constructor = use_default>
using	json_sized_array_null_no_name = json_base::json_nullable< WrappedContainer, json_base::json_sized_array< JsonElement, SizeMember, json_details::unwrapped_t< WrappedContainer > >, NullableType, Constructor >

template<typename T = std::string, json_options_t Options = string_opts_def, typename Constructor = use_default>
using	json_string_no_name = json_base::json_string< T, Options, Constructor >

template<char const * Name, typename T = std::optional<std::string>, json_options_t Options = string_opts_def, JsonNullable NullableType = JsonNullable::Nullable, typename Constructor = use_default>
using	json_string_null = json_nullable< Name, T, json_base::json_string< json_details::unwrapped_t< T >, Options >, NullableType, Constructor >

template<typename T = std::optional<std::string>, json_options_t Options = string_opts_def, JsonNullable NullableType = JsonNullable::Nullable, typename Constructor = use_default>
using	json_string_null_no_name = json_base::json_nullable< T, json_base::json_string< json_details::unwrapped_t< T >, Options >, NullableType, Constructor >

template<typename T = std::string, json_options_t Options = string_raw_opts_def, typename Constructor = use_default>
using	json_string_raw_no_name = json_base::json_string_raw< T, Options, Constructor >

template<char const * Name, typename T = std::optional<std::string>, json_options_t Options = string_raw_opts_def, JsonNullable NullableType = JsonNullable::Nullable, typename Constructor = use_default>
using	json_string_raw_null = json_nullable< Name, T, json_base::json_string_raw< json_details::unwrapped_t< T >, Options >, NullableType, Constructor >

template<typename T = std::optional<std::string>, json_options_t Options = string_raw_opts_def, JsonNullable NullableType = JsonNullable::Nullable, typename Constructor = use_default>
using	json_string_raw_null_no_name = json_base::json_nullable< T, json_base::json_string_raw< json_details::unwrapped_t< T >, Options >, NullableType, Constructor >

template<typename T , typename TagMember , typename Switcher , typename JsonElements = use_default, typename Constructor = use_default>
using	json_tagged_variant_no_name = json_base::json_tagged_variant< T, TagMember, Switcher, JsonElements, Constructor >

template<char const * Name, typename WrappedVariant , typename TagMember , typename Switcher , typename JsonElements = use_default, JsonNullable NullableType = JsonNullable::Nullable, typename Constructor = use_default>
using	json_tagged_variant_null = json_nullable< Name, WrappedVariant, json_base::json_tagged_variant< json_details::unwrapped_t< WrappedVariant >, TagMember, Switcher, JsonElements >, NullableType, Constructor >

template<typename T , typename TagMember , typename Switcher , typename JsonElements = use_default, JsonNullable NullableType = JsonNullable::Nullable, typename Constructor = use_default>
using	json_tagged_variant_null_no_name = json_base::json_nullable< T, json_base::json_tagged_variant< json_details::unwrapped_t< T >, TagMember, Switcher, JsonElements >, NullableType, Constructor >

template<typename... JsonElements>
using	json_tagged_variant_type_list = json_variant_type_list< JsonElements... >

template<typename Tuple , typename Constructor = use_default, typename JsonTupleTypesList = use_default>
using	json_tuple_no_name = json_base::json_tuple< Tuple, Constructor, JsonTupleTypesList >

template<char const * Name, typename WrappedTuple , typename JsonTupleTypesList = use_default, JsonNullable NullableType = JsonNullable::Nullable, typename Constructor = use_default>
using	json_tuple_null = json_nullable< Name, WrappedTuple, json_base::json_tuple< json_details::unwrapped_t< WrappedTuple >, JsonTupleTypesList >, NullableType, Constructor >

template<typename WrappedTuple , typename JsonTupleTypesList = use_default, JsonNullable NullableType = JsonNullable::Nullable, typename Constructor = use_default>
using	json_tuple_null_no_name = json_base::json_nullable< WrappedTuple, JsonTupleTypesList, NullableType, Constructor >

using	json_value = basic_json_value<>
	An untyped JSON value. More...

using	json_value_state = basic_stateful_json_value<>

template<typename Variant , typename JsonElements = use_default, typename Constructor = use_default>
using	json_variant_no_name = json_base::json_variant< Variant, JsonElements, Constructor >

template<char const * Name, typename WrappedVariant , typename JsonElements = use_default, JsonNullable NullableType = JsonNullable::Nullable, typename Constructor = use_default>
using	json_variant_null = json_nullable< Name, WrappedVariant, json_base::json_variant< json_details::unwrapped_t< WrappedVariant >, JsonElements >, NullableType, Constructor >

template<typename Variant , typename JsonElements = use_default, JsonNullable NullableType = JsonNullable::Nullable, typename Constructor = use_default>
using	json_variant_null_no_name = json_base::json_nullable< Variant, json_base::json_variant< json_details::unwrapped_t< Variant >, JsonElements >, NullableType, Constructor >

using	number_opts_t = json_details::JsonOptionList< options::LiteralAsStringOpt, options::JsonRangeCheck, options::JsonNumberErrors, options::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 >

using	string_opts_t = json_details::JsonOptionList< options::EightBitModes >

using	string_raw_opts_t = json_details::JsonOptionList< options::EightBitModes, options::AllowEscapeCharacter >

template<typename ParsePolicy >
using	TryDefaultParsePolicy = daw::conditional_t< ParsePolicy::is_default_parse_policy, DefaultParsePolicy, ParsePolicy >

Enumerations
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	JsonNullable : unsigned { Nullable , NullVisible }
	Control how json_nullable members are serialized. More...

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	StackParseStateType { Class , Array }

Functions
template<typename Result , json_options_t PolicyFlags, typename Allocator >
constexpr Result	as (basic_json_value< PolicyFlags, Allocator > const &jv)

template<json_options_t PolicyFlags, typename Allocator >
	basic_json_value (BasicParsePolicy< PolicyFlags, Allocator >) -> basic_json_value< PolicyFlags, Allocator >

	basic_json_value (char const first, char const last) -> basic_json_value<>

	basic_json_value (char const *first, std::size_t sz) -> basic_json_value<>

	basic_json_value (daw::string_view) -> basic_json_value<>

template<json_options_t PolicyFlags, typename Allocator >
	basic_json_value_iterator (basic_json_value< PolicyFlags, Allocator > const &) -> basic_json_value_iterator< PolicyFlags, Allocator >

template<json_options_t PolicyFlags, typename Allocator >
	basic_json_value_iterator (BasicParsePolicy< PolicyFlags, Allocator > const &) -> basic_json_value_iterator< PolicyFlags, Allocator >

	basic_json_value_iterator (daw::string_view) -> basic_json_value_iterator<>

template<typename Allocator >
	basic_json_value_iterator (daw::string_view, Allocator const &) -> basic_json_value_iterator< daw::json::json_details::default_policy_flag, Allocator >

template<json_options_t PolicyFlags, typename Allocator >
	basic_json_value_iterator_range (basic_json_value_iterator< PolicyFlags, Allocator >, basic_json_value_iterator< PolicyFlags, Allocator >) -> basic_json_value_iterator_range< PolicyFlags, Allocator >

	basic_stateful_json_value () -> basic_stateful_json_value<>

template<json_options_t PolicyFlags, typename Allocator >
	basic_stateful_json_value (basic_json_value< PolicyFlags, Allocator >) -> basic_stateful_json_value< PolicyFlags, Allocator >

	basic_stateful_json_value (daw::string_view) -> basic_stateful_json_value<>

	BasicParsePolicy () -> BasicParsePolicy<>

	BasicParsePolicy (char const , char const ) -> BasicParsePolicy<>

template<typename Allocator >
	BasicParsePolicy (char const , char const , Allocator const &) -> BasicParsePolicy< json_details::default_policy_flag, Allocator >

	BasicParsePolicy (char const , char const , char const , char const ) -> BasicParsePolicy<>

template<typename Allocator >
	BasicParsePolicy (char const , char const , char const , char const , Allocator const &) -> BasicParsePolicy< json_details::default_policy_flag, Allocator >

DAW_ATTRIB_NOINLINE void	daw_json_error (ErrorReason reason)

template<typename ParseState >
DAW_ATTRIB_NOINLINE void	daw_json_error (ErrorReason reason, ParseState const &location)

DAW_ATTRIB_NOINLINE void	daw_json_error (json_details::missing_member reason)

template<typename ParseState >
DAW_ATTRIB_NOINLINE void	daw_json_error (json_details::missing_member reason, ParseState const &location)

DAW_ATTRIB_NOINLINE void	daw_json_error (json_details::missing_token reason)

template<typename ParseState >
DAW_ATTRIB_NOINLINE void	daw_json_error (json_details::missing_token reason, ParseState const &location)

	DAW_JSON_MAKE_REQ_TYPE_ALIAS_TRAIT (ignore_unknown_members_v, json_data_contract< T >::ignore_unknown_members)

	DAW_JSON_MAKE_REQ_TYPE_ALIAS_TRAIT (is_exact_class_mapping_v, json_data_contract< T >::exact_class_mapping)

template<typename T >
	DAW_JSON_REQUIRES (boost::describe::has_describe_members< T >::value and use_boost_describe_v< T >) struct json_data_contract< T >

template<typename JsonClass , typename Value , typename WritableType , auto... PolicyFlags DAW_JSON_ENABLEIF2>
	DAW_JSON_REQUIRES (concepts::is_writable_output_type_v< daw::remove_cvref_t< WritableType >>) const expr daw

DAW_ATTRIB_NOINLINE void	default_error_handler_terminating (json_exception &&jex, void *)

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_node >	find_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_node >	find_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 , bool KnownBounds = false, json_options_t P, typename A >
constexpr auto	from_json (basic_json_value< P, A > value)
	Parse a value from a json_value. More...

template<typename JsonMember , bool KnownBounds = false, json_options_t P, typename A , auto... PolicyFlags>
constexpr auto	from_json (basic_json_value< P, A > value, options::parse_flags_t< PolicyFlags... >)
	Parse a value from a json_value. More...

template<typename JsonMember , bool KnownBounds, json_options_t P, typename A >
constexpr auto	from_json (basic_json_value< P, A > value, std::string_view member_path)
	Parse a JSONMember from the json_data starting at member_path. More...

template<typename JsonMember , bool KnownBounds = false, json_options_t P, typename A , auto... PolicyFlags>
constexpr auto	from_json (basic_json_value< P, A > value, std::string_view member_path, options::parse_flags_t< PolicyFlags... >)
	Parse a JSONMember from the json_data starting at member_path. More...

template<typename JsonMember , bool KnownBounds, json_options_t P, typename Allocator , auto... PolicyFlags>
constexpr auto	from_json (basic_json_value< P, Allocator > value, options::parse_flags_t< PolicyFlags... >)
	Parse a value from a json_value. More...

template<typename JsonMember , bool KnownBounds, json_options_t P, typename Allocator , auto... PolicyFlags>
constexpr auto	from_json (basic_json_value< P, Allocator > value, std::string_view member_path, options::parse_flags_t< PolicyFlags... >)
	Parse a JSONMember from the json_data starting at member_path. More...

template<typename JsonMember , bool KnownBounds, json_options_t PolicyFlags, typename Allocator >
constexpr auto	from_json (basic_json_value< PolicyFlags > value, std::string_view member_path)
	Parse a JSONMember from the json_data starting at member_path. More...

template<typename JsonMember , bool KnownBounds, json_options_t PolicyFlags, typename Allocator >
constexpr auto	from_json (basic_json_value< PolicyFlags, Allocator > value)
	Parse a value from a json_value. More...

template<typename JsonMember , bool KnownBounds, typename String >
constexpr auto	from_json (String &&json_data)
	Construct the JSONMember from the JSON document argument. More...

template<typename JsonMember , bool KnownBounds = false, typename String >
constexpr auto	from_json (String &&json_data)
	Construct the JSONMember from the JSON document argument. More...

template<typename JsonMember , bool KnownBounds, typename String , auto... PolicyFlags>
constexpr auto	from_json (String &&json_data, options::parse_flags_t< PolicyFlags... >)
	Construct the JSONMember from the JSON document argument. More...

template<typename JsonMember , bool KnownBounds = false, typename String , auto... PolicyFlags>
constexpr auto	from_json (String &&json_data, options::parse_flags_t< PolicyFlags... >)

template<typename JsonMember , bool KnownBounds, typename String >
constexpr auto	from_json (String &&json_data, std::string_view member_path)
	Parse a JSONMember from the json_data starting at member_path. More...

template<typename JsonMember , bool KnownBounds = false, typename String >
constexpr auto	from_json (String &&json_data, std::string_view member_path)
	Parse a JSONMember from the json_data starting at member_path. More...

template<typename JsonMember , bool KnownBounds, typename String , auto... PolicyFlags>
constexpr auto	from_json (String &&json_data, std::string_view member_path, options::parse_flags_t< PolicyFlags... >)
	Parse a JSONMember from the json_data starting at member_path. More...

template<typename JsonMember , bool KnownBounds = false, typename String , auto... PolicyFlags>
constexpr auto	from_json (String &&json_data, std::string_view member_path, options::parse_flags_t< PolicyFlags... >)
	Parse a JSONMember from the json_data starting at member_path. More...

template<typename JsonMember , bool KnownBounds, typename String , typename Allocator >
constexpr auto	from_json_alloc (String &&json_data, Allocator const &alloc)
	Construct the JSONMember from the JSON document argument. More...

template<typename JsonMember , bool KnownBounds = false, typename String , typename Allocator >
constexpr auto	from_json_alloc (String &&json_data, Allocator const &alloc)
	Construct the JSONMember from the JSON document argument. More...

template<typename JsonMember , bool KnownBounds, typename String , typename Allocator , auto... PolicyFlags>
constexpr auto	from_json_alloc (String &&json_data, Allocator const &alloc, options::parse_flags_t< PolicyFlags... >)
	Construct the JSONMember from the JSON document argument. More...

template<typename JsonMember , bool KnownBounds = false, typename String , typename Allocator , auto... PolicyFlags>
constexpr auto	from_json_alloc (String &&json_data, Allocator const &alloc, options::parse_flags_t< PolicyFlags... >)
	Construct the JSONMember from the JSON document argument. More...

template<typename JsonMember , bool KnownBounds, typename String , typename Allocator >
constexpr auto	from_json_alloc (String &&json_data, std::string_view member_path, Allocator const &alloc)
	Parse a JSONMember from the json_data starting at member_path. More...

template<typename JsonMember , bool KnownBounds = false, typename String , typename Allocator >
constexpr auto	from_json_alloc (String &&json_data, std::string_view member_path, Allocator const &alloc)
	Parse a JSONMember from the json_data starting at member_path. More...

template<typename JsonMember , bool KnownBounds, typename String , typename Allocator , auto... PolicyFlags>
constexpr auto	from_json_alloc (String &&json_data, std::string_view member_path, Allocator const &alloc, options::parse_flags_t< PolicyFlags... >)
	Parse a JSON Member from the json_data starting at member_path. More...

template<typename JsonMember , bool KnownBounds = false, typename String , typename Allocator , auto... PolicyFlags>
constexpr auto	from_json_alloc (String &&json_data, std::string_view member_path, Allocator const &alloc, options::parse_flags_t< PolicyFlags... >)
	Parse a JSONMember from the json_data starting at member_path. More...

template<typename JsonElement , typename Container , typename Constructor , bool KnownBounds, typename String >
constexpr Container	from_json_array (String &&json_data)
	Parse JSON data where the root item is an array. More...

template<typename JsonElement , typename Container = std::vector<json_details::from_json_result_t<JsonElement>>, typename Constructor = use_default, bool KnownBounds = false, typename String >
constexpr Container	from_json_array (String &&json_data)
	Parse JSON data where the root item is an array. More...

template<typename JsonElement , typename Container , typename Constructor , bool KnownBounds, typename String , auto... PolicyFlags>
constexpr Container	from_json_array (String &&json_data, options::parse_flags_t< PolicyFlags... >)
	Parse JSON data where the root item is an array. More...

template<typename JsonElement , typename Container = std::vector<json_details::from_json_result_t<JsonElement>>, typename Constructor = use_default, bool KnownBounds = false, typename String , auto... PolicyFlags>
constexpr Container	from_json_array (String &&json_data, options::parse_flags_t< PolicyFlags... >)
	Parse JSON data where the root item is an array. More...

template<typename JsonElement , typename Container , typename Constructor , bool KnownBounds, typename String >
constexpr Container	from_json_array (String &&json_data, std::string_view member_path)
	Parse JSON data where the root item is an array. More...

template<typename JsonElement , typename Container = std::vector<json_details::from_json_result_t<JsonElement>>, typename Constructor = use_default, bool KnownBounds = false, typename String >
constexpr Container	from_json_array (String &&json_data, std::string_view member_path)
	Parse JSON data where the root item is an array. More...

template<typename JsonElement , typename Container , typename Constructor , bool KnownBounds, typename String , auto... PolicyFlags>
constexpr Container	from_json_array (String &&json_data, std::string_view member_path, options::parse_flags_t< PolicyFlags... >)
	Parse JSON data where the root item is an array. More...

template<typename JsonElement , typename Container = std::vector<json_details::from_json_result_t<JsonElement>>, typename Constructor = use_default, bool KnownBounds = false, typename String , auto... PolicyFlags>
constexpr Container	from_json_array (String &&json_data, std::string_view member_path, options::parse_flags_t< PolicyFlags... >)
	Parse JSON data where the root item is an array. More...

template<std::size_t Idx, json_options_t PolicyFlags, typename Allocator >
constexpr decltype(auto)	get (basic_json_pair< PolicyFlags, Allocator > &&parse_state)

template<std::size_t Idx, json_options_t PolicyFlags, typename Allocator >
constexpr decltype(auto)	get (basic_json_pair< PolicyFlags, Allocator > &parse_state)

template<std::size_t Idx, json_options_t PolicyFlags, typename Allocator >
constexpr decltype(auto)	get (basic_json_pair< PolicyFlags, Allocator > const &parse_state)

template<typename Signature = use_default, typename String , typename Callable DAW_JSON_ENABLEIF>
constexpr auto	json_apply (String &&json_doc, Callable &&callable)
	Parse to parameters specified in signature and pass them to Callable for evaluation. This is similar to std::apply but using JSON documents instead of tuples. More...

template<typename Signature = use_default, typename String , auto... PolicyFlags, typename Callable DAW_JSON_ENABLEIF>
constexpr auto	json_apply (String &&json_doc, daw::json::options::parse_flags_t< PolicyFlags... > flags, Callable &&callable)
	Parse to parameters specified in signature and pass them to Callable for evaluation. This is similar to std::apply but using JSON documents instead of tuples. More...

template<typename Signature = use_default, typename String , typename Callable DAW_JSON_ENABLEIF>
constexpr auto	json_apply (String &&json_doc, std::string_view json_path, Callable &&callable)
	Parse to parameters specified in signature and pass them to Callable for evaluation. This is similar to std::apply but using JSON documents instead of tuples. More...

template<typename Signature = use_default, typename String , auto... PolicyFlags, typename Callable DAW_JSON_ENABLEIF>
constexpr auto	json_apply (String &&json_doc, std::string_view json_path, daw::json::options::parse_flags_t< PolicyFlags... > flags, Callable &&callable)
	Parse to parameters specified in signature and pass them to Callable for evaluation. This is similar to std::apply but using JSON documents instead of tuples. More...

template<json_options_t P, typename A , typename StackContainerPolicy = use_default, typename Handler >
constexpr DAW_ATTRIB_INLINE void	json_event_parser (basic_json_value< P, A > bjv, Handler &&handler)

template<json_options_t P, typename A , typename StackContainerPolicy = use_default, typename Handler , auto... ParseFlags>
constexpr void	json_event_parser (basic_json_value< P, A > bjv, Handler &&handler, options::parse_flags_t< ParseFlags... >)

template<typename Handler >
DAW_ATTRIB_INLINE void	json_event_parser (daw::string_view json_document, Handler &&handler)

template<typename Handler , auto... ParseFlags>
DAW_ATTRIB_INLINE void	json_event_parser (daw::string_view json_document, Handler &&handler, options::parse_flags_t< ParseFlags... > pflags)

	json_lines_iterator (daw::string_view) -> json_lines_iterator<>

	json_lines_range (daw::string_view) -> json_lines_range<>

template<typename JsonElement , auto... PolicyFlags>
	json_lines_range (json_lines_iterator< JsonElement, PolicyFlags... >, json_lines_iterator< JsonElement, PolicyFlags... >) -> json_lines_range< JsonElement, PolicyFlags... >

DAW_CONSTEVAL std::string_view	json_link_version ()

template<typename JsonElement = json_value, auto... ParsePolicies>
std::vector< json_lines_range< JsonElement, ParsePolicies... > >	partition_jsonl_document (std::size_t num_partitions, daw::string_view jsonl_doc)
	parition the jsonl/nbjson document into num_partition non overlapping sub-ranges. This can be used to parallelize json lines parsing More...

template<typename WritableOutput , typename CharT >
constexpr WritableOutput &	put_output (WritableOutput &out, CharT c)

template<typename T >
	requires (std::is_aggregate_v< T > and std::is_class_v< T > and not std::is_empty_v< T >) inline const expr bool use_boost_pfr
	Enable Boost PFR mappings for a type. More...

template<typename... Policies>
constexpr json_options_t	serialize_options (Policies... policies)

template<typename JsonClass , typename Value , auto... PolicyFlags>
std::string	to_json (Value const &value, options::output_flags_t< PolicyFlags... > flgs)

template<typename JsonClass = use_default, typename Value , auto... PolicyFlags>
DAW_JSON_REQUIRES(concepts::is_writable_output_type_v< daw::remove_cvref_t< WritableType >>) const expr daw std::string	to_json (Value const &value, options::output_flags_t< PolicyFlags... >)
	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. More...

template<typename JsonElement , typename Container , auto... PolicyFlags>
std::string	to_json_array (Container const &c, options::output_flags_t< PolicyFlags... > flgs)

template<typename JsonElement = use_default, typename Container , auto... PolicyFlags>
DAW_JSON_REQUIRES(concepts::is_writable_output_type_v< daw::remove_cvref_t< WritableType >>) const expr daw std::string	to_json_array (Container const &c, options::output_flags_t< PolicyFlags... >=options::output_flags<>)

DAW_ATTRIB_NOINLINE 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 WritableOutput , typename... StringViews>
constexpr WritableOutput &	write_output (WritableOutput &out, StringViews const &...svs)

Variables
constexpr auto	bool_opts = bool_opts_t{ }

constexpr json_options_t	bool_opts_def

template<typename >
constexpr bool	can_single_allocation_string_v = false
	Can use the fast, pseudo random string iterators. They are InputIterators with an operator- that allows for O(1) distance calculations as we often know the length but cannot provide random access. For types that only use InputIterator operations and last - first for distance calc. More...

constexpr auto	ConformancePolicy

static thread_local daw_json_error_handler_t	daw_json_error_handler

static thread_local void *	daw_json_error_handler_data = nullptr

constexpr char const	default_key_name [] = "key"

constexpr char const	default_value_name [] = "value"

template<typename T >
constexpr bool	force_aggregate_construction_v

template<typename >
constexpr bool	is_a_basic_json_value = false

template<json_options_t PolicyFlags, typename Allocator >
constexpr bool	is_a_basic_json_value< basic_json_value< PolicyFlags, Allocator > > = true

template<typename... Ts>
constexpr bool	is_empty_pack_v = sizeof...( Ts ) == 0

template<typename T >
constexpr bool	is_missing_data_contract_or_unknown_type_v = false

template<typename T >
constexpr bool	is_missing_data_contract_or_unknown_type_v< missing_json_data_contract_for_or_unknown_type< T > > = true

template<>
constexpr bool	is_missing_data_contract_or_unknown_type_v< void >

template<typename T >
constexpr bool	is_pinned_type_v
	Is the type pinned in memory and unable to be copied/moved after construction(e.g. std::mutex). These types require using RVO in order to be used but that can have a penalty as std::current_exceptions( ) must be checked which is quite noticeable on MSVC. More...

template<typename T >
constexpr bool	is_pointer_like_v

template<typename , typename... >
constexpr bool	is_serialization_policy_v = false

template<typename OutputIterator , json_options_t PolicyFlags>
constexpr bool	is_serialization_policy_v< serialization_policy< OutputIterator, PolicyFlags > > = true

template<typename >
constexpr bool	is_zero_terminated_string_v = false

constexpr auto	json_custom_opts = json_custom_opts_t{ }

constexpr json_options_t	json_custom_opts_def

constexpr auto	number_opts = number_opts_t{ }

constexpr json_options_t	number_opts_def

template<typename Constructor , typename T , typename ParseState >
constexpr bool	should_construct_explicitly_v

constexpr auto	string_opts = string_opts_t{ }

constexpr json_options_t	string_opts_def

constexpr auto	string_raw_opts = string_raw_opts_t{ }

constexpr json_options_t	string_raw_opts_def

template<typename , typename = void>
constexpr bool	use_boost_describe_v = true
	Types that use Boost.Describe need to specialize use_boost_describe_v for their type with a bool value of true. This defaults to on, all described structs, but can be opted-out of if one wants to do a custom mapping of a Boost.Described struct. More...

constexpr bool	use_daw_json_exceptions_v = false

Detailed Description

Customization point traits.

Typedef Documentation

◆ daw_json_error_handler_t

using daw::json::daw_json_error_handler_t = typedef daw::not_null<void ( * )( json_exception &&, void * )>

Definition at line 54 of file daw_json_assert.h.

Function Documentation

◆ DAW_JSON_REQUIRES() [1/2]

template<typename T >

daw::json::DAW_JSON_REQUIRES ( boost::describe::has_describe_members< T >::value and use_boost_describe_v< T > )

Definition at line 66 of file daw_json_link_describe.h.

◆ default_error_handler_terminating()

DAW_ATTRIB_NOINLINE void daw::json::default_error_handler_terminating	(	json_exception &&	jex,
		void *
	)

inline

Definition at line 45 of file daw_json_assert.h.

◆ requires()

template<typename T >

daw::json::requires ( std::is_aggregate_v< T > and std::is_class_v< T > and not std::is_empty_v< T > ) const

Enable Boost PFR mappings for a type.

Template Parameters

T

Variable Documentation

◆ daw_json_error_handler

thread_local daw_json_error_handler_t daw::json::daw_json_error_handler

static

Initial value:

=

default_error_handler_terminating

daw::json::default_error_handler_terminating

DAW_ATTRIB_NOINLINE void default_error_handler_terminating(json_exception &&jex, void *)

Definition: daw_json_assert.h:45

Definition at line 61 of file daw_json_assert.h.

◆ daw_json_error_handler_data

thread_local void* daw::json::daw_json_error_handler_data = nullptr

static

Definition at line 35 of file daw_json_assert.h.

◆ use_boost_describe_v

template<typename , typename = void>

constexpr bool daw::json::use_boost_describe_v = true

inlineconstexpr

Types that use Boost.Describe need to specialize use_boost_describe_v for their type with a bool value of true. This defaults to on, all described structs, but can be opted-out of if one wants to do a custom mapping of a Boost.Described struct.

Definition at line 32 of file daw_json_link_describe.h.

◆ use_daw_json_exceptions_v

constexpr bool daw::json::use_daw_json_exceptions_v = false

inlineconstexpr

Definition at line 32 of file daw_json_assert.h.

Namespaces

Classes

Typedefs

Enumerations

Functions

Variables