DAW JSON Link
Loading...
Searching...
No Matches
Namespaces | Classes | Typedefs | Enumerations | Functions | Variables
daw::json Namespace Reference

string_writer grows its string with resize_and_overwrite, leaving the new bytes uninitialized, when the standard library has it. That skips zero filling memory that is overwritten right away, but the bytes past what was written are never initialized, which resize_and_overwrite's precondition does not allow. Define DAW_JSON_NO_LESS_SAFE_STRING_WRITER to grow with resize( ) instead More...

Namespaces

namespace  anonymous_namespace{daw_container_traits.h}
 
namespace  anonymous_namespace{daw_container_traits_fwd.h}
 
namespace  anonymous_namespace{daw_fp_fallback.h}
 
namespace  anonymous_namespace{daw_from_json.h}
 
namespace  anonymous_namespace{daw_from_json_fwd.h}
 
namespace  anonymous_namespace{daw_json_allocator_wrapper.h}
 
namespace  anonymous_namespace{daw_json_alternate_mapping.h}
 
namespace  anonymous_namespace{daw_json_apply.h}
 
namespace  anonymous_namespace{daw_json_arrow_proxy.h}
 
namespace  anonymous_namespace{daw_json_assert.h}
 
namespace  anonymous_namespace{daw_json_construct_value.h}
 
namespace  anonymous_namespace{daw_json_container_appender.h}
 
namespace  anonymous_namespace{daw_json_data_contract.h}
 
namespace  anonymous_namespace{daw_json_default_constuctor.h}
 
namespace  anonymous_namespace{daw_json_default_constuctor_fwd.h}
 
namespace  anonymous_namespace{daw_json_enums.h}
 
namespace  anonymous_namespace{daw_json_event_parser.h}
 
namespace  anonymous_namespace{daw_json_exec_modes.h}
 
namespace  anonymous_namespace{daw_json_find_path.h}
 
namespace  anonymous_namespace{daw_json_find_result.h}
 
namespace  anonymous_namespace{daw_json_iostream.h}
 
namespace  anonymous_namespace{daw_json_iterator.h}
 
namespace  anonymous_namespace{daw_json_lines_iterator.h}
 
namespace  anonymous_namespace{daw_json_link.h}
 
namespace  anonymous_namespace{daw_json_link_types.h}
 
namespace  anonymous_namespace{daw_json_link_types_aggregate.h}
 
namespace  anonymous_namespace{daw_json_link_types_fwd.h}
 
namespace  anonymous_namespace{daw_json_link_types_iso8601.h}
 
namespace  anonymous_namespace{daw_json_location_info.h}
 
namespace  anonymous_namespace{daw_json_name.h}
 
namespace  anonymous_namespace{daw_json_option_bits.h}
 
namespace  anonymous_namespace{daw_json_parse_array_iterator.h}
 
namespace  anonymous_namespace{daw_json_parse_class.h}
 
namespace  anonymous_namespace{daw_json_parse_common.h}
 
namespace  anonymous_namespace{daw_json_parse_digit.h}
 
namespace  anonymous_namespace{daw_json_parse_iso8601_utils.h}
 
namespace  anonymous_namespace{daw_json_parse_kv_array_iterator.h}
 
namespace  anonymous_namespace{daw_json_parse_kv_class_iterator.h}
 
namespace  anonymous_namespace{daw_json_parse_name.h}
 
namespace  anonymous_namespace{daw_json_parse_options.h}
 
namespace  anonymous_namespace{daw_json_parse_options_impl.h}
 
namespace  anonymous_namespace{daw_json_parse_policy.h}
 
namespace  anonymous_namespace{daw_json_parse_policy_cpp_comments.h}
 
namespace  anonymous_namespace{daw_json_parse_policy_hash_comments.h}
 
namespace  anonymous_namespace{daw_json_parse_policy_no_comments.h}
 
namespace  anonymous_namespace{daw_json_parse_policy_policy_details.h}
 
namespace  anonymous_namespace{daw_json_parse_real.h}
 
namespace  anonymous_namespace{daw_json_parse_real_decimal.h}
 
namespace  anonymous_namespace{daw_json_parse_real_eisellemire.h}
 
namespace  anonymous_namespace{daw_json_parse_real_power10.h}
 
namespace  anonymous_namespace{daw_json_parse_std_string.h}
 
namespace  anonymous_namespace{daw_json_parse_string_need_slow.h}
 
namespace  anonymous_namespace{daw_json_parse_string_quote.h}
 
namespace  anonymous_namespace{daw_json_parse_unsigned_int.h}
 
namespace  anonymous_namespace{daw_json_parse_value.h}
 
namespace  anonymous_namespace{daw_json_parse_value_fwd.h}
 
namespace  anonymous_namespace{daw_json_schema.h}
 
namespace  anonymous_namespace{daw_json_serialize_impl.h}
 
namespace  anonymous_namespace{daw_json_serialize_options.h}
 
namespace  anonymous_namespace{daw_json_serialize_options_impl.h}
 
namespace  anonymous_namespace{daw_json_serialize_policy.h}
 
namespace  anonymous_namespace{daw_json_serialize_policy_details.h}
 
namespace  anonymous_namespace{daw_json_skip.h}
 
namespace  anonymous_namespace{daw_json_string_util.h}
 
namespace  anonymous_namespace{daw_json_traits.h}
 
namespace  anonymous_namespace{daw_json_type_options.h}
 
namespace  anonymous_namespace{daw_json_types_base.h}
 
namespace  anonymous_namespace{daw_json_value.h}
 
namespace  anonymous_namespace{daw_json_value_fwd.h}
 
namespace  anonymous_namespace{daw_json_value_state.h}
 
namespace  anonymous_namespace{daw_json_writer.h}
 
namespace  anonymous_namespace{daw_not_const_ex_functions.h}
 
namespace  anonymous_namespace{daw_nullable_value.h}
 
namespace  anonymous_namespace{daw_nullable_value_fwd.h}
 
namespace  anonymous_namespace{daw_to_json.h}
 
namespace  anonymous_namespace{daw_to_json_fwd.h}
 
namespace  anonymous_namespace{daw_writable_output_basics.h}
 
namespace  anonymous_namespace{daw_writable_output_cstdio.h}
 
namespace  anonymous_namespace{daw_writable_output_details.h}
 
namespace  anonymous_namespace{daw_writable_output_fwd.h}
 
namespace  anonymous_namespace{daw_writable_output_ostream.h}
 
namespace  anonymous_namespace{daw_writable_output_string_writer.h}
 
namespace  anonymous_namespace{power_of_five_128_table.h}
 
namespace  anonymous_namespace{to_daw_json_string.h}
 
namespace  concepts
 
namespace  datetime
 
namespace  json_base
 
namespace  literals
 
namespace  options
 
namespace  parse_utils
 
namespace  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. For non-random iterators it reserves the known element count, or the ArrayReserve parse option when the count is unknown. More...
 
struct  default_exec_tag
 
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 arrays. Requires that operator* and operator++ 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_fp
 
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
 Mark a member as nullable. More...
 
struct  json_number
 
class  json_path_node
 
struct  json_raw
 
struct  json_recursive_class
 
struct  json_sized_array
 
struct  json_string
 
struct  json_string_insitu
 
struct  json_string_raw
 
struct  json_submember
 
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
 A list of JSON element mappings for a tuple-like type. More...
 
struct  json_type_alias
 
struct  json_variant
 
struct  json_variant_type_list
 
class  json_writer_t
 
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_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
 
class  string_writer
 A writable output that serializes into a std::string. The string's own output trait resizes it on every write; this keeps spare room and only grows the string when it runs out, so a write is a size check and a copy. finish( ) cuts the string to what was written. More...
 
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 fp_opts_t = json_details::JsonOptionList< options::LiteralAsStringOpt, options::JsonRangeCheck, options::JsonNumberErrors >
 
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<JSONNAMETYPE 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 , 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 > >, JsonNullable::NullVisible, 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<JSONNAMETYPE 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, 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 >, JsonNullable::NullVisible, Constructor >
 
template<JSONNAMETYPE Name, typename T , options::FPOutputFormat Format = options::FPOutputFormat::Auto, unsigned Precision = daw::max_value<unsigned>, json_options_t Options = fp_opts_def, typename Constructor = use_default>
using json_checked_fp = json_fp< Name, T, Format, Precision, Options, Constructor >
 
template<typename T = double, json_options_t Options = fp_opts_def, options::FPOutputFormat Format = options::FPOutputFormat::Auto, unsigned Precision = daw::max_value<unsigned>, typename Constructor = use_default>
using json_checked_fp_no_name = json_base::json_fp< T, Format, Precision, json_details::fp_opts_set< Options, options::JsonRangeCheck::CheckForNarrowing >, Constructor >
 
template<JSONNAMETYPE Name, typename T = std::optional<double>, options::FPOutputFormat Format = options::FPOutputFormat::Auto, unsigned Precision = daw::max_value<unsigned>, json_options_t Options = fp_opts_def, JsonNullable NullableType = JsonNullable::Nullable, typename Constructor = use_default>
using json_checked_fp_null = json_nullable< Name, T, json_base::json_fp< json_details::unwrapped_t< T >, Format, Precision, json_details::number_opts_set< Options, options::JsonRangeCheck::CheckForNarrowing > >, NullableType, Constructor >
 
template<typename T = std::optional<double>, options::FPOutputFormat Format = options::FPOutputFormat::Auto, unsigned Precision = daw::max_value<unsigned>, json_options_t Options = fp_opts_def, typename Constructor = use_default>
using json_checked_fp_null_no_name = json_base::json_nullable< T, json_base::json_fp< json_details::unwrapped_t< T >, Format, Precision, json_details::fp_opts_set< Options, options::JsonRangeCheck::CheckForNarrowing > >, JsonNullable::NullVisible, Constructor >
 
template<JSONNAMETYPE 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<JSONNAMETYPE 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, 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 > >, JsonNullable::NullVisible, Constructor >
 
template<typename T , typename Constructor = use_default>
using json_class_no_name = json_base::json_class< T, Constructor >
 
template<JSONNAMETYPE 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 , typename Constructor = use_default>
using json_class_null_no_name = json_base::json_nullable< T, json_base::json_class< json_details::unwrapped_t< T > >, JsonNullable::NullVisible, Constructor >
 
template<JSONNAMETYPE 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<JSONNAMETYPE 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, 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 > >, JsonNullable::NullVisible, 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<JSONNAMETYPE 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, 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 >, JsonNullable::NullVisible, 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.
 
template<typename T , typename Constructor = use_default>
using json_date_no_name = json_base::json_date< T, Constructor >
 
template<JSONNAMETYPE 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 , typename Constructor = use_default>
using json_date_null_no_name = json_base::json_nullable< T, json_base::json_date< json_details::unwrapped_t< T > >, JsonNullable::NullVisible, Constructor >
 
template<JSONNAMETYPE Name, typename T = json_value, typename Constructor = use_default, auto... >
using json_delayed = json_raw< Name, T, Constructor >
 
template<JSONNAMETYPE 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 = double, options::FPOutputFormat Format = options::FPOutputFormat::Auto, unsigned Precision = daw::max_value<unsigned>, json_options_t Options = fp_opts_def, typename Constructor = use_default>
using json_fp_no_name = json_base::json_fp< T, Format, Precision, Options, Constructor >
 
template<JSONNAMETYPE Name, typename T = std::optional<double>, options::FPOutputFormat Format = options::FPOutputFormat::Auto, unsigned Precision = daw::max_value<unsigned>, json_options_t Options = fp_opts_def, JsonNullable NullableType = JsonNullable::Nullable, typename Constructor = use_default>
using json_fp_null = json_nullable< Name, T, json_base::json_fp< json_details::unwrapped_t< T >, Format, Precision, Options >, NullableType, Constructor >
 
template<typename T = std::optional<double>, options::FPOutputFormat Format = options::FPOutputFormat::Auto, unsigned Precision = daw::max_value<unsigned>, json_options_t Options = fp_opts_def, typename Constructor = use_default>
using json_fp_null_no_name = json_base::json_nullable< T, json_base::json_fp< json_details::unwrapped_t< T >, Format, Precision, Options >, JsonNullable::NullVisible, 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, 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 >, JsonNullable::NullVisible, 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<JSONNAMETYPE 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, 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 >, JsonNullable::NullVisible, 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<JSONNAMETYPE 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, 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 >, JsonNullable::NullVisible, Constructor >
 
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.
 
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.
 
template<typename T , typename JsonMember = use_default, typename Constructor = use_default, typename IsNull = use_default>
using json_nullable_no_name = json_base::json_nullable< T, JsonMember, JsonNullable::NullVisible, Constructor, IsNull >
 Mark a member as nullable.
 
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<JSONNAMETYPE 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, 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 >, JsonNullable::NullVisible, 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<JSONNAMETYPE 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>, typename Constructor = use_default>
using json_raw_null_no_name = json_base::json_nullable< T, json_base::json_raw< json_details::unwrapped_t< T > >, JsonNullable::NullVisible, Constructor >
 
template<typename T , typename Constructor = use_default>
using json_recursive_class_no_name = json_base::json_recursive_class< T, 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 , 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 > >, JsonNullable::NullVisible, Constructor >
 
template<typename T = std::string_view, json_options_t Options = string_opts_def, typename Constructor = use_default>
using json_string_insitu_no_name = json_base::json_string_insitu< T, Options, Constructor >
 
template<JSONNAMETYPE Name, typename T = std::optional<std::string_view>, json_options_t Options = string_opts_def, JsonNullable NullableType = JsonNullable::Nullable, typename Constructor = use_default>
using json_string_insitu_null = json_nullable< Name, T, json_base::json_string_insitu< json_details::unwrapped_t< T >, Options >, NullableType, Constructor >
 
template<typename T = std::optional<std::string_view>, json_options_t Options = string_opts_def, typename Constructor = use_default>
using json_string_insitu_null_no_name = json_base::json_nullable< T, json_base::json_string_insitu< json_details::unwrapped_t< T >, Options >, JsonNullable::NullVisible, 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<JSONNAMETYPE 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, 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 >, JsonNullable::NullVisible, 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<JSONNAMETYPE 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, 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 >, JsonNullable::NullVisible, 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<JSONNAMETYPE 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, 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 >, JsonNullable::NullVisible, Constructor >
 
template<typename... JsonElements>
using json_tagged_variant_type_list = json_variant_type_list< JsonElements... >
 
template<typename Tuple , typename JsonTupleTypesList = use_default, typename Constructor = use_default>
using json_tuple_no_name = json_base::json_tuple< Tuple, JsonTupleTypesList, Constructor >
 Map an unnamed tuple-like value to a JSON heterogeneous array.
 
template<JSONNAMETYPE 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 >
 Map a nullable tuple-like type to a JSON heterogeneous array.
 
template<typename WrappedTuple , typename JsonTupleTypesList = use_default, typename Constructor = use_default>
using json_tuple_null_no_name = json_base::json_nullable< WrappedTuple, json_base::json_tuple< json_details::unwrapped_t< WrappedTuple >, JsonTupleTypesList >, JsonNullable::NullVisible, Constructor >
 Map an unnamed nullable tuple-like value.
 
using json_value = basic_json_value<>
 An untyped JSON value.
 
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<JSONNAMETYPE 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, 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 >, JsonNullable::NullVisible, 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, options::EscapeValidUTF8 >
 
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 , StringInsitu ,
  Submember
}
 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 *, char *) -> BasicParsePolicy<>
 
template<typename Allocator >
 BasicParsePolicy (char *, char *, Allocator const &) -> BasicParsePolicy< json_details::default_policy_flag, Allocator >
 
 BasicParsePolicy (char *, char *, char *, char *) -> BasicParsePolicy<>
 
template<typename Allocator >
 BasicParsePolicy (char *, char *, char *, char *, Allocator const &) -> BasicParsePolicy< json_details::default_policy_flag, Allocator >
 
 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 (bool b, ErrorReason reason)
 
template<typename ParseState >
DAW_ATTRIB_NOINLINE void daw_json_error (bool b, ErrorReason reason, ParseState const &location)
 
DAW_ATTRIB_NOINLINE void daw_json_error (bool b, json_details::missing_member reason)
 
template<typename ParseState >
DAW_ATTRIB_NOINLINE void daw_json_error (bool b, json_details::missing_member reason, ParseState const &location)
 
DAW_ATTRIB_NOINLINE void daw_json_error (bool b, json_details::missing_token reason)
 
template<typename ParseState >
DAW_ATTRIB_NOINLINE void daw_json_error (bool b, json_details::missing_token reason, ParseState const &location)
 
 DAW_JSON_MAKE_REQ_TYPE_ALIAS_TRAIT_CUSTOM (ignore_unknown_members_v, json_data_contract< T >::ignore_unknown_members)
 
 DAW_JSON_MAKE_REQ_TYPE_ALIAS_TRAIT_CUSTOM (is_exact_class_mapping_v, json_data_contract< T >::exact_class_mapping)
 
template<typename T >
 DAW_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_ENABLEIF2>
 DAW_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)
 
DAW_CPP20_CX_ALLOC 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.
 
DAW_CPP20_CX_ALLOC std::vector< json_path_node > find_json_path_stack_to (json_exception const &jex, char const *doc_start)
 
DAW_CPP20_CX_ALLOC std::string find_json_path_to (char const *parse_location, char const *doc_start)
 
DAW_CPP20_CX_ALLOC 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.
 
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.
 
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.
 
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.
 
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.
 
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.
 
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.
 
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.
 
template<typename JsonMember , bool KnownBounds, typename String >
constexpr auto from_json (String &&json_data)
 Construct the JSONMember from the JSON document argument.
 
template<typename JsonMember , bool KnownBounds = false, typename String >
constexpr auto from_json (String &&json_data)
 Construct the JSONMember from the JSON document argument.
 
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.
 
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.
 
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.
 
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.
 
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.
 
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.
 
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.
 
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.
 
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.
 
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.
 
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.
 
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.
 
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.
 
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.
 
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.
 
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.
 
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.
 
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.
 
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.
 
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.
 
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.
 
template<typename JsonMember , bool KnownBounds, typename String >
constexpr auto from_json_insitu (String &&json_data)
 
template<typename JsonMember , bool KnownBounds = false, typename String >
constexpr auto from_json_insitu (String &&json_data)
 
template<typename JsonMember , bool KnownBounds, typename String , auto... PolicyFlags>
constexpr auto from_json_insitu (String &&json_data, options::parse_flags_t< PolicyFlags... >)
 Parse a writable JSON buffer with string mutation enabled. The buffer must remain alive and at a stable address while borrowed results are used. Parsing may modify the buffer, including on failure.
 
template<typename JsonMember , bool KnownBounds = false, typename String , auto... PolicyFlags>
constexpr auto from_json_insitu (String &&json_data, options::parse_flags_t< PolicyFlags... >)
 Parse a writable JSON buffer with string mutation enabled. The buffer must outlive borrowed results and keep a stable address. Parsing may modify the buffer, including on failure.
 
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_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.
 
template<typename Signature = use_default, typename String , auto... PolicyFlags, typename Callable DAW_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.
 
template<typename Signature = use_default, typename String , typename Callable DAW_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.
 
template<typename Signature = use_default, typename String , auto... PolicyFlags, typename Callable DAW_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.
 
template<typename StackContainerPolicy = use_default, std::size_t MaxDepth = daw::max_value<std::size_t>, json_options_t P, typename A , typename Handler >
DAW_ATTRIB_INLINE constexpr void json_event_parser (basic_json_value< P, A > bjv, Handler &&handler)
 
template<typename StackContainerPolicy = use_default, std::size_t MaxDepth = daw::max_value<std::size_t>, json_options_t P, typename A , typename Handler , auto... ParseFlags>
constexpr void json_event_parser (basic_json_value< P, A > bjv, Handler &&handler, options::parse_flags_t< ParseFlags... >)
 
template<typename StackContainerPolicy = use_default, std::size_t MaxDepth = daw::max_value<std::size_t>, typename Handler >
DAW_ATTRIB_INLINE void json_event_parser (daw::string_view json_document, Handler &&handler)
 
template<typename StackContainerPolicy = use_default, std::size_t MaxDepth = daw::max_value<std::size_t>, 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<auto... PolicyFlags, typename WriterType >
constexpr auto json_writer (WriterType &&writer DAW_LIFETIME_BOUND)
 
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
 
template<typename WritableOutput , typename CharT >
constexpr WritableOutput & put_output (WritableOutput &out, CharT c)
 
template<typename WritableOutput >
constexpr WritableOutput & reserve_output (WritableOutput &out, std::size_t n)
 Hint that about n more bytes will be written. Outputs without a reserve ignore it, and writes still check their own room.
 
template<typename... Policies>
constexpr json_options_t serialize_options (Policies... policies)
 
template<typename JsonClass , typename Value , auto... PolicyFlags>
DAW_CPP20_CX_ALLOC std::string to_json (Value const &value, options::output_flags_t< PolicyFlags... > flgs)
 
template<typename JsonClass = use_default, typename Value , auto... PolicyFlags>
DAW_REQUIRES(concepts::is_writable_output_type_v< daw::remove_cvref_t< WritableType > >) const expr daw DAW_CPP20_CX_ALLOC std::string to_json (Value const &value, options::output_flags_t< PolicyFlags... >=options::output_flags<>)
 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<typename JsonElement , typename Container , auto... PolicyFlags>
DAW_CPP20_CX_ALLOC std::string to_json_array (Container const &c, options::output_flags_t< PolicyFlags... > flgs)
 
template<typename JsonElement = use_default, typename Container , auto... PolicyFlags>
DAW_REQUIRES(concepts::is_writable_output_type_v< daw::remove_cvref_t< WritableType > >) const expr daw DAW_CPP20_CX_ALLOC std::string to_json_array (Container const &c, options::output_flags_t< PolicyFlags... >=options::output_flags<>)
 
DAW_ATTRIB_NOINLINE DAW_CPP20_CX_ALLOC 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.
 
template<typename T , typename WritableType , auto... PolicyFlags>
constexpr WritableType to_json_schema (WritableType &it, std::string_view id, std::string_view title, options::output_flags_t< PolicyFlags... >=options::output_flags<>)
 Generate a JSON Schema string based on the mappings for the type specified.
 
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.
 
constexpr auto ConformancePolicy
 
thread_local daw_json_error_handler_t daw_json_error_handler
 
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
 
constexpr auto fp_opts = fp_opts_t{ }
 
constexpr json_options_t fp_opts_def
 
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>
DAW_CPP20_CONCEPT 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.
 
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.
 
template<typename T >
constexpr bool use_boost_pfr = false
 Enable Boost PFR mappings for a type.
 
constexpr bool use_daw_json_exceptions_v = false
 

Detailed Description

string_writer grows its string with resize_and_overwrite, leaving the new bytes uninitialized, when the standard library has it. That skips zero filling memory that is overwritten right away, but the bytes past what was written are never initialized, which resize_and_overwrite's precondition does not allow. Define DAW_JSON_NO_LESS_SAFE_STRING_WRITER to grow with resize( ) instead

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 57 of file daw_json_assert.h.

Function Documentation

◆ DAW_REQUIRES() [1/2]

template<typename T >
daw::json::DAW_REQUIRES ( boost::describe::has_describe_members< T >::value and use_boost_describe_v< T >  )

Definition at line 67 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 48 of file daw_json_assert.h.

Variable Documentation

◆ daw_json_error_handler

thread_local daw_json_error_handler_t daw::json::daw_json_error_handler
inline
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:48

Definition at line 64 of file daw_json_assert.h.

◆ daw_json_error_handler_data

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

Definition at line 38 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 33 of file daw_json_link_describe.h.

◆ use_boost_pfr

template<typename T >
constexpr bool daw::json::use_boost_pfr = false
inlineconstexpr

Enable Boost PFR mappings for a type.

Template Parameters
T

Definition at line 27 of file daw_json_boost_pfr_mapping.h.

◆ use_daw_json_exceptions_v

constexpr bool daw::json::use_daw_json_exceptions_v = false
inlineconstexpr

Definition at line 35 of file daw_json_assert.h.

Generated by doxygen 1.9.8