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

Namespaces

 container_detect
 
 hnd_checks
 
 
 name
 
 parse_tokens
 
 parsed_constants
 
 pocm_details
 
 string_quote
 
 to_strings
 
 vector_detect
 

Classes

struct  AllocatorWrapper
 
class  AllocatorWrapper< NoAllocator >
 
class  AllocatorWrapperBase
 
class  AllocatorWrapperBase< Alloc, true >
 
struct  arrow_proxy
 
struct  auto_detect_array_element
 
struct  basic_appender
 
struct  basic_array_t
 
struct  basic_array_t< T, 0 >
 
struct  basic_stateful_json_value_state
 
struct  can_parse_to_stdstring_fast
 
struct  cannot_deduce_variant_element_types
 
struct  construct_value_tp_invoke_t
 
struct  constructor_cannot_be_invoked
 
struct  default_option_flag_t
 
struct  default_option_flag_t< OptionList< Options... > >
 
struct  default_policy_flag_t
 
struct  default_policy_flag_t< pack_list< Policies... > >
 
struct  ensure_json_type
 
struct  ensure_mapped
 
struct  exec_mode_from_tag_t
 
struct  exec_mode_from_tag_t< constexpr_exec_tag >
 
struct  exec_mode_from_tag_t< runtime_exec_tag >
 
struct  exec_mode_from_tag_t< simd_exec_tag >
 
struct  handler_result_holder
 
struct  is_std_allocator
 
struct  is_std_allocator< std::allocator< Ts... > >
 
struct  json_class_map_type
 
struct  json_data_contract_constructor_impl
 
struct  json_data_contract_constructor_impl< T, true, true >
 
struct  json_deduced_type_map
 
struct  json_deduced_type_map< AssociativeContainer, std::enable_if_t< std::conjunction_v< not_trait< has_json_data_contract_trait< AssociativeContainer > >, is_associative_container< AssociativeContainer > > > >
 
struct  json_deduced_type_map< bool >
 
struct  json_deduced_type_map< Container, std::enable_if_t< std::conjunction_v< not_trait< has_json_data_contract_trait< Container > >, not_trait< is_associative_container< Container > >, json_details::is_container< Container >, not_trait< is_string< Container > > > > >
 
struct  json_deduced_type_map< daw::string_view >
 
struct  json_deduced_type_map< Enum, std::enable_if_t< std::conjunction_v< not_trait< json_details::has_json_data_contract_trait< Enum > >, std::is_enum< Enum > > > >
 
struct  json_deduced_type_map< FloatingPoint, std::enable_if_t< std::conjunction_v< not_trait< json_details::has_json_data_contract_trait< FloatingPoint > >, daw::is_floating_point< FloatingPoint > > > >
 
struct  json_deduced_type_map< Integer, std::enable_if_t< std::conjunction_v< not_trait< json_details::has_json_data_contract_trait< Integer > >, daw::is_integral< Integer > > > >
 
struct  json_deduced_type_map< JsonType, std::enable_if_t< json_details::is_a_json_type_v< JsonType > > >
 
struct  json_deduced_type_map< std::optional< T >, std::enable_if_t< std::conjunction_v< not_trait< has_json_data_contract_trait< std::optional< T > > >, daw::is_detected< json_deduced_type_map, T > > > >
 
struct  json_deduced_type_map< std::string >
 
struct  json_deduced_type_map< std::string_view >
 
struct  json_deduced_type_map< T, std::enable_if_t< json_details::has_json_data_contract_trait_v< T > > >
 
struct  json_deduced_type_map< Tuple, std::enable_if_t< std::conjunction_v< not_trait< json_details::has_json_data_contract_trait< Tuple > >, is_tuple< Tuple > > > >
 
struct  json_link_quick_map_type
 
struct  json_parse_array_iterator
 
struct  json_parse_array_iterator_base
 
struct  json_parse_array_iterator_base< ParseState, true >
 
struct  json_parse_kv_array_iterator
 
struct  json_parse_kv_array_iterator_base
 
struct  json_parse_kv_array_iterator_base< ParseState, true >
 
struct  json_parse_kv_class_iterator
 
struct  json_parse_kv_class_iterator_base
 
struct  json_parse_kv_class_iterator_base< ParseState, true >
 
struct  json_type_deducer
 
struct  json_type_deducer< T, false, false, false, true >
 
struct  json_type_deducer< T, false, false, true, Container >
 
struct  json_type_deducer< T, false, true, QuickMap, Container >
 
struct  json_type_deducer< T, true, JsonType, QuickMap, Container >
 
struct  JsonOptionList
 
struct  location_info_t
 
struct  location_info_t< false, CharT >
 
struct  locations_info_t
 
struct  missing_default_type_mapping
 
struct  missing_required_mapping_for
 
struct  NoAllocator
 
struct  nullable_constructor_cannot_be_invoked
 
struct  option_bits_start_impl
 
struct  option_bits_start_impl< Policy, pack_list< Options... > >
 
struct  option_list_impl
 
struct  ordered_class_cleanup
 
struct  pop_json_path_result
 
struct  unknown_variant_type
 

Typedefs

template<typename ParsePolicy , typename String , auto OptionMutable, auto OptionImmutable>
using apply_mutable_policy = std::conditional_t< ParsePolicy::allow_temporarily_mutating_buffer, std::conditional_t< is_mutable_string_v< String >, apply_policy_option_t< ParsePolicy, OptionMutable >, apply_policy_option_t< ParsePolicy, OptionImmutable > >, std::conditional_t<(is_rvalue_string< String > and is_mutable_string_v< String >), apply_policy_option_t< ParsePolicy, OptionMutable >, apply_policy_option_t< ParsePolicy, OptionImmutable > >>
 
template<typename ParsePolicy , auto Option>
using apply_policy_option_t = typename ParsePolicy::template SetPolicyOptions< Option >
 
template<typename ParsePolicy , typename String , auto Option>
using apply_zstring_policy_option_t = std::conditional_t< is_zero_terminated_string_v< daw::remove_cvref_t< String > >, apply_policy_option_t< ParsePolicy, Option >, ParsePolicy >
 
template<typename T >
using base_int_type_impl = std::underlying_type< T >
 
template<typename T >
using base_int_type_t = typename std::conditional_t< std::is_enum_v< T >, base_int_type_impl< T >, daw::traits::identity< T > >::type
 
template<typename T >
using can_deref = typename std::bool_constant< daw::is_detected_v< dereffed_type_impl, T > >
 
template<typename T >
using cant_deref = daw::not_trait< can_deref< T > >
 
template<bool Nullable, typename Constructor , typename... Args>
using construction_result = std::conditional_t< Nullable, std::conditional_t< std::is_invocable_v< Constructor, Args... >, std::conditional_t< std::is_invocable_v< Constructor >, std::invoke_result< Constructor >, traits::identity< nullable_constructor_cannot_be_invoked< Constructor > > >, traits::identity< nullable_constructor_cannot_be_invoked< Constructor, Args... > > >, std::conditional_t< std::is_invocable_v< Constructor, Args... >, std::invoke_result< Constructor, Args... >, traits::identity< constructor_cannot_be_invoked< Constructor, Args... > > > >
 
template<typename JsonMember , JSONNAMETYPE NewName, bool Cond>
using copy_name_when = std::conditional_t< Cond, typename JsonMember::template with_name< NewName >, JsonMember >
 
template<typename JsonMember , JSONNAMETYPE NewName>
using copy_name_when_noname = copy_name_when< JsonMember, NewName, JsonMember::name==no_name >
 
template<typename JsonMember >
using dependent_member_t = typename JsonMember::dependent_member
 
template<typename T >
using deref_t = daw::remove_cvref_t< decltype(deref_detect(std::declval< T >()))>
 
template<typename T >
using dereffed_type = typename daw::detected_or< T, dereffed_type_impl, T >::type
 
template<typename T >
using dereffed_type_impl = daw::remove_cvref_t< decltype(*(std::declval< T & >()))>
 
template<typename Container , typename Value >
using detect_insert_end = decltype(std::declval< Container & >().insert(std::end(std::declval< Container & >()), std::declval< Value >()))
 
template<typename Container , typename Value >
using detect_push_back = decltype(std::declval< Container & >().push_back(std::declval< Value >()))
 
template<typename T >
using detected_underlying_nullable_type = std::remove_reference_t< daw::detected_t< underlying_nullable_type, T > >
 
template<JsonNullable Nullable, typename Variant >
using determine_variant_element_types = std::conditional_t< not is_nullable_json_value_v< Nullable > or not is_nullable_type< Variant >, std::remove_reference_t< decltype(get_variant_type_list(std::declval< Variant const * >()))>, std::conditional_t< is_nullable_type< Variant >, std::remove_reference_t< decltype(get_variant_type_list(std::declval< detected_underlying_nullable_type< Variant > const * >()))>, cannot_deduce_variant_element_types< Nullable, Variant > >>
 
template<typename T >
using element_type_t = typename T::element_type
 
template<typename T >
using ensure_mapped_t = typename ensure_mapped< T >::type
 
template<typename T >
using force_aggregate_construction_test = typename json_data_contract< T >::force_aggregate_construction
 
template<typename T >
using force_aggregate_construction_test2 = decltype(T::force_aggregate_construction)
 
template<typename JsonMember >
using from_json_result_t = json_result< json_deduced_type< JsonMember > >
 
template<typename T >
using from_string_test = decltype(from_string(std::declval< daw::tag_t< T > >(), std::declval< std::string_view >()))
 
template<typename Allocator >
using has_allocate_test = decltype(std::declval< Allocator & >().allocate(size_t{ 1 }))
 
template<typename Allocator >
using has_deallocate_test = decltype(std::declval< Allocator & >().deallocate(static_cast< void * >(nullptr), size_t{ 1 }))
 
template<typename T >
using has_element_type = daw::is_detected< element_type_t, T >
 
template<typename T >
using has_empty_member_test = decltype(std::declval< T >().empty())
 
template<typename T >
using has_exact_mapping_trait_in_class_map = typename json_data_contract< T >::exact_class_mapping
 
template<typename T >
using has_ignore_unknown_members_trait_in_class_map = typename json_data_contract< T >::ignore_unknown_members
 
template<typename T >
using has_json_data_constract_constructor_test = decltype(decltype(std::declval< json_data_contract_trait_t< T > >)::constructor)
 
template<typename T >
using has_json_data_contract_trait = not_trait< std::is_same< missing_json_data_contract_for< T >, json_data_contract_trait_t< T > >>
 
template<typename T >
using has_json_deduced_type = daw::not_trait< std::is_same< json_deduced_type< T >, missing_json_data_contract_for< T > >>
 
template<typename T >
using has_json_link_quick_map = decltype(json_link_quick_map< T >())
 
template<typename T , typename U >
using has_lshift_test = decltype(operator<<(std::declval< T & >(), std::declval< U const & >()))
 
template<typename T >
using has_op_bool_test = decltype(static_cast< bool >(std::declval< T >()))
 
template<typename T >
using has_op_star_test = decltype(*std::declval< T >())
 
template<typename T , typename U >
using has_rshift_test = decltype(operator>>(std::declval< T & >(), std::declval< U const & >()))
 
template<typename T >
using is_a_json_tagged_variant = daw::is_detected< is_a_json_tagged_variant_test, T >
 
template<typename T >
using is_a_json_tagged_variant_test = typename T::i_am_a_json_tagged_variant
 
template<typename T >
using is_a_json_type = std::bool_constant< daw::is_detected_v< json_type_t, T > >
 
template<typename AssociativeContainer >
using is_associative_container = std::conjunction< is_container< AssociativeContainer >, daw::is_detected< container_detect::container_key_type, AssociativeContainer >, daw::is_detected< container_detect::container_mapped_type, AssociativeContainer > >
 
template<typename T >
using is_container = std::conjunction< daw::is_detected< container_detect::container_value_type, T >, daw::is_detected< container_detect::container_begin_type, T >, daw::is_detected< container_detect::container_end_type, T > >
 
template<typename Container >
using is_container_opted_into_json_iostreams = is_opted_into_json_iostreams< typename Container::value_type >
 
template<typename JsonType >
using is_json_class_map_test = typename JsonType::json_member
 
template<typename JsonType >
using is_json_nullable = std::bool_constant< JsonType::expected_type==JsonParseTypes::Null >
 
template<typename JsonMember >
using is_no_name = std::bool_constant< JsonMember::name==no_name >
 
template<JsonNullable nullable>
using is_nullable_json_value = std::bool_constant< nullable !=JsonNullable::MustExist >
 
template<typename T >
using is_opted_into_json_iostreams = typename json_data_contract< T >::opt_into_iostreams
 
template<typename String >
using is_string = std::conjunction< is_container< String >, container_detect::is_value_type_char< String > >
 
template<typename T >
using is_string_view_like = std::conjunction< daw::is_detected< is_string_like_impl::has_data_test, T >, daw::is_detected< is_string_like_impl::has_size_test, T > >
 
template<typename T >
using is_submember_tagged_variant_t = typename json_data_contract< T >::type::i_am_a_submember_tagged_variant
 
template<typename T >
using is_tuple = daw::is_detected< json_details::tuple_test, T >
 Detect if T follows the tuple protocol. More...
 
template<typename T >
using is_vector = std::bool_constant< vector_detect::vector_test< T >::value >
 
template<typename JsonMember >
using json_base_type = typename JsonMember::base_type
 
template<typename T , typename Default >
using json_class_constructor_t = typename std::conditional_t< daw::is_detected< json_data_contract_constructor_t, T >::value, json_data_contract_constructor< T >, daw::traits::identity< Default > >::type
 
template<typename Constructor , typename... Members>
using json_class_parse_result_impl = daw::detected_t< json_class_parse_result_impl2, Constructor, Members... >
 
template<typename Constructor , typename... Members>
using json_class_parse_result_impl2 = decltype(Constructor{ }(std::declval< typename Members::parse_to_t && >()...))
 
template<typename Constructor , typename... Members>
using json_class_parse_result_t = daw::remove_cvref_t< json_class_parse_result_impl< Constructor, Members... > >
 
template<typename T >
using json_data_contract_constructor = json_data_contract_constructor_impl< T, daw::is_detected< json_data_contract_trait_t, T >::value, daw::is_detected< has_json_data_constract_constructor_test, T >::value >
 
template<typename T >
using json_data_contract_constructor_t = typename json_data_contract_constructor< T >::type
 
template<typename T >
using json_deduced_type = typename json_type_deducer< T, has_json_data_contract_trait_v< T >, json_details::is_a_json_type_v< T >, has_json_link_quick_map_v< T >, is_container_v< T > >::type
 
template<typename T >
using json_link_quick_map_t = typename decltype(json_link_quick_map< T >())::mapped_type
 
template<typename T >
using json_map_alias_test = typename json_data_contract_trait_t< T >::i_am_a_json_map_alias
 
template<typename T >
using json_member_constructor_t = typename T::constructor_t
 
template<typename T >
using json_member_parse_to_t = typename T::parse_to_t
 
using json_options_t = std::uint32_t
 
template<typename T >
using json_parser_to_json_data_t = decltype(json_data_contract< T >::to_json_data(std::declval< T & >()))
 
template<typename JsonMember >
using json_result = typename JsonMember::parse_to_t
 
template<typename T >
using json_type_t = typename T::i_am_a_json_type
 
template<JsonRangeCheck RangeCheck, typename Unsigned , typename MaxArithUnsigned >
using max_unsigned_t = std::conditional_t< std::disjunction< daw::is_integral< Unsigned >, std::is_enum< Unsigned > >::value, std::conditional_t<(sizeof(Unsigned) > sizeof(MaxArithUnsigned)), Unsigned, MaxArithUnsigned >, Unsigned >
 
template<typename T >
using ordered_member_subtype_t = typename daw::detected_or_t< T, ordered_member_subtype_test, T >
 
template<typename T >
using ordered_member_subtype_test = typename T::json_member
 
template<typename T >
using ordered_member_t = typename T::i_am_an_ordered_member
 
template<typename JsonMember >
using ordered_member_wrapper = std::conditional_t< is_an_ordered_member_v< JsonMember >, JsonMember, json_deduced_type< JsonMember > >
 
using policy_list = typename option_list_impl< ExecModeTypes, ZeroTerminatedString, PolicyCommentTypes, CheckedParseMode, AllowEscapedNames, IEEE754Precise, ForceFullNameCheck, MinifiedDocument, UseExactMappingsByDefault, TemporarilyMutateBuffer, MustVerifyEndOfDataIsValid, ExcludeSpecialEscapes >::type
 
template<typename JsonMember >
using switcher_t = typename JsonMember::switcher
 
template<typename T >
using tuple_test = typename tuple_elements_pack< T >::type
 
template<typename T >
using underlying_nullable_type = decltype(*std::declval< T >())
 
template<typename T , JsonNullable Nullable>
using unwrap_type = typename std::conditional_t< is_nullable_json_value_v< Nullable >, dereffed_type< T >, T >
 
template<typename JsonMember >
using without_name = typename JsonMember::without_name
 

Enumerations

enum class  AllMembersMustExist { yes , no }
 

Functions

template<typename T >
constexpr daw::remove_cvref_t< T > as_copy (T &&value)
 
template<bool is_unchecked_input>
constexpr UInt16 byte_from_nibbles (char const *&first)
 
template<typename Value , typename Constructor , typename ParseState , typename... Args>
static constexpr DAW_ATTRIB_FLATINLINE auto construct_value (template_params< Value, Constructor >, ParseState &parse_state, Args &&...args)
 
template<typename Value , typename Constructor , typename ParseState , typename... Args>
static constexpr DAW_ATTRIB_FLATINLINE auto construct_value_tp (ParseState &parse_state, fwd_pack< Args... > &&tp_args)
 
template<typename Predicate >
constexpr DAW_ATTRIB_FLATINLINE std::int32_t count_4digits (char const *first, Predicate pred)
 
template<typename Predicate >
constexpr DAW_ATTRIB_FLATINLINE std::int32_t count_8digits (char const *first, Predicate pred)
 
template<typename CharT >
constexpr DAW_ATTRIB_FLATTEN CharT * count_digits (CharT *first, CharT *last)
 
template<typename ParseState , typename Appender >
static constexpr void decode_utf16 (ParseState &parse_state, Appender &app)
 
template<typename ParseState >
static constexpr char * decode_utf16 (ParseState &parse_state, char *it)
 
template<std::size_t , typename JsonMember , typename , typename OutputIterator , typename TpArgs , typename Value , typename VisitedMembers , std::enable_if_t< not has_dependent_member_v< JsonMember >, std::nullptr_t > = nullptr>
constexpr void dependent_member_to_json_str (bool &, OutputIterator const &, TpArgs const &, Value const &, VisitedMembers const &)
 
template<std::size_t pos, typename JsonMember , typename NamePack , typename OutputIterator , typename TpArgs , typename Value , typename VisitedMembers , std::enable_if_t< has_dependent_member_v< JsonMember >, std::nullptr_t > = nullptr>
constexpr void dependent_member_to_json_str (bool &is_first, OutputIterator it, TpArgs const &args, Value const &v, VisitedMembers &visited_members)
 
constexpr void deref_detect (...)
 
template<typename T >
constexpr auto deref_detect (T &&value) -> decltype(*value)
 
template<typename... MemberNames>
constexpr bool do_hashes_collide ()
 
template<std::size_t pos, AllMembersMustExist must_exist, bool from_start = false, std::size_t N, typename ParseState , bool B, typename CharT >
constexpr std::pair< ParseState, bool > find_class_member (ParseState &parse_state, locations_info_t< N, CharT, B > &locations, bool is_nullable, daw::string_view member_name)
 
template<JsonBaseParseTypes PT>
constexpr std::size_t find_json_element (std::initializer_list< JsonBaseParseTypes > pts)
 
std::ptrdiff_t find_lsb_set (runtime_exec_tag, UInt32 value)
 
template<typename Needle , typename... Haystack>
constexpr std::size_t find_names_in_pack (daw::fwd_pack< Haystack... >)
 
template<typename ParsePolicy , typename String >
constexpr std::pair< bool, ParsePolicy > find_range (String &&str, daw::string_view start_path)
 
template<typename ParsePolicy , typename String , typename Allocator >
constexpr auto find_range (String &&str, daw::string_view start_path, Allocator &alloc)
 
template<typename ParseState >
constexpr bool find_range2 (ParseState &parse_state, daw::string_view path)
 
template<typename Policy , typename Result = Policy>
constexpr Result get_bits_for (json_options_t value)
 
template<typename Option , typename Result = Option, typename... OptionList>
constexpr Result get_bits_for (JsonOptionList< OptionList... >, json_options_t value)
 
template<typename... Ts>
constexpr std::conditional_t< std::conjunction< has_json_deduced_type< Ts >... >::value, json_variant_type_list< json_deduced_type< Ts >... >, missing_default_type_mapping< json_deduced_type< Ts >... > > get_variant_type_list (std::variant< Ts... > const *)
 
template<typename T >
constexpr unknown_variant_type< T > get_variant_type_list (T const *)
 
template<typename Handler >
constexpr handler_result_holder handle_on_array_end (Handler &&handler)
 
template<typename Handler , typename ParseState >
constexpr handler_result_holder handle_on_array_start (Handler &&handler, basic_json_value< ParseState > jv)
 
template<typename Handler , typename ParseState >
constexpr handler_result_holder handle_on_bool (Handler &&handler, basic_json_value< ParseState > jv)
 
template<typename Handler >
constexpr handler_result_holder handle_on_class_end (Handler &&handler)
 
template<typename Handler , typename ParseState >
constexpr handler_result_holder handle_on_class_start (Handler &&handler, basic_json_value< ParseState > jv)
 
template<typename Handler , typename ParseState >
constexpr handler_result_holder handle_on_error (Handler &&handler, basic_json_value< ParseState > jv)
 
template<typename Handler , typename ParseState >
constexpr handler_result_holder handle_on_null (Handler &&handler, basic_json_value< ParseState > &jv)
 
template<typename Handler , typename ParseState >
constexpr handler_result_holder handle_on_number (Handler &&handler, basic_json_value< ParseState > &jv)
 
template<typename Handler , typename ParseState >
constexpr handler_result_holder handle_on_string (Handler &&handler, basic_json_value< ParseState > &jv)
 
template<typename Handler , typename ParseState >
constexpr handler_result_holder handle_on_value (Handler &&handler, basic_json_pair< ParseState > p)
 
template<typename T >
constexpr auto has_value (T const &v) -> std::enable_if_t< is_readable_v< T >, bool >
 
constexpr DAW_ATTRIB_FLATINLINE bool is_escaped (char const *ptr, char const *min_ptr)
 
static constexpr bool is_made_of_eight_digits_cx (const char *ptr)
 
template<typename T >
constexpr bool is_null (std::optional< T > const &v)
 
template<typename T >
constexpr bool is_null (T const &)
 
template<typename Key , typename Value >
constexpr Key const & json_get_key (std::pair< Key, Value > const &kv)
 
template<typename Key , typename Value >
constexpr Value const & json_get_value (std::pair< Key, Value > const &kv)
 
template<typename T >
constexpr auto json_link_quick_map ()
 
template<typename... OptionList, typename... Options>
constexpr json_options_t json_option (JsonOptionList< OptionList... >, Options... options)
 
constexpr bool json_path_compare (daw::string_view json_path_item, daw::string_view member_name)
 
template<typename ParseState , typename... JsonMembers>
constexpr DAW_ATTRIB_FLATINLINE auto make_locations_info ()
 
template<bool is_unchecked_input, char... keys, typename CharT >
DAW_ATTRIB_FLATINLINE CharT * mem_move_to_next_of (runtime_exec_tag, CharT *first, CharT *last)
 
template<bool is_unchecked_input, typename ExecTag , typename CharT , std::enable_if_t< std::is_base_of< runtime_exec_tag, ExecTag >::value, std::nullptr_t > = nullptr>
DAW_ATTRIB_FLATINLINE CharT * mem_skip_string (ExecTag const &tag, CharT *first, CharT *const last)
 
template<bool is_unchecked_input, typename ExecTag , typename CharT , std::enable_if_t< std::is_base_of< runtime_exec_tag, ExecTag >::value, std::nullptr_t > = nullptr>
DAW_ATTRIB_FLATINLINE CharT * mem_skip_until_end_of_string (ExecTag const &tag, CharT *first, CharT *const last)
 
template<bool is_unchecked_input, typename CharT >
DAW_ATTRIB_FLATINLINE CharT * mem_skip_until_end_of_string (runtime_exec_tag tag, CharT *first, CharT *const last, std::ptrdiff_t &first_escape)
 
template<typename JsonMember , typename OutputIterator , typename T >
constexpr OutputIterator member_to_string (template_param< JsonMember >, OutputIterator it, T const &value)
 
template<typename ParseState >
constexpr bool needs_slow_path (ParseState const &parse_state)
 
template<typename T >
constexpr auto number_parse_type_test () -> std::enable_if_t< std::is_enum< T >::value, JsonParseTypes >
 
template<typename OutputIterator >
constexpr OutputIterator output_hex (std::uint16_t c, OutputIterator it)
 
constexpr UInt64 parse_16_digits (const char *const str)
 
constexpr UInt64 parse_8_digits (const char *const str)
 
template<std::size_t member_position, typename JsonMember , AllMembersMustExist must_exist, bool NeedsClassPositions, typename ParseState , std::size_t N, typename CharT , bool B>
constexpr json_result< JsonMember > parse_class_member (ParseState &parse_state, locations_info_t< N, CharT, B > &locations)
 
static constexpr DAW_ATTRIB_FLATINLINE unsigned parse_digit (char c)
 
template<bool skip_end_check, typename Unsigned >
constexpr DAW_ATTRIB_FLATINLINE void parse_digits_until_last (char const *first, char const *const last, Unsigned &v)
 
template<bool skip_end_check, typename Unsigned , typename CharT >
constexpr DAW_ATTRIB_FLATINLINE CharT * parse_digits_while_number (CharT *first, CharT *const last, Unsigned &v)
 
template<typename JsonClass , typename... JsonMembers, typename ParseState , std::size_t... Is>
constexpr json_result< JsonClass > parse_json_class (ParseState &parse_state, std::index_sequence< Is... >)
 
template<typename ParseState >
constexpr DAW_ATTRIB_FLATTEN daw::string_view parse_name (ParseState &parse_state)
 
template<std::size_t N, typename JsonClass , bool KnownBounds, typename... JsonClasses, typename ParseState >
constexpr DAW_ATTRIB_FLATTEN json_result< JsonClass > parse_nth_class (std::size_t idx, ParseState &parse_state)
 
template<typename JsonMember , typename ParseState >
constexpr json_result< JsonMember > parse_ordered_class_member (template_param< JsonMember >, std::size_t &member_index, ParseState &parse_state)
 
template<typename JsonClass , typename... JsonMembers, typename ParseState >
static constexpr json_result< JsonClass > parse_ordered_json_class (template_params< JsonClass, JsonMembers... >, ParseState &parse_state)
 
template<typename Result , bool KnownRange, typename ParseState , std::enable_if_t< KnownRange, std::nullptr_t > = nullptr>
constexpr DAW_ATTRIB_FLATINLINE Result parse_real (ParseState &parse_state)
 
template<bool AllowHighEight, typename JsonMember , bool KnownBounds, typename ParseState >
constexpr auto parse_string_known_stdstring (ParseState &parse_state)
 
template<typename JsonMember , bool KnownBounds, typename ParseState , std::size_t... Is>
constexpr DAW_ATTRIB_FLATINLINE json_result< JsonMember > parse_tuple_value (ParseState &parse_state, std::index_sequence< Is... >)
 
template<typename JsonMember , bool KnownBounds, typename ParseState >
constexpr DAW_ATTRIB_FLATTEN json_result< JsonMember > parse_value (ParseState &parse_state, ParseTag< JsonParseTypes::Array >)
 
template<typename JsonMember , bool KnownBounds = false, typename ParseState >
constexpr json_result< JsonMember > parse_value (ParseState &parse_state, ParseTag< JsonParseTypes::Array >)
 
template<typename JsonMember , bool KnownBounds, typename ParseState >
constexpr DAW_ATTRIB_INLINE json_result< JsonMember > parse_value (ParseState &parse_state, ParseTag< JsonParseTypes::Bool >)
 
template<typename JsonMember , bool KnownBounds = false, typename ParseState >
constexpr json_result< JsonMember > parse_value (ParseState &parse_state, ParseTag< JsonParseTypes::Bool >)
 
template<typename JsonMember , bool KnownBounds, typename ParseState >
constexpr DAW_ATTRIB_FLATTEN json_result< JsonMember > parse_value (ParseState &parse_state, ParseTag< JsonParseTypes::Class >)
 
template<typename JsonMember , bool KnownBounds = false, typename ParseState >
constexpr json_result< JsonMember > parse_value (ParseState &parse_state, ParseTag< JsonParseTypes::Class >)
 
template<typename JsonMember , bool KnownBounds, typename ParseState >
constexpr json_result< JsonMember > parse_value (ParseState &parse_state, ParseTag< JsonParseTypes::Custom >)
 
template<typename JsonMember , bool KnownBounds, typename ParseState >
constexpr DAW_ATTRIB_INLINE json_result< JsonMember > parse_value (ParseState &parse_state, ParseTag< JsonParseTypes::Date >)
 
template<typename JsonMember , bool KnownBounds = false, typename ParseState >
constexpr json_result< JsonMember > parse_value (ParseState &parse_state, ParseTag< JsonParseTypes::Date >)
 
template<typename JsonMember , bool KnownBounds, typename ParseState >
constexpr DAW_ATTRIB_FLATTEN json_result< JsonMember > parse_value (ParseState &parse_state, ParseTag< JsonParseTypes::KeyValue >)
 
template<typename JsonMember , bool KnownBounds = false, typename ParseState >
constexpr json_result< JsonMember > parse_value (ParseState &parse_state, ParseTag< JsonParseTypes::KeyValue >)
 
template<typename JsonMember , bool KnownBounds, typename ParseState >
constexpr DAW_ATTRIB_FLATTEN json_result< JsonMember > parse_value (ParseState &parse_state, ParseTag< JsonParseTypes::KeyValueArray >)
 
template<typename JsonMember , bool KnownBounds = false, typename ParseState >
constexpr json_result< JsonMember > parse_value (ParseState &parse_state, ParseTag< JsonParseTypes::KeyValueArray >)
 
template<typename JsonMember , bool KnownBounds, typename ParseState >
constexpr DAW_ATTRIB_INLINE json_result< JsonMember > parse_value (ParseState &parse_state, ParseTag< JsonParseTypes::Null >)
 
template<typename JsonMember , bool KnownBounds = false, typename ParseState >
constexpr json_result< JsonMember > parse_value (ParseState &parse_state, ParseTag< JsonParseTypes::Null >)
 
template<typename JsonMember , bool KnownBounds, typename ParseState >
constexpr DAW_ATTRIB_INLINE json_result< JsonMember > parse_value (ParseState &parse_state, ParseTag< JsonParseTypes::Real >)
 
template<typename JsonMember , bool KnownBounds = false, typename ParseState >
constexpr json_result< JsonMember > parse_value (ParseState &parse_state, ParseTag< JsonParseTypes::Real >)
 
template<typename JsonMember , bool KnownBounds, typename ParseState >
constexpr DAW_ATTRIB_INLINE json_result< JsonMember > parse_value (ParseState &parse_state, ParseTag< JsonParseTypes::Signed >)
 
template<typename JsonMember , bool KnownBounds = false, typename ParseState >
constexpr json_result< JsonMember > parse_value (ParseState &parse_state, ParseTag< JsonParseTypes::Signed >)
 
template<typename JsonMember , bool KnownBounds, typename ParseState >
constexpr DAW_ATTRIB_FLATTEN json_result< JsonMember > parse_value (ParseState &parse_state, ParseTag< JsonParseTypes::SizedArray >)
 
template<typename JsonMember , bool KnownBounds = false, typename ParseState >
constexpr json_result< JsonMember > parse_value (ParseState &parse_state, ParseTag< JsonParseTypes::SizedArray >)
 
template<typename JsonMember , bool KnownBounds, typename ParseState >
constexpr json_result< JsonMember > parse_value (ParseState &parse_state, ParseTag< JsonParseTypes::StringEscaped >)
 
template<typename JsonMember , bool KnownBounds, typename ParseState >
constexpr DAW_ATTRIB_INLINE json_result< JsonMember > parse_value (ParseState &parse_state, ParseTag< JsonParseTypes::StringRaw >)
 
template<typename JsonMember , bool KnownBounds = false, typename ParseState >
constexpr json_result< JsonMember > parse_value (ParseState &parse_state, ParseTag< JsonParseTypes::StringRaw >)
 
template<typename JsonMember , bool KnownBounds, typename ParseState >
constexpr DAW_ATTRIB_FLATINLINE json_result< JsonMember > parse_value (ParseState &parse_state, ParseTag< JsonParseTypes::Tuple >)
 
template<typename JsonMember , bool KnownBounds = false, typename ParseState >
constexpr json_result< JsonMember > parse_value (ParseState &parse_state, ParseTag< JsonParseTypes::Tuple >)
 
template<typename JsonMember , bool KnownBounds, typename ParseState >
constexpr DAW_ATTRIB_FLATINLINE json_result< JsonMember > parse_value (ParseState &parse_state, ParseTag< JsonParseTypes::Unknown >)
 
template<typename JsonMember , bool KnownBounds = false, typename ParseState >
constexpr json_result< JsonMember > parse_value (ParseState &parse_state, ParseTag< JsonParseTypes::Unknown >)
 
template<typename JsonMember , bool KnownBounds, typename ParseState >
constexpr DAW_ATTRIB_INLINE json_result< JsonMember > parse_value (ParseState &parse_state, ParseTag< JsonParseTypes::Unsigned >)
 
template<typename JsonMember , bool KnownBounds = false, typename ParseState >
constexpr json_result< JsonMember > parse_value (ParseState &parse_state, ParseTag< JsonParseTypes::Unsigned >)
 
template<typename JsonMember , bool , typename ParseState >
constexpr DAW_ATTRIB_INLINE json_result< JsonMember > parse_value (ParseState &parse_state, ParseTag< JsonParseTypes::Variant >)
 
template<typename JsonMember , bool KnownBounds = false, typename ParseState >
constexpr json_result< JsonMember > parse_value (ParseState &parse_state, ParseTag< JsonParseTypes::Variant >)
 
template<typename JsonMember , bool , typename ParseState >
constexpr DAW_ATTRIB_INLINE json_result< JsonMember > parse_value (ParseState &parse_state, ParseTag< JsonParseTypes::VariantTagged >)
 
template<typename JsonMember , bool KnownBounds, std::size_t N, typename ParseState , bool B>
constexpr json_result< JsonMember > parse_value (ParseState &parse_state, ParseTag< JsonParseTypes::VariantTagged >)
 
template<typename JsonMember , bool KnownBounds = false, typename ParseState >
constexpr json_result< JsonMember > parse_value (ParseState &parse_state, ParseTag< JsonParseTypes::VariantTagged >)
 
template<JsonBaseParseTypes BPT, typename JsonMembers , typename ParseState >
constexpr DAW_ATTRIB_FLATTEN json_result< JsonMembers > parse_variant_value (ParseState &parse_state)
 
template<typename Result , typename TypeList , std::size_t pos = 0, typename ParseState >
constexpr DAW_ATTRIB_FLATINLINE Result parse_visit (std::size_t idx, ParseState &parse_state)
 
template<typename Real , std::enable_if_t< std::is_floating_point_v< Real >, std::nullptr_t > = nullptr>
DAW_ATTRIB_NOINLINE Real parse_with_strtod (char const *first, char const *last)
 
constexpr pop_json_path_result pop_json_path (daw::string_view &path)
 
template<typename Result , typename Unsigned >
static constexpr DAW_ATTRIB_FLATINLINE Result power10 (constexpr_exec_tag, Result result, Unsigned p)
 
template<typename Result , typename Unsigned >
static constexpr DAW_ATTRIB_FLATINLINE Result power10 (runtime_exec_tag, Result result, Unsigned p)
 
template<typename... JsonMembers, typename OutputIterator , std::size_t... Is, typename Tuple , typename Value >
constexpr OutputIterator serialize_json_class (OutputIterator it, Tuple const &args, Value const &value, std::index_sequence< Is... >)
 
template<typename... JsonMembers, typename OutputIterator , typename Tuple , typename Value , std::size_t... Is>
constexpr OutputIterator serialize_ordered_json_class (OutputIterator it, Tuple const &args, Value const &value, std::index_sequence< Is... >)
 
template<typename Policy , typename... Policies>
constexpr json_options_t set_bits (json_options_t value, Policy pol, Policies... pols)
 
template<typename... OptionList, typename Option , typename... Options>
constexpr json_options_t set_bits (JsonOptionList< OptionList... >, json_options_t value, Option pol, Options... pols)
 
template<typename... OptionList, typename Option >
static constexpr json_options_t set_bits_for (JsonOptionList< OptionList... >, Option e)
 
template<typename Policy >
constexpr json_options_t set_bits_for (Policy e)
 
template<typename Policy >
constexpr void set_bits_in (json_options_t &value, Policy e)
 
template<typename... OptionList, typename Option >
constexpr void set_bits_in (JsonOptionList< OptionList... >, json_options_t &value, Option e)
 
template<bool skip_end_check, typename CharT >
constexpr DAW_ATTRIB_FLATINLINE CharT * skip_digits (CharT *first, CharT *const last)
 
template<typename ParseState >
constexpr ParseState skip_false (ParseState &parse_state)
 
template<typename JsonMember , typename ParseState >
constexpr DAW_ATTRIB_FLATINLINE ParseState skip_known_value (ParseState &parse_state)
 
template<typename ParseState >
constexpr ParseState skip_literal (ParseState &parse_state)
 
template<typename ParseState >
constexpr ParseState skip_null (ParseState &parse_state)
 
template<typename ParseState >
constexpr ParseState skip_number (ParseState &parse_state)
 
template<LiteralAsStringOpt literal_as_string, typename ParseState >
constexpr DAW_ATTRIB_INLINE void skip_quote_when_literal_as_string (ParseState &parse_state)
 
template<typename ParseState >
constexpr DAW_ATTRIB_FLATINLINE ParseState skip_string (ParseState &parse_state)
 
template<typename ParseState >
constexpr DAW_ATTRIB_FLATINLINE ParseState skip_string_nq (ParseState &parse_state)
 
template<typename ParseState >
constexpr ParseState skip_true (ParseState &parse_state)
 
template<typename ParseState >
constexpr ParseState skip_value (ParseState &parse_state)
 
template<typename JsonMember , typename OutputIterator , typename parse_to_t >
constexpr OutputIterator to_daw_json_string (ParseTag< JsonParseTypes::Array >, OutputIterator it, parse_to_t const &value)
 
template<typename JsonMember , typename OutputIterator , typename parse_to_t >
constexpr OutputIterator to_daw_json_string (ParseTag< JsonParseTypes::Bool >, OutputIterator it, parse_to_t const &value)
 
template<typename JsonMember , typename OutputIterator , typename parse_to_t >
constexpr OutputIterator to_daw_json_string (ParseTag< JsonParseTypes::Class >, OutputIterator it, parse_to_t const &value)
 
template<typename JsonMember , typename OutputIterator , typename parse_to_t >
constexpr OutputIterator to_daw_json_string (ParseTag< JsonParseTypes::Custom >, OutputIterator it, parse_to_t const &value)
 
template<typename JsonMember , typename OutputIterator , typename parse_to_t >
constexpr OutputIterator to_daw_json_string (ParseTag< JsonParseTypes::Date >, OutputIterator it, parse_to_t const &value)
 
template<typename JsonMember , typename OutputIterator , typename parse_to_t >
constexpr OutputIterator to_daw_json_string (ParseTag< JsonParseTypes::KeyValue >, OutputIterator it, parse_to_t const &value)
 
template<typename JsonMember , typename OutputIterator , typename parse_to_t >
constexpr OutputIterator to_daw_json_string (ParseTag< JsonParseTypes::KeyValueArray >, OutputIterator it, parse_to_t const &value)
 
template<typename JsonMember , typename OutputIterator , typename Optional >
constexpr OutputIterator to_daw_json_string (ParseTag< JsonParseTypes::Null >, OutputIterator it, Optional const &value)
 
template<typename JsonMember , typename OutputIterator , typename parse_to_t >
constexpr OutputIterator to_daw_json_string (ParseTag< JsonParseTypes::Null >, OutputIterator it, parse_to_t const &value)
 
template<typename JsonMember , typename OutputIterator , typename parse_to_t >
OutputIterator to_daw_json_string (ParseTag< JsonParseTypes::Real >, OutputIterator it, parse_to_t const &value)
 
template<typename JsonMember , typename OutputIterator , typename parse_to_t >
constexpr OutputIterator to_daw_json_string (ParseTag< JsonParseTypes::Signed >, OutputIterator it, parse_to_t const &value)
 
template<typename JsonMember , typename OutputIterator , typename parse_to_t >
constexpr OutputIterator to_daw_json_string (ParseTag< JsonParseTypes::SizedArray >, OutputIterator it, parse_to_t const &value)
 
template<typename JsonMember , typename OutputIterator , typename parse_to_t >
constexpr OutputIterator to_daw_json_string (ParseTag< JsonParseTypes::StringEscaped >, OutputIterator it, parse_to_t const &value)
 
template<typename JsonMember , typename OutputIterator , typename parse_to_t >
constexpr OutputIterator to_daw_json_string (ParseTag< JsonParseTypes::StringRaw >, OutputIterator it, parse_to_t const &value)
 
template<typename JsonMember , typename OutputIterator , typename parse_to_t >
constexpr OutputIterator to_daw_json_string (ParseTag< JsonParseTypes::Tuple >, OutputIterator it, parse_to_t const &value)
 
template<typename JsonMember , typename OutputIterator , typename parse_to_t >
constexpr OutputIterator to_daw_json_string (ParseTag< JsonParseTypes::Unknown >, OutputIterator it, parse_to_t const &value)
 
template<typename JsonMember , typename OutputIterator , typename parse_to_t >
constexpr OutputIterator to_daw_json_string (ParseTag< JsonParseTypes::Unsigned >, OutputIterator it, parse_to_t const &value)
 
template<typename JsonMember , typename OutputIterator , typename parse_to_t >
constexpr OutputIterator to_daw_json_string (ParseTag< JsonParseTypes::Variant >, OutputIterator it, parse_to_t const &value)
 
template<typename JsonMember , typename OutputIterator , typename parse_to_t >
constexpr OutputIterator to_daw_json_string (ParseTag< JsonParseTypes::VariantTagged >, OutputIterator it, parse_to_t const &value)
 
template<typename JsonMember , typename OutputIterator , typename parse_to_t , std::size_t... Is>
OutputIterator to_daw_json_string_tuple (OutputIterator it, parse_to_t const &value, std::index_sequence< Is... >)
 
template<size_t TupleIdx, typename JsonMember , typename OutputIterator , template< class... > class Tuple, typename... Args>
constexpr void to_json_ordered_str (std::size_t &array_idx, OutputIterator &it, Tuple< Args... > const &tp)
 
template<std::size_t pos, typename JsonMember , typename OutputIterator , typename Tuple , typename Value , typename Visited >
constexpr void to_json_str (bool &is_first, OutputIterator &it, Tuple const &tp, Value const &, Visited &visited_members)
 
constexpr UInt8 to_nibble (unsigned char chr)
 
template<typename Char >
constexpr char to_nibble_char (Char c)
 
template<std::size_t idx, typename JsonMembers , typename OutputIterator , typename parse_to_t >
constexpr void to_variant_string (OutputIterator &it, parse_to_t const &value)
 
constexpr char u32toC (UInt32 value)
 
template<typename T >
uneval_func ()
 
template<typename Unsigned , JsonRangeCheck RangeChecked, bool KnownBounds, typename ParseState , std::enable_if_t< KnownBounds, std::nullptr_t > = nullptr>
static constexpr Unsigned unsigned_parser (constexpr_exec_tag, ParseState &parse_state)
 
template<typename OutputIterator >
constexpr void utf32_to_utf8 (std::uint32_t cp, OutputIterator &it)
 

Variables

template<typename T , typename ParseState >
constexpr bool all_json_members_must_exist_v
 
template<typename Option , typename Options >
constexpr unsigned basic_option_bits_start
 
template<typename Policy , typename Policies >
constexpr unsigned basic_policy_bits_start
 
template<json_options_t CurrentOptions, auto option, auto... options>
constexpr json_options_t bool_opts_set
 
template<typename Constructor , typename... Members>
constexpr bool can_defer_construction_v
 
template<typename T >
constexpr bool can_deref_v = can_deref<T>::value
 
template<bool IsKnown>
constexpr bool can_random_v = IsKnown
 
template<json_options_t CurrentOptions, auto option, auto... options>
constexpr json_options_t class_opts_set
 
template<typename Constructor >
constexpr auto construct_value_tp_invoke
 
template<typename >
constexpr auto default_json_option_value
 
template<>
constexpr auto default_json_option_value< AllowEscapeCharacter >
 
template<>
constexpr auto default_json_option_value< AllowEscapedNames >
 
template<>
constexpr auto default_json_option_value< CheckedParseMode >
 
template<>
constexpr auto default_json_option_value< EightBitModes >
 
template<>
constexpr auto default_json_option_value< EmptyStringNull >
 
template<>
constexpr auto default_json_option_value< ExcludeSpecialEscapes >
 
template<>
constexpr auto default_json_option_value< ExecModeTypes >
 
template<>
constexpr auto default_json_option_value< ForceFullNameCheck >
 
template<>
constexpr auto default_json_option_value< IEEE754Precise >
 
template<>
constexpr auto default_json_option_value< JsonCustomTypes >
 
template<>
constexpr auto default_json_option_value< JsonNullable >
 
template<>
constexpr auto default_json_option_value< JsonRangeCheck >
 
template<>
constexpr auto default_json_option_value< LiteralAsStringOpt >
 
template<>
constexpr auto default_json_option_value< MinifiedDocument >
 
template<>
constexpr auto default_json_option_value< MustVerifyEndOfDataIsValid >
 
template<>
constexpr auto default_json_option_value< PolicyCommentTypes >
 
template<>
constexpr auto default_json_option_value< TemporarilyMutateBuffer >
 
template<>
constexpr auto default_json_option_value< UseExactMappingsByDefault >
 
template<>
constexpr auto default_json_option_value< ZeroTerminatedString >
 
constexpr char const default_key_name [] = "key"
 
template<typename OptionList >
static constexpr json_options_t default_option_flag
 
static constexpr json_options_t default_policy_flag
 
constexpr char const default_value_name [] = "value"
 
constexpr auto digits100
 
constexpr double dpow10_tbl []
 
template<typename ExecMode >
constexpr ExecModeTypes exec_mode_from_tag
 
template<typename T >
constexpr bool has_deduced_type_mapping_v
 
template<typename JsonMember >
constexpr bool has_dependent_member_v
 
template<typename T >
constexpr bool has_empty_member_v
 
template<typename T >
constexpr bool has_from_string_v
 
template<typename Container , typename Value >
constexpr bool has_insert_end_v
 
template<typename T >
constexpr bool has_istream_op_v
 
template<typename T >
constexpr bool has_json_data_contract_trait_v
 
template<typename T >
constexpr bool has_json_link_quick_map_v
 
template<typename T >
constexpr bool has_json_member_constructor_v
 
template<typename T >
constexpr bool has_json_member_parse_to_v
 
template<typename T >
constexpr bool has_json_to_json_data_v
 
template<typename T >
constexpr bool has_op_bool_v
 
template<typename T >
constexpr bool has_op_star_v
 
template<typename T >
constexpr bool has_ostream_op_v
 
template<typename Container , typename Value >
constexpr bool has_push_back_v
 
template<typename JsonMember >
constexpr bool has_switcher_v
 
template<typename T >
constexpr bool has_unnamed_default_type_mapping_v
 
template<typename T >
constexpr bool is_a_json_tagged_variant_v
 
template<typename T >
constexpr bool is_a_json_type_v = is_a_json_type<T>::value
 
template<typename Allocator >
constexpr bool is_allocator_v
 
template<typename T >
constexpr bool is_an_ordered_member_v
 
template<typename AssociativeContainer >
constexpr bool is_associative_container_v
 
template<typename T >
constexpr bool is_container_opted_into_json_iostreams_v
 
template<typename Container >
constexpr bool is_container_v = is_container<Container>::value
 
constexpr auto is_digit
 
template<typename ParsePolicy >
constexpr bool is_guaranteed_rvo_v
 
template<typename JsonType >
constexpr bool is_json_class_map_v
 
template<typename T >
constexpr bool is_json_map_alias_v
 
template<typename JsonType >
static constexpr bool is_json_nullable_v
 
template<typename String >
constexpr bool is_mutable_string
 
template<typename String >
constexpr bool is_mutable_string_v
 
template<typename JsonMember >
constexpr bool is_no_name_v = is_no_name<JsonMember>::value
 
template<JsonNullable ClassNullability, JsonNullable DependentNullability>
constexpr bool is_nullability_compatable_v
 
template<JsonNullable nullable>
constexpr bool is_nullable_json_value_v
 
template<typename T >
constexpr bool is_nullable_type
 
template<typename T >
constexpr bool is_opted_into_json_iostreams_v
 
template<typename Option >
constexpr bool is_option_flag = json_option_bits_width<Option> > 0
 
template<typename T >
constexpr bool is_readable_v
 
template<typename String >
constexpr bool is_ref_string
 
template<typename String >
constexpr bool is_rvalue_string = std::is_rvalue_reference_v<String>
 
template<typename String >
constexpr bool is_string_v = is_string<String>::value
 
template<typename T >
constexpr bool is_string_view_like_v
 
template<typename T >
constexpr bool is_string_view_like_v< basic_json_value< T > > = false
 
template<typename T >
constexpr bool is_submember_tagged_variant_v
 
template<typename T >
constexpr bool is_tuple_v = is_tuple<T>::value
 
template<typename Optional >
constexpr bool is_valid_optional_v
 
template<typename T , typename Default >
constexpr auto json_class_constructor
 
template<json_options_t CurrentOptions, auto option, auto... options>
constexpr json_options_t json_custom_opts_set
 
template<typename >
constexpr unsigned json_option_bits_width = 0
 
template<>
constexpr unsigned json_option_bits_width< AllowEscapeCharacter >
 
template<>
constexpr unsigned json_option_bits_width< AllowEscapedNames > = 1
 
template<>
constexpr unsigned json_option_bits_width< CheckedParseMode > = 1
 
template<>
constexpr unsigned json_option_bits_width< EightBitModes > = 1
 
template<>
constexpr unsigned json_option_bits_width< EmptyStringNull > = 1
 
template<>
constexpr unsigned json_option_bits_width< ExcludeSpecialEscapes >
 
template<>
constexpr unsigned json_option_bits_width< ExecModeTypes > = 2
 
template<>
constexpr unsigned json_option_bits_width< ForceFullNameCheck > = 1
 
template<>
constexpr unsigned json_option_bits_width< IEEE754Precise > = 1
 
template<>
constexpr unsigned json_option_bits_width< JsonCustomTypes > = 2
 
template<>
constexpr unsigned json_option_bits_width< JsonNullable > = 2
 
template<>
constexpr unsigned json_option_bits_width< JsonRangeCheck > = 1
 
template<>
constexpr unsigned json_option_bits_width< LiteralAsStringOpt > = 2
 
template<>
constexpr unsigned json_option_bits_width< MinifiedDocument > = 1
 
template<>
constexpr unsigned json_option_bits_width< MustVerifyEndOfDataIsValid > = 1
 
template<>
constexpr unsigned json_option_bits_width< PolicyCommentTypes > = 2
 
template<>
constexpr unsigned json_option_bits_width< TemporarilyMutateBuffer > = 1
 
template<>
constexpr unsigned json_option_bits_width< UseExactMappingsByDefault > = 1
 
template<>
constexpr unsigned json_option_bits_width< ZeroTerminatedString >
 
template<json_options_t CurrentOptions, auto option, auto... options>
constexpr json_options_t number_opts_set
 
template<typename T >
constexpr JsonParseTypes number_parse_type_impl_v
 
template<typename T >
constexpr JsonParseTypes number_parse_type_v = number_parse_type_test<T>( )
 
template<typename >
constexpr std::size_t parse_space_needed_v = 1U
 
template<>
constexpr std::size_t parse_space_needed_v< simd_exec_tag > = 16U
 
template<typename Policy >
constexpr unsigned policy_bits_start
 
template<json_options_t CurrentOptions, auto option, auto... options>
constexpr json_options_t string_opts_set
 
template<json_options_t CurrentOptions, auto option, auto... options>
constexpr json_options_t string_raw_opts_set
 
template<json_options_t CurrentOptions, auto option, auto... options>
constexpr json_options_t tuple_opts_set
 

Typedef Documentation

◆ apply_mutable_policy

template<typename ParsePolicy , typename String , auto OptionMutable, auto OptionImmutable>
using daw::json::DAW_JSON_VER::json_details::apply_mutable_policy = typedef std::conditional_t< ParsePolicy::allow_temporarily_mutating_buffer, std::conditional_t<is_mutable_string_v<String>, apply_policy_option_t<ParsePolicy, OptionMutable>, apply_policy_option_t<ParsePolicy, OptionImmutable> >, std::conditional_t< (is_rvalue_string<String> and is_mutable_string_v<String>), apply_policy_option_t<ParsePolicy, OptionMutable>, apply_policy_option_t<ParsePolicy, OptionImmutable> >>

◆ apply_policy_option_t

template<typename ParsePolicy , auto Option>
using daw::json::DAW_JSON_VER::json_details::apply_policy_option_t = typedef typename ParsePolicy::template SetPolicyOptions<Option>

◆ apply_zstring_policy_option_t

template<typename ParsePolicy , typename String , auto Option>
using daw::json::DAW_JSON_VER::json_details::apply_zstring_policy_option_t = typedef std::conditional_t< is_zero_terminated_string_v<daw::remove_cvref_t<String> >, apply_policy_option_t<ParsePolicy, Option>, ParsePolicy>

◆ base_int_type_impl

template<typename T >
using daw::json::DAW_JSON_VER::json_details::base_int_type_impl = typedef std::underlying_type<T>

◆ base_int_type_t

template<typename T >
using daw::json::DAW_JSON_VER::json_details::base_int_type_t = typedef typename std::conditional_t<std::is_enum_v<T>, base_int_type_impl<T>, daw::traits::identity<T> >::type

◆ can_deref

template<typename T >
using daw::json::DAW_JSON_VER::json_details::can_deref = typedef typename std::bool_constant<daw::is_detected_v<dereffed_type_impl, T> >

◆ cant_deref

template<typename T >
using daw::json::DAW_JSON_VER::json_details::cant_deref = typedef daw::not_trait<can_deref<T> >

◆ construction_result

template<bool Nullable, typename Constructor , typename... Args>
using daw::json::DAW_JSON_VER::json_details::construction_result = typedef std::conditional_t< Nullable, std::conditional_t< std::is_invocable_v<Constructor, Args...>, std::conditional_t< std::is_invocable_v<Constructor>, std::invoke_result<Constructor>, traits::identity<nullable_constructor_cannot_be_invoked<Constructor> > >, traits::identity<nullable_constructor_cannot_be_invoked<Constructor, Args...> > >, std::conditional_t< std::is_invocable_v<Constructor, Args...>, std::invoke_result<Constructor, Args...>, traits::identity<constructor_cannot_be_invoked<Constructor, Args...> > > >

◆ copy_name_when

template<typename JsonMember , JSONNAMETYPE NewName, bool Cond>
using daw::json::DAW_JSON_VER::json_details::copy_name_when = typedef std::conditional_t< Cond, typename JsonMember::template with_name<NewName>, JsonMember>

◆ copy_name_when_noname

template<typename JsonMember , JSONNAMETYPE NewName>
using daw::json::DAW_JSON_VER::json_details::copy_name_when_noname = typedef copy_name_when<JsonMember, NewName, JsonMember::name == no_name>

◆ dependent_member_t

template<typename JsonMember >
using daw::json::DAW_JSON_VER::json_details::dependent_member_t = typedef typename JsonMember::dependent_member

◆ deref_t

template<typename T >
using daw::json::DAW_JSON_VER::json_details::deref_t = typedef daw::remove_cvref_t<decltype( deref_detect( std::declval<T>( ) ) )>

◆ dereffed_type

template<typename T >
using daw::json::DAW_JSON_VER::json_details::dereffed_type = typedef typename daw::detected_or<T, dereffed_type_impl, T>::type

◆ dereffed_type_impl

template<typename T >
using daw::json::DAW_JSON_VER::json_details::dereffed_type_impl = typedef daw::remove_cvref_t<decltype( *( std::declval<T &>( ) ) )>

◆ detect_insert_end

template<typename Container , typename Value >
using daw::json::DAW_JSON_VER::json_details::detect_insert_end = typedef decltype( std::declval<Container &>( ).insert( std::end( std::declval<Container &>( ) ), std::declval<Value>( ) ) )

◆ detect_push_back

template<typename Container , typename Value >
using daw::json::DAW_JSON_VER::json_details::detect_push_back = typedef decltype( std::declval<Container &>( ).push_back( std::declval<Value>( ) ) )

◆ detected_underlying_nullable_type

template<typename T >
using daw::json::DAW_JSON_VER::json_details::detected_underlying_nullable_type = typedef std::remove_reference_t<daw::detected_t<underlying_nullable_type, T> >

◆ determine_variant_element_types

template<JsonNullable Nullable, typename Variant >
using daw::json::DAW_JSON_VER::json_details::determine_variant_element_types = typedef std::conditional_t< not is_nullable_json_value_v<Nullable> or not is_nullable_type<Variant>, std::remove_reference_t<decltype( get_variant_type_list( std::declval<Variant const *>( ) ) )>, std::conditional_t< is_nullable_type<Variant>, std::remove_reference_t<decltype( get_variant_type_list( std::declval< detected_underlying_nullable_type<Variant> const *>( ) ) )>, cannot_deduce_variant_element_types<Nullable, Variant> >>

◆ element_type_t

template<typename T >
using daw::json::DAW_JSON_VER::json_details::element_type_t = typedef typename T::element_type

◆ ensure_mapped_t

template<typename T >
using daw::json::DAW_JSON_VER::json_details::ensure_mapped_t = typedef typename ensure_mapped<T>::type

◆ force_aggregate_construction_test

◆ force_aggregate_construction_test2

template<typename T >
using daw::json::DAW_JSON_VER::json_details::force_aggregate_construction_test2 = typedef decltype( T::force_aggregate_construction )

◆ from_json_result_t

template<typename JsonMember >
using daw::json::DAW_JSON_VER::json_details::from_json_result_t = typedef json_result<json_deduced_type<JsonMember> >

◆ from_string_test

template<typename T >
using daw::json::DAW_JSON_VER::json_details::from_string_test = typedef decltype( from_string( std::declval<daw::tag_t<T> >( ), std::declval<std::string_view>( ) ) )

◆ has_allocate_test

template<typename Allocator >
using daw::json::DAW_JSON_VER::json_details::has_allocate_test = typedef decltype( std::declval<Allocator &>( ).allocate( size_t{ 1 } ) )

◆ has_deallocate_test

template<typename Allocator >
using daw::json::DAW_JSON_VER::json_details::has_deallocate_test = typedef decltype( std::declval<Allocator &>( ).deallocate( static_cast<void *>( nullptr ), size_t{ 1 } ) )

◆ has_element_type

template<typename T >
using daw::json::DAW_JSON_VER::json_details::has_element_type = typedef daw::is_detected<element_type_t, T>

◆ has_empty_member_test

template<typename T >
using daw::json::DAW_JSON_VER::json_details::has_empty_member_test = typedef decltype( std::declval<T>( ).empty( ) )

◆ has_exact_mapping_trait_in_class_map

template<typename T >
using daw::json::DAW_JSON_VER::json_details::has_exact_mapping_trait_in_class_map = typedef typename json_data_contract<T>::exact_class_mapping

◆ has_ignore_unknown_members_trait_in_class_map

◆ has_json_data_constract_constructor_test

template<typename T >
using daw::json::DAW_JSON_VER::json_details::has_json_data_constract_constructor_test = typedef decltype( decltype( std::declval< json_data_contract_trait_t<T> > )::constructor )

◆ has_json_data_contract_trait

◆ has_json_deduced_type

template<typename T >
using daw::json::DAW_JSON_VER::json_details::has_json_deduced_type = typedef daw::not_trait< std::is_same<json_deduced_type<T>, missing_json_data_contract_for<T> >>

◆ has_json_link_quick_map

template<typename T >
using daw::json::DAW_JSON_VER::json_details::has_json_link_quick_map = typedef decltype( json_link_quick_map<T>( ) )

◆ has_lshift_test

template<typename T , typename U >
using daw::json::DAW_JSON_VER::json_details::has_lshift_test = typedef decltype( operator<<( std::declval<T &>( ), std::declval<U const &>( ) ) )

◆ has_op_bool_test

template<typename T >
using daw::json::DAW_JSON_VER::json_details::has_op_bool_test = typedef decltype( static_cast<bool>( std::declval<T>( ) ) )

◆ has_op_star_test

template<typename T >
using daw::json::DAW_JSON_VER::json_details::has_op_star_test = typedef decltype( *std::declval<T>( ) )

◆ has_rshift_test

template<typename T , typename U >
using daw::json::DAW_JSON_VER::json_details::has_rshift_test = typedef decltype( operator> >( std::declval<T &>( ), std::declval<U const &>( ) ) )

◆ is_a_json_tagged_variant

template<typename T >
using daw::json::DAW_JSON_VER::json_details::is_a_json_tagged_variant = typedef daw::is_detected<is_a_json_tagged_variant_test, T>

◆ is_a_json_tagged_variant_test

template<typename T >
using daw::json::DAW_JSON_VER::json_details::is_a_json_tagged_variant_test = typedef typename T::i_am_a_json_tagged_variant

◆ is_a_json_type

template<typename T >
using daw::json::DAW_JSON_VER::json_details::is_a_json_type = typedef std::bool_constant<daw::is_detected_v<json_type_t, T> >

◆ is_associative_container

template<typename AssociativeContainer >
using daw::json::DAW_JSON_VER::json_details::is_associative_container = typedef std::conjunction< is_container<AssociativeContainer>, daw::is_detected<container_detect::container_key_type, AssociativeContainer>, daw::is_detected<container_detect::container_mapped_type, AssociativeContainer> >

◆ is_container

template<typename T >
using daw::json::DAW_JSON_VER::json_details::is_container = typedef std::conjunction< daw::is_detected<container_detect::container_value_type, T>, daw::is_detected<container_detect::container_begin_type, T>, daw::is_detected<container_detect::container_end_type, T> >

◆ is_container_opted_into_json_iostreams

template<typename Container >
using daw::json::DAW_JSON_VER::json_details::is_container_opted_into_json_iostreams = typedef is_opted_into_json_iostreams<typename Container::value_type>

◆ is_json_class_map_test

template<typename JsonType >
using daw::json::DAW_JSON_VER::json_details::is_json_class_map_test = typedef typename JsonType::json_member

◆ is_json_nullable

template<typename JsonType >
using daw::json::DAW_JSON_VER::json_details::is_json_nullable = typedef std::bool_constant<JsonType::expected_type == JsonParseTypes::Null>

◆ is_no_name

template<typename JsonMember >
using daw::json::DAW_JSON_VER::json_details::is_no_name = typedef std::bool_constant<JsonMember::name == no_name>

◆ is_nullable_json_value

template<JsonNullable nullable>
using daw::json::DAW_JSON_VER::json_details::is_nullable_json_value = typedef std::bool_constant<nullable != JsonNullable::MustExist>

◆ is_opted_into_json_iostreams

template<typename T >
using daw::json::DAW_JSON_VER::json_details::is_opted_into_json_iostreams = typedef typename json_data_contract<T>::opt_into_iostreams

◆ is_string

template<typename String >
using daw::json::DAW_JSON_VER::json_details::is_string = typedef std::conjunction<is_container<String>, container_detect::is_value_type_char<String> >

◆ is_string_view_like

template<typename T >
using daw::json::DAW_JSON_VER::json_details::is_string_view_like = typedef std::conjunction< daw::is_detected<is_string_like_impl::has_data_test, T>, daw::is_detected<is_string_like_impl::has_size_test, T> >

◆ is_submember_tagged_variant_t

template<typename T >
using daw::json::DAW_JSON_VER::json_details::is_submember_tagged_variant_t = typedef typename json_data_contract<T>::type::i_am_a_submember_tagged_variant

◆ is_tuple

template<typename T >
using daw::json::DAW_JSON_VER::json_details::is_tuple = typedef daw::is_detected<json_details::tuple_test, T>

Detect if T follows the tuple protocol.

Template Parameters
T

◆ is_vector

template<typename T >
using daw::json::DAW_JSON_VER::json_details::is_vector = typedef std::bool_constant<vector_detect::vector_test<T>::value>

◆ json_base_type

template<typename JsonMember >
using daw::json::DAW_JSON_VER::json_details::json_base_type = typedef typename JsonMember::base_type

◆ json_class_constructor_t

template<typename T , typename Default >
using daw::json::DAW_JSON_VER::json_details::json_class_constructor_t = typedef typename std::conditional_t< daw::is_detected<json_data_contract_constructor_t, T>::value, json_data_contract_constructor<T>, daw::traits::identity<Default> >::type

◆ json_class_parse_result_impl

template<typename Constructor , typename... Members>
using daw::json::DAW_JSON_VER::json_details::json_class_parse_result_impl = typedef daw::detected_t<json_class_parse_result_impl2, Constructor, Members...>

◆ json_class_parse_result_impl2

template<typename Constructor , typename... Members>
using daw::json::DAW_JSON_VER::json_details::json_class_parse_result_impl2 = typedef decltype( Constructor{ }( std::declval<typename Members::parse_to_t &&>( )... ) )

◆ json_class_parse_result_t

template<typename Constructor , typename... Members>
using daw::json::DAW_JSON_VER::json_details::json_class_parse_result_t = typedef daw::remove_cvref_t< json_class_parse_result_impl<Constructor, Members...> >

◆ json_data_contract_constructor

◆ json_data_contract_constructor_t

◆ json_deduced_type

◆ json_link_quick_map_t

template<typename T >
using daw::json::DAW_JSON_VER::json_details::json_link_quick_map_t = typedef typename decltype( json_link_quick_map<T>( ) )::mapped_type

◆ json_map_alias_test

template<typename T >
using daw::json::DAW_JSON_VER::json_details::json_map_alias_test = typedef typename json_data_contract_trait_t<T>::i_am_a_json_map_alias

◆ json_member_constructor_t

template<typename T >
using daw::json::DAW_JSON_VER::json_details::json_member_constructor_t = typedef typename T::constructor_t

◆ json_member_parse_to_t

template<typename T >
using daw::json::DAW_JSON_VER::json_details::json_member_parse_to_t = typedef typename T::parse_to_t

◆ json_options_t

◆ json_parser_to_json_data_t

template<typename T >
using daw::json::DAW_JSON_VER::json_details::json_parser_to_json_data_t = typedef decltype( json_data_contract<T>::to_json_data( std::declval<T &>( ) ) )

◆ json_result

template<typename JsonMember >
using daw::json::DAW_JSON_VER::json_details::json_result = typedef typename JsonMember::parse_to_t

◆ json_type_t

template<typename T >
using daw::json::DAW_JSON_VER::json_details::json_type_t = typedef typename T::i_am_a_json_type

◆ max_unsigned_t

template<JsonRangeCheck RangeCheck, typename Unsigned , typename MaxArithUnsigned >
using daw::json::DAW_JSON_VER::json_details::max_unsigned_t = typedef std::conditional_t< std::disjunction<daw::is_integral<Unsigned>, std::is_enum<Unsigned> >::value, std::conditional_t<( sizeof( Unsigned ) > sizeof( MaxArithUnsigned ) ), Unsigned, MaxArithUnsigned>, Unsigned>

◆ ordered_member_subtype_t

template<typename T >
using daw::json::DAW_JSON_VER::json_details::ordered_member_subtype_t = typedef typename daw::detected_or_t<T, ordered_member_subtype_test, T>

◆ ordered_member_subtype_test

template<typename T >
using daw::json::DAW_JSON_VER::json_details::ordered_member_subtype_test = typedef typename T::json_member

◆ ordered_member_t

template<typename T >
using daw::json::DAW_JSON_VER::json_details::ordered_member_t = typedef typename T::i_am_an_ordered_member

◆ ordered_member_wrapper

template<typename JsonMember >
using daw::json::DAW_JSON_VER::json_details::ordered_member_wrapper = typedef std::conditional_t<is_an_ordered_member_v<JsonMember>, JsonMember, json_deduced_type<JsonMember> >

◆ policy_list

◆ switcher_t

template<typename JsonMember >
using daw::json::DAW_JSON_VER::json_details::switcher_t = typedef typename JsonMember::switcher

◆ tuple_test

template<typename T >
using daw::json::DAW_JSON_VER::json_details::tuple_test = typedef typename tuple_elements_pack<T>::type

◆ underlying_nullable_type

template<typename T >
using daw::json::DAW_JSON_VER::json_details::underlying_nullable_type = typedef decltype( *std::declval<T>( ) )

◆ unwrap_type

template<typename T , JsonNullable Nullable>
using daw::json::DAW_JSON_VER::json_details::unwrap_type = typedef typename std::conditional_t<is_nullable_json_value_v<Nullable>, dereffed_type<T>, T>

◆ without_name

template<typename JsonMember >
using daw::json::DAW_JSON_VER::json_details::without_name = typedef typename JsonMember::without_name

Enumeration Type Documentation

◆ AllMembersMustExist

Enumerator
yes 
no 

Function Documentation

◆ as_copy()

template<typename T >
constexpr daw::remove_cvref_t<T> daw::json::DAW_JSON_VER::json_details::as_copy ( T &&  value)
constexpr

◆ byte_from_nibbles()

template<bool is_unchecked_input>
constexpr UInt16 daw::json::DAW_JSON_VER::json_details::byte_from_nibbles ( char const *&  first)
inlineconstexpr

◆ construct_value()

template<typename Value , typename Constructor , typename ParseState , typename... Args>
static constexpr DAW_ATTRIB_FLATINLINE auto daw::json::DAW_JSON_VER::json_details::construct_value ( template_params< Value, Constructor >  ,
ParseState &  parse_state,
Args &&...  args 
)
inlinestaticconstexpr

◆ construct_value_tp()

template<typename Value , typename Constructor , typename ParseState , typename... Args>
static constexpr DAW_ATTRIB_FLATINLINE auto daw::json::DAW_JSON_VER::json_details::construct_value_tp ( ParseState &  parse_state,
fwd_pack< Args... > &&  tp_args 
)
inlinestaticconstexpr

◆ count_4digits()

template<typename Predicate >
constexpr DAW_ATTRIB_FLATINLINE std::int32_t daw::json::DAW_JSON_VER::json_details::count_4digits ( char const *  first,
Predicate  pred 
)
inlineconstexpr

◆ count_8digits()

template<typename Predicate >
constexpr DAW_ATTRIB_FLATINLINE std::int32_t daw::json::DAW_JSON_VER::json_details::count_8digits ( char const *  first,
Predicate  pred 
)
inlineconstexpr

◆ count_digits()

template<typename CharT >
constexpr DAW_ATTRIB_FLATTEN CharT* daw::json::DAW_JSON_VER::json_details::count_digits ( CharT *  first,
CharT *  last 
)
inlineconstexpr

◆ decode_utf16() [1/2]

template<typename ParseState , typename Appender >
static constexpr void daw::json::DAW_JSON_VER::json_details::decode_utf16 ( ParseState &  parse_state,
Appender &  app 
)
staticconstexpr

◆ decode_utf16() [2/2]

template<typename ParseState >
static constexpr char* daw::json::DAW_JSON_VER::json_details::decode_utf16 ( ParseState &  parse_state,
char *  it 
)
staticconstexpr

◆ dependent_member_to_json_str() [1/2]

template<std::size_t , typename JsonMember , typename , typename OutputIterator , typename TpArgs , typename Value , typename VisitedMembers , std::enable_if_t< not has_dependent_member_v< JsonMember >, std::nullptr_t > = nullptr>
constexpr void daw::json::DAW_JSON_VER::json_details::dependent_member_to_json_str ( bool &  ,
OutputIterator const &  ,
TpArgs const &  ,
Value const &  ,
VisitedMembers const &   
)
inlineconstexpr

◆ dependent_member_to_json_str() [2/2]

template<std::size_t pos, typename JsonMember , typename NamePack , typename OutputIterator , typename TpArgs , typename Value , typename VisitedMembers , std::enable_if_t< has_dependent_member_v< JsonMember >, std::nullptr_t > = nullptr>
constexpr void daw::json::DAW_JSON_VER::json_details::dependent_member_to_json_str ( bool &  is_first,
OutputIterator  it,
TpArgs const &  args,
Value const &  v,
VisitedMembers &  visited_members 
)
constexpr

◆ deref_detect() [1/2]

constexpr void daw::json::DAW_JSON_VER::json_details::deref_detect (   ...)
inlineconstexpr

◆ deref_detect() [2/2]

template<typename T >
constexpr auto daw::json::DAW_JSON_VER::json_details::deref_detect ( T &&  value) -> decltype(*value)
constexpr

◆ do_hashes_collide()

template<typename... MemberNames>
constexpr bool daw::json::DAW_JSON_VER::json_details::do_hashes_collide ( )
inlineconstexpr

◆ find_class_member()

template<std::size_t pos, AllMembersMustExist must_exist, bool from_start = false, std::size_t N, typename ParseState , bool B, typename CharT >
constexpr std::pair<ParseState, bool> daw::json::DAW_JSON_VER::json_details::find_class_member ( ParseState &  parse_state,
locations_info_t< N, CharT, B > &  locations,
bool  is_nullable,
daw::string_view  member_name 
)
inlineconstexpr

◆ find_json_element()

template<JsonBaseParseTypes PT>
constexpr std::size_t daw::json::DAW_JSON_VER::json_details::find_json_element ( std::initializer_list< JsonBaseParseTypes pts)
constexpr

◆ find_lsb_set()

std::ptrdiff_t daw::json::DAW_JSON_VER::json_details::find_lsb_set ( runtime_exec_tag  ,
UInt32  value 
)
inline

◆ find_names_in_pack()

template<typename Needle , typename... Haystack>
constexpr std::size_t daw::json::DAW_JSON_VER::json_details::find_names_in_pack ( daw::fwd_pack< Haystack... >  )
constexpr

◆ find_range() [1/2]

template<typename ParsePolicy , typename String >
constexpr std::pair<bool, ParsePolicy> daw::json::DAW_JSON_VER::json_details::find_range ( String &&  str,
daw::string_view  start_path 
)
constexpr

◆ find_range() [2/2]

template<typename ParsePolicy , typename String , typename Allocator >
constexpr auto daw::json::DAW_JSON_VER::json_details::find_range ( String &&  str,
daw::string_view  start_path,
Allocator &  alloc 
)
constexpr

◆ find_range2()

template<typename ParseState >
constexpr bool daw::json::DAW_JSON_VER::json_details::find_range2 ( ParseState &  parse_state,
daw::string_view  path 
)
constexpr

◆ get_bits_for() [1/2]

template<typename Policy , typename Result = Policy>
constexpr Result daw::json::DAW_JSON_VER::json_details::get_bits_for ( json_options_t  value)
constexpr

◆ get_bits_for() [2/2]

template<typename Option , typename Result = Option, typename... OptionList>
constexpr Result daw::json::DAW_JSON_VER::json_details::get_bits_for ( JsonOptionList< OptionList... >  ,
json_options_t  value 
)
constexpr

◆ get_variant_type_list() [1/2]

template<typename... Ts>
constexpr std::conditional_t< std::conjunction<has_json_deduced_type<Ts>...>::value, json_variant_type_list<json_deduced_type<Ts>...>, missing_default_type_mapping<json_deduced_type<Ts>...> > daw::json::DAW_JSON_VER::json_details::get_variant_type_list ( std::variant< Ts... > const *  )
constexpr

◆ get_variant_type_list() [2/2]

template<typename T >
constexpr unknown_variant_type<T> daw::json::DAW_JSON_VER::json_details::get_variant_type_list ( T const *  )
constexpr

◆ handle_on_array_end()

template<typename Handler >
constexpr handler_result_holder daw::json::DAW_JSON_VER::json_details::handle_on_array_end ( Handler &&  handler)
inlineconstexpr

◆ handle_on_array_start()

template<typename Handler , typename ParseState >
constexpr handler_result_holder daw::json::DAW_JSON_VER::json_details::handle_on_array_start ( Handler &&  handler,
basic_json_value< ParseState >  jv 
)
inlineconstexpr

◆ handle_on_bool()

template<typename Handler , typename ParseState >
constexpr handler_result_holder daw::json::DAW_JSON_VER::json_details::handle_on_bool ( Handler &&  handler,
basic_json_value< ParseState >  jv 
)
inlineconstexpr

◆ handle_on_class_end()

template<typename Handler >
constexpr handler_result_holder daw::json::DAW_JSON_VER::json_details::handle_on_class_end ( Handler &&  handler)
inlineconstexpr

◆ handle_on_class_start()

template<typename Handler , typename ParseState >
constexpr handler_result_holder daw::json::DAW_JSON_VER::json_details::handle_on_class_start ( Handler &&  handler,
basic_json_value< ParseState >  jv 
)
inlineconstexpr

◆ handle_on_error()

template<typename Handler , typename ParseState >
constexpr handler_result_holder daw::json::DAW_JSON_VER::json_details::handle_on_error ( Handler &&  handler,
basic_json_value< ParseState >  jv 
)
inlineconstexpr

◆ handle_on_null()

template<typename Handler , typename ParseState >
constexpr handler_result_holder daw::json::DAW_JSON_VER::json_details::handle_on_null ( Handler &&  handler,
basic_json_value< ParseState > &  jv 
)
inlineconstexpr

◆ handle_on_number()

template<typename Handler , typename ParseState >
constexpr handler_result_holder daw::json::DAW_JSON_VER::json_details::handle_on_number ( Handler &&  handler,
basic_json_value< ParseState > &  jv 
)
inlineconstexpr

◆ handle_on_string()

template<typename Handler , typename ParseState >
constexpr handler_result_holder daw::json::DAW_JSON_VER::json_details::handle_on_string ( Handler &&  handler,
basic_json_value< ParseState > &  jv 
)
inlineconstexpr

◆ handle_on_value()

template<typename Handler , typename ParseState >
constexpr handler_result_holder daw::json::DAW_JSON_VER::json_details::handle_on_value ( Handler &&  handler,
basic_json_pair< ParseState >  p 
)
inlineconstexpr

◆ has_value()

template<typename T >
constexpr auto daw::json::DAW_JSON_VER::json_details::has_value ( T const &  v) -> std::enable_if_t<is_readable_v<T>, bool>
constexpr

◆ is_escaped()

constexpr DAW_ATTRIB_FLATINLINE bool daw::json::DAW_JSON_VER::json_details::is_escaped ( char const *  ptr,
char const *  min_ptr 
)
inlineconstexpr

◆ is_made_of_eight_digits_cx()

static constexpr bool daw::json::DAW_JSON_VER::json_details::is_made_of_eight_digits_cx ( const char *  ptr)
inlinestaticconstexpr

◆ is_null() [1/2]

template<typename T >
constexpr bool daw::json::DAW_JSON_VER::json_details::is_null ( std::optional< T > const &  v)
inlineconstexpr

◆ is_null() [2/2]

template<typename T >
constexpr bool daw::json::DAW_JSON_VER::json_details::is_null ( T const &  )
inlineconstexpr

◆ json_get_key()

template<typename Key , typename Value >
constexpr Key const& daw::json::DAW_JSON_VER::json_details::json_get_key ( std::pair< Key, Value > const &  kv)
inlineconstexpr

◆ json_get_value()

template<typename Key , typename Value >
constexpr Value const& daw::json::DAW_JSON_VER::json_details::json_get_value ( std::pair< Key, Value > const &  kv)
inlineconstexpr

◆ json_link_quick_map()

template<typename T >
constexpr auto daw::json::DAW_JSON_VER::json_details::json_link_quick_map ( )
inlineconstexpr

◆ json_option()

template<typename... OptionList, typename... Options>
constexpr json_options_t daw::json::DAW_JSON_VER::json_details::json_option ( JsonOptionList< OptionList... >  ,
Options...  options 
)
constexpr

◆ json_path_compare()

constexpr bool daw::json::DAW_JSON_VER::json_details::json_path_compare ( daw::string_view  json_path_item,
daw::string_view  member_name 
)
constexpr

◆ make_locations_info()

template<typename ParseState , typename... JsonMembers>
constexpr DAW_ATTRIB_FLATINLINE auto daw::json::DAW_JSON_VER::json_details::make_locations_info ( )
inlineconstexpr

◆ mem_move_to_next_of()

template<bool is_unchecked_input, char... keys, typename CharT >
DAW_ATTRIB_FLATINLINE CharT* daw::json::DAW_JSON_VER::json_details::mem_move_to_next_of ( runtime_exec_tag  ,
CharT *  first,
CharT *  last 
)
inline

◆ mem_skip_string()

template<bool is_unchecked_input, typename ExecTag , typename CharT , std::enable_if_t< std::is_base_of< runtime_exec_tag, ExecTag >::value, std::nullptr_t > = nullptr>
DAW_ATTRIB_FLATINLINE CharT* daw::json::DAW_JSON_VER::json_details::mem_skip_string ( ExecTag const &  tag,
CharT *  first,
CharT *const  last 
)
inline

◆ mem_skip_until_end_of_string() [1/2]

template<bool is_unchecked_input, typename ExecTag , typename CharT , std::enable_if_t< std::is_base_of< runtime_exec_tag, ExecTag >::value, std::nullptr_t > = nullptr>
DAW_ATTRIB_FLATINLINE CharT* daw::json::DAW_JSON_VER::json_details::mem_skip_until_end_of_string ( ExecTag const &  tag,
CharT *  first,
CharT *const  last 
)
inline

◆ mem_skip_until_end_of_string() [2/2]

template<bool is_unchecked_input, typename CharT >
DAW_ATTRIB_FLATINLINE CharT* daw::json::DAW_JSON_VER::json_details::mem_skip_until_end_of_string ( runtime_exec_tag  tag,
CharT *  first,
CharT *const  last,
std::ptrdiff_t &  first_escape 
)
inline

◆ member_to_string()

template<typename JsonMember , typename OutputIterator , typename T >
constexpr OutputIterator daw::json::DAW_JSON_VER::json_details::member_to_string ( template_param< JsonMember >  ,
OutputIterator  it,
T const &  value 
)
inlineconstexpr

◆ needs_slow_path()

template<typename ParseState >
constexpr bool daw::json::DAW_JSON_VER::json_details::needs_slow_path ( ParseState const &  parse_state)
inlineconstexpr

◆ number_parse_type_test()

template<typename T >
constexpr auto daw::json::DAW_JSON_VER::json_details::number_parse_type_test ( ) -> std::enable_if_t<std::is_enum<T>::value, JsonParseTypes>
constexpr

◆ output_hex()

template<typename OutputIterator >
constexpr OutputIterator daw::json::DAW_JSON_VER::json_details::output_hex ( std::uint16_t  c,
OutputIterator  it 
)
constexpr

◆ parse_16_digits()

constexpr UInt64 daw::json::DAW_JSON_VER::json_details::parse_16_digits ( const char *const  str)
inlineconstexpr

◆ parse_8_digits()

constexpr UInt64 daw::json::DAW_JSON_VER::json_details::parse_8_digits ( const char *const  str)
inlineconstexpr

◆ parse_class_member()

template<std::size_t member_position, typename JsonMember , AllMembersMustExist must_exist, bool NeedsClassPositions, typename ParseState , std::size_t N, typename CharT , bool B>
constexpr json_result<JsonMember> daw::json::DAW_JSON_VER::json_details::parse_class_member ( ParseState &  parse_state,
locations_info_t< N, CharT, B > &  locations 
)
constexpr

◆ parse_digit()

static constexpr DAW_ATTRIB_FLATINLINE unsigned daw::json::DAW_JSON_VER::json_details::parse_digit ( char  c)
inlinestaticconstexpr

◆ parse_digits_until_last()

template<bool skip_end_check, typename Unsigned >
constexpr DAW_ATTRIB_FLATINLINE void daw::json::DAW_JSON_VER::json_details::parse_digits_until_last ( char const *  first,
char const *const  last,
Unsigned &  v 
)
inlineconstexpr

◆ parse_digits_while_number()

template<bool skip_end_check, typename Unsigned , typename CharT >
constexpr DAW_ATTRIB_FLATINLINE CharT* daw::json::DAW_JSON_VER::json_details::parse_digits_while_number ( CharT *  first,
CharT *const  last,
Unsigned &  v 
)
inlineconstexpr

◆ parse_json_class()

template<typename JsonClass , typename... JsonMembers, typename ParseState , std::size_t... Is>
constexpr json_result<JsonClass> daw::json::DAW_JSON_VER::json_details::parse_json_class ( ParseState &  parse_state,
std::index_sequence< Is... >   
)
constexpr

◆ parse_name()

template<typename ParseState >
constexpr DAW_ATTRIB_FLATTEN daw::string_view daw::json::DAW_JSON_VER::json_details::parse_name ( ParseState &  parse_state)
inlineconstexpr

◆ parse_nth_class()

template<std::size_t N, typename JsonClass , bool KnownBounds, typename... JsonClasses, typename ParseState >
constexpr DAW_ATTRIB_FLATTEN json_result<JsonClass> daw::json::DAW_JSON_VER::json_details::parse_nth_class ( std::size_t  idx,
ParseState &  parse_state 
)
constexpr

◆ parse_ordered_class_member()

template<typename JsonMember , typename ParseState >
constexpr json_result<JsonMember> daw::json::DAW_JSON_VER::json_details::parse_ordered_class_member ( template_param< JsonMember >  ,
std::size_t &  member_index,
ParseState &  parse_state 
)
constexpr

◆ parse_ordered_json_class()

template<typename JsonClass , typename... JsonMembers, typename ParseState >
static constexpr json_result<JsonClass> daw::json::DAW_JSON_VER::json_details::parse_ordered_json_class ( template_params< JsonClass, JsonMembers... >  ,
ParseState &  parse_state 
)
staticconstexpr

◆ parse_real()

template<typename Result , bool KnownRange, typename ParseState , std::enable_if_t< KnownRange, std::nullptr_t > = nullptr>
constexpr DAW_ATTRIB_FLATINLINE Result daw::json::DAW_JSON_VER::json_details::parse_real ( ParseState &  parse_state)
inlineconstexpr

◆ parse_string_known_stdstring()

template<bool AllowHighEight, typename JsonMember , bool KnownBounds, typename ParseState >
constexpr auto daw::json::DAW_JSON_VER::json_details::parse_string_known_stdstring ( ParseState &  parse_state)
constexpr

◆ parse_tuple_value()

template<typename JsonMember , bool KnownBounds, typename ParseState , std::size_t... Is>
constexpr DAW_ATTRIB_FLATINLINE json_result<JsonMember> daw::json::DAW_JSON_VER::json_details::parse_tuple_value ( ParseState &  parse_state,
std::index_sequence< Is... >   
)
constexpr

◆ parse_value() [1/35]

template<typename JsonMember , bool KnownBounds, typename ParseState >
constexpr DAW_ATTRIB_FLATTEN json_result<JsonMember> daw::json::DAW_JSON_VER::json_details::parse_value ( ParseState &  parse_state,
ParseTag< JsonParseTypes::Array  
)
constexpr

◆ parse_value() [2/35]

template<typename JsonMember , bool KnownBounds = false, typename ParseState >
constexpr json_result<JsonMember> daw::json::DAW_JSON_VER::json_details::parse_value ( ParseState &  parse_state,
ParseTag< JsonParseTypes::Array  
)
constexpr

◆ parse_value() [3/35]

template<typename JsonMember , bool KnownBounds, typename ParseState >
constexpr DAW_ATTRIB_INLINE json_result<JsonMember> daw::json::DAW_JSON_VER::json_details::parse_value ( ParseState &  parse_state,
ParseTag< JsonParseTypes::Bool  
)
inlineconstexpr

◆ parse_value() [4/35]

template<typename JsonMember , bool KnownBounds = false, typename ParseState >
constexpr json_result<JsonMember> daw::json::DAW_JSON_VER::json_details::parse_value ( ParseState &  parse_state,
ParseTag< JsonParseTypes::Bool  
)
inlineconstexpr

◆ parse_value() [5/35]

template<typename JsonMember , bool KnownBounds, typename ParseState >
constexpr DAW_ATTRIB_FLATTEN json_result<JsonMember> daw::json::DAW_JSON_VER::json_details::parse_value ( ParseState &  parse_state,
ParseTag< JsonParseTypes::Class  
)
constexpr

◆ parse_value() [6/35]

template<typename JsonMember , bool KnownBounds = false, typename ParseState >
constexpr json_result<JsonMember> daw::json::DAW_JSON_VER::json_details::parse_value ( ParseState &  parse_state,
ParseTag< JsonParseTypes::Class  
)
constexpr

◆ parse_value() [7/35]

template<typename JsonMember , bool KnownBounds, typename ParseState >
constexpr json_result< JsonMember > daw::json::DAW_JSON_VER::json_details::parse_value ( ParseState &  parse_state,
ParseTag< JsonParseTypes::Custom  
)
constexpr

◆ parse_value() [8/35]

template<typename JsonMember , bool KnownBounds, typename ParseState >
constexpr DAW_ATTRIB_INLINE json_result<JsonMember> daw::json::DAW_JSON_VER::json_details::parse_value ( ParseState &  parse_state,
ParseTag< JsonParseTypes::Date  
)
inlineconstexpr

◆ parse_value() [9/35]

template<typename JsonMember , bool KnownBounds = false, typename ParseState >
constexpr json_result<JsonMember> daw::json::DAW_JSON_VER::json_details::parse_value ( ParseState &  parse_state,
ParseTag< JsonParseTypes::Date  
)
inlineconstexpr

◆ parse_value() [10/35]

template<typename JsonMember , bool KnownBounds, typename ParseState >
constexpr DAW_ATTRIB_FLATTEN json_result<JsonMember> daw::json::DAW_JSON_VER::json_details::parse_value ( ParseState &  parse_state,
ParseTag< JsonParseTypes::KeyValue  
)
constexpr

Parse a key_value pair encoded as a json object where the keys are the member names

Template Parameters
JsonMemberjson_key_value type
ParseStateInput range type
Parameters
parse_stateParseState of input to parse
Returns
Constructed key_value container

◆ parse_value() [11/35]

template<typename JsonMember , bool KnownBounds = false, typename ParseState >
constexpr json_result<JsonMember> daw::json::DAW_JSON_VER::json_details::parse_value ( ParseState &  parse_state,
ParseTag< JsonParseTypes::KeyValue  
)
constexpr

Parse a key_value pair encoded as a json object where the keys are the member names

Template Parameters
JsonMemberjson_key_value type
ParseStateInput range type
Parameters
parse_stateParseState of input to parse
Returns
Constructed key_value container

◆ parse_value() [12/35]

template<typename JsonMember , bool KnownBounds, typename ParseState >
constexpr DAW_ATTRIB_FLATTEN json_result<JsonMember> daw::json::DAW_JSON_VER::json_details::parse_value ( ParseState &  parse_state,
ParseTag< JsonParseTypes::KeyValueArray  
)
constexpr

Parse a key_value pair encoded as a json object where the keys are the member names

Template Parameters
JsonMemberjson_key_value type
ParseStateInput ParseState type
Parameters
parse_stateParseState of input to parse
Returns
Constructed key_value container

◆ parse_value() [13/35]

template<typename JsonMember , bool KnownBounds = false, typename ParseState >
constexpr json_result<JsonMember> daw::json::DAW_JSON_VER::json_details::parse_value ( ParseState &  parse_state,
ParseTag< JsonParseTypes::KeyValueArray  
)
constexpr

Parse a key_value pair encoded as a json object where the keys are the member names

Template Parameters
JsonMemberjson_key_value type
ParseStateInput ParseState type
Parameters
parse_stateParseState of input to parse
Returns
Constructed key_value container

◆ parse_value() [14/35]

template<typename JsonMember , bool KnownBounds, typename ParseState >
constexpr DAW_ATTRIB_INLINE json_result<JsonMember> daw::json::DAW_JSON_VER::json_details::parse_value ( ParseState &  parse_state,
ParseTag< JsonParseTypes::Null  
)
inlineconstexpr

◆ parse_value() [15/35]

template<typename JsonMember , bool KnownBounds = false, typename ParseState >
constexpr json_result<JsonMember> daw::json::DAW_JSON_VER::json_details::parse_value ( ParseState &  parse_state,
ParseTag< JsonParseTypes::Null  
)
inlineconstexpr

◆ parse_value() [16/35]

template<typename JsonMember , bool KnownBounds, typename ParseState >
constexpr DAW_ATTRIB_INLINE json_result<JsonMember> daw::json::DAW_JSON_VER::json_details::parse_value ( ParseState &  parse_state,
ParseTag< JsonParseTypes::Real  
)
inlineconstexpr

◆ parse_value() [17/35]

template<typename JsonMember , bool KnownBounds = false, typename ParseState >
constexpr json_result<JsonMember> daw::json::DAW_JSON_VER::json_details::parse_value ( ParseState &  parse_state,
ParseTag< JsonParseTypes::Real  
)
inlineconstexpr

◆ parse_value() [18/35]

template<typename JsonMember , bool KnownBounds, typename ParseState >
constexpr DAW_ATTRIB_INLINE json_result<JsonMember> daw::json::DAW_JSON_VER::json_details::parse_value ( ParseState &  parse_state,
ParseTag< JsonParseTypes::Signed  
)
inlineconstexpr

◆ parse_value() [19/35]

template<typename JsonMember , bool KnownBounds = false, typename ParseState >
constexpr json_result<JsonMember> daw::json::DAW_JSON_VER::json_details::parse_value ( ParseState &  parse_state,
ParseTag< JsonParseTypes::Signed  
)
inlineconstexpr

◆ parse_value() [20/35]

template<typename JsonMember , bool KnownBounds, typename ParseState >
constexpr DAW_ATTRIB_FLATTEN json_result<JsonMember> daw::json::DAW_JSON_VER::json_details::parse_value ( ParseState &  parse_state,
ParseTag< JsonParseTypes::SizedArray  
)
constexpr

◆ parse_value() [21/35]

template<typename JsonMember , bool KnownBounds = false, typename ParseState >
constexpr json_result<JsonMember> daw::json::DAW_JSON_VER::json_details::parse_value ( ParseState &  parse_state,
ParseTag< JsonParseTypes::SizedArray  
)
constexpr

◆ parse_value() [22/35]

template<typename JsonMember , bool KnownBounds, typename ParseState >
constexpr json_result< JsonMember > daw::json::DAW_JSON_VER::json_details::parse_value ( ParseState &  parse_state,
ParseTag< JsonParseTypes::StringEscaped  
)
constexpr

◆ parse_value() [23/35]

template<typename JsonMember , bool KnownBounds, typename ParseState >
constexpr DAW_ATTRIB_INLINE json_result<JsonMember> daw::json::DAW_JSON_VER::json_details::parse_value ( ParseState &  parse_state,
ParseTag< JsonParseTypes::StringRaw  
)
inlineconstexpr

◆ parse_value() [24/35]

template<typename JsonMember , bool KnownBounds = false, typename ParseState >
constexpr json_result<JsonMember> daw::json::DAW_JSON_VER::json_details::parse_value ( ParseState &  parse_state,
ParseTag< JsonParseTypes::StringRaw  
)
inlineconstexpr

◆ parse_value() [25/35]

template<typename JsonMember , bool KnownBounds, typename ParseState >
constexpr DAW_ATTRIB_FLATINLINE json_result<JsonMember> daw::json::DAW_JSON_VER::json_details::parse_value ( ParseState &  parse_state,
ParseTag< JsonParseTypes::Tuple  
)
constexpr

◆ parse_value() [26/35]

template<typename JsonMember , bool KnownBounds = false, typename ParseState >
constexpr json_result<JsonMember> daw::json::DAW_JSON_VER::json_details::parse_value ( ParseState &  parse_state,
ParseTag< JsonParseTypes::Tuple  
)
constexpr

◆ parse_value() [27/35]

template<typename JsonMember , bool KnownBounds, typename ParseState >
constexpr DAW_ATTRIB_FLATINLINE json_result<JsonMember> daw::json::DAW_JSON_VER::json_details::parse_value ( ParseState &  parse_state,
ParseTag< JsonParseTypes::Unknown  
)
constexpr

◆ parse_value() [28/35]

template<typename JsonMember , bool KnownBounds = false, typename ParseState >
constexpr json_result<JsonMember> daw::json::DAW_JSON_VER::json_details::parse_value ( ParseState &  parse_state,
ParseTag< JsonParseTypes::Unknown  
)
constexpr

◆ parse_value() [29/35]

template<typename JsonMember , bool KnownBounds, typename ParseState >
constexpr DAW_ATTRIB_INLINE json_result<JsonMember> daw::json::DAW_JSON_VER::json_details::parse_value ( ParseState &  parse_state,
ParseTag< JsonParseTypes::Unsigned  
)
inlineconstexpr

◆ parse_value() [30/35]

template<typename JsonMember , bool KnownBounds = false, typename ParseState >
constexpr json_result<JsonMember> daw::json::DAW_JSON_VER::json_details::parse_value ( ParseState &  parse_state,
ParseTag< JsonParseTypes::Unsigned  
)
inlineconstexpr

◆ parse_value() [31/35]

template<typename JsonMember , bool , typename ParseState >
constexpr DAW_ATTRIB_INLINE json_result<JsonMember> daw::json::DAW_JSON_VER::json_details::parse_value ( ParseState &  parse_state,
ParseTag< JsonParseTypes::Variant  
)
constexpr

◆ parse_value() [32/35]

template<typename JsonMember , bool KnownBounds = false, typename ParseState >
constexpr json_result<JsonMember> daw::json::DAW_JSON_VER::json_details::parse_value ( ParseState &  parse_state,
ParseTag< JsonParseTypes::Variant  
)
constexpr

◆ parse_value() [33/35]

template<typename JsonMember , bool , typename ParseState >
constexpr DAW_ATTRIB_INLINE json_result<JsonMember> daw::json::DAW_JSON_VER::json_details::parse_value ( ParseState &  parse_state,
ParseTag< JsonParseTypes::VariantTagged  
)
inlineconstexpr

◆ parse_value() [34/35]

template<typename JsonMember , bool KnownBounds, std::size_t N, typename ParseState , bool B>
constexpr json_result< JsonMember > daw::json::DAW_JSON_VER::json_details::parse_value ( ParseState &  parse_state,
ParseTag< JsonParseTypes::VariantTagged  
)
inlineconstexpr

◆ parse_value() [35/35]

template<typename JsonMember , bool KnownBounds = false, typename ParseState >
constexpr json_result<JsonMember> daw::json::DAW_JSON_VER::json_details::parse_value ( ParseState &  parse_state,
ParseTag< JsonParseTypes::VariantTagged  
)
inlineconstexpr

◆ parse_variant_value()

template<JsonBaseParseTypes BPT, typename JsonMembers , typename ParseState >
constexpr DAW_ATTRIB_FLATTEN json_result<JsonMembers> daw::json::DAW_JSON_VER::json_details::parse_variant_value ( ParseState &  parse_state)
constexpr

◆ parse_visit()

template<typename Result , typename TypeList , std::size_t pos = 0, typename ParseState >
constexpr DAW_ATTRIB_FLATINLINE Result daw::json::DAW_JSON_VER::json_details::parse_visit ( std::size_t  idx,
ParseState &  parse_state 
)
constexpr

◆ parse_with_strtod()

template<typename Real , std::enable_if_t< std::is_floating_point_v< Real >, std::nullptr_t > = nullptr>
DAW_ATTRIB_NOINLINE Real daw::json::DAW_JSON_VER::json_details::parse_with_strtod ( char const *  first,
char const *  last 
)

◆ pop_json_path()

constexpr pop_json_path_result daw::json::DAW_JSON_VER::json_details::pop_json_path ( daw::string_view &  path)
constexpr

◆ power10() [1/2]

template<typename Result , typename Unsigned >
static constexpr DAW_ATTRIB_FLATINLINE Result daw::json::DAW_JSON_VER::json_details::power10 ( constexpr_exec_tag  ,
Result  result,
Unsigned  p 
)
inlinestaticconstexpr

◆ power10() [2/2]

template<typename Result , typename Unsigned >
static constexpr DAW_ATTRIB_FLATINLINE Result daw::json::DAW_JSON_VER::json_details::power10 ( runtime_exec_tag  ,
Result  result,
Unsigned  p 
)
inlinestaticconstexpr

◆ serialize_json_class()

template<typename... JsonMembers, typename OutputIterator , std::size_t... Is, typename Tuple , typename Value >
constexpr OutputIterator daw::json::DAW_JSON_VER::json_details::serialize_json_class ( OutputIterator  it,
Tuple const &  args,
Value const &  value,
std::index_sequence< Is... >   
)
inlineconstexpr

◆ serialize_ordered_json_class()

template<typename... JsonMembers, typename OutputIterator , typename Tuple , typename Value , std::size_t... Is>
constexpr OutputIterator daw::json::DAW_JSON_VER::json_details::serialize_ordered_json_class ( OutputIterator  it,
Tuple const &  args,
Value const &  value,
std::index_sequence< Is... >   
)
inlineconstexpr

◆ set_bits() [1/2]

template<typename Policy , typename... Policies>
constexpr json_options_t daw::json::DAW_JSON_VER::json_details::set_bits ( json_options_t  value,
Policy  pol,
Policies...  pols 
)
constexpr

◆ set_bits() [2/2]

template<typename... OptionList, typename Option , typename... Options>
constexpr json_options_t daw::json::DAW_JSON_VER::json_details::set_bits ( JsonOptionList< OptionList... >  ,
json_options_t  value,
Option  pol,
Options...  pols 
)
constexpr

◆ set_bits_for() [1/2]

template<typename... OptionList, typename Option >
static constexpr json_options_t daw::json::DAW_JSON_VER::json_details::set_bits_for ( JsonOptionList< OptionList... >  ,
Option  e 
)
staticconstexpr

◆ set_bits_for() [2/2]

template<typename Policy >
constexpr json_options_t daw::json::DAW_JSON_VER::json_details::set_bits_for ( Policy  e)
constexpr

◆ set_bits_in() [1/2]

template<typename Policy >
constexpr void daw::json::DAW_JSON_VER::json_details::set_bits_in ( json_options_t value,
Policy  e 
)
constexpr

◆ set_bits_in() [2/2]

template<typename... OptionList, typename Option >
constexpr void daw::json::DAW_JSON_VER::json_details::set_bits_in ( JsonOptionList< OptionList... >  ,
json_options_t value,
Option  e 
)
constexpr

◆ skip_digits()

template<bool skip_end_check, typename CharT >
constexpr DAW_ATTRIB_FLATINLINE CharT* daw::json::DAW_JSON_VER::json_details::skip_digits ( CharT *  first,
CharT *const  last 
)
inlineconstexpr

◆ skip_false()

template<typename ParseState >
constexpr ParseState daw::json::DAW_JSON_VER::json_details::skip_false ( ParseState &  parse_state)
constexpr

◆ skip_known_value()

template<typename JsonMember , typename ParseState >
constexpr DAW_ATTRIB_FLATINLINE ParseState daw::json::DAW_JSON_VER::json_details::skip_known_value ( ParseState &  parse_state)
inlineconstexpr

◆ skip_literal()

template<typename ParseState >
constexpr ParseState daw::json::DAW_JSON_VER::json_details::skip_literal ( ParseState &  parse_state)
inlineconstexpr

◆ skip_null()

template<typename ParseState >
constexpr ParseState daw::json::DAW_JSON_VER::json_details::skip_null ( ParseState &  parse_state)
constexpr

◆ skip_number()

template<typename ParseState >
constexpr ParseState daw::json::DAW_JSON_VER::json_details::skip_number ( ParseState &  parse_state)
constexpr

◆ skip_quote_when_literal_as_string()

template<LiteralAsStringOpt literal_as_string, typename ParseState >
constexpr DAW_ATTRIB_INLINE void daw::json::DAW_JSON_VER::json_details::skip_quote_when_literal_as_string ( ParseState &  parse_state)
inlineconstexpr

◆ skip_string()

template<typename ParseState >
constexpr DAW_ATTRIB_FLATINLINE ParseState daw::json::DAW_JSON_VER::json_details::skip_string ( ParseState &  parse_state)
inlineconstexpr

◆ skip_string_nq()

template<typename ParseState >
constexpr DAW_ATTRIB_FLATINLINE ParseState daw::json::DAW_JSON_VER::json_details::skip_string_nq ( ParseState &  parse_state)
inlineconstexpr

◆ skip_true()

template<typename ParseState >
constexpr ParseState daw::json::DAW_JSON_VER::json_details::skip_true ( ParseState &  parse_state)
constexpr

◆ skip_value()

template<typename ParseState >
constexpr ParseState daw::json::DAW_JSON_VER::json_details::skip_value ( ParseState &  parse_state)
inlineconstexpr

◆ to_daw_json_string() [1/19]

template<typename JsonMember , typename OutputIterator , typename parse_to_t >
constexpr OutputIterator daw::json::DAW_JSON_VER::json_details::to_daw_json_string ( ParseTag< JsonParseTypes::Array ,
OutputIterator  it,
parse_to_t const &  value 
)
constexpr

◆ to_daw_json_string() [2/19]

template<typename JsonMember , typename OutputIterator , typename parse_to_t >
constexpr OutputIterator daw::json::DAW_JSON_VER::json_details::to_daw_json_string ( ParseTag< JsonParseTypes::Bool ,
OutputIterator  it,
parse_to_t const &  value 
)
constexpr

◆ to_daw_json_string() [3/19]

template<typename JsonMember , typename OutputIterator , typename parse_to_t >
constexpr OutputIterator daw::json::DAW_JSON_VER::json_details::to_daw_json_string ( ParseTag< JsonParseTypes::Class ,
OutputIterator  it,
parse_to_t const &  value 
)
inlineconstexpr

◆ to_daw_json_string() [4/19]

template<typename JsonMember , typename OutputIterator , typename parse_to_t >
constexpr OutputIterator daw::json::DAW_JSON_VER::json_details::to_daw_json_string ( ParseTag< JsonParseTypes::Custom ,
OutputIterator  it,
parse_to_t const &  value 
)
inlineconstexpr

◆ to_daw_json_string() [5/19]

template<typename JsonMember , typename OutputIterator , typename parse_to_t >
constexpr OutputIterator daw::json::DAW_JSON_VER::json_details::to_daw_json_string ( ParseTag< JsonParseTypes::Date ,
OutputIterator  it,
parse_to_t const &  value 
)
constexpr

◆ to_daw_json_string() [6/19]

template<typename JsonMember , typename OutputIterator , typename parse_to_t >
constexpr OutputIterator daw::json::DAW_JSON_VER::json_details::to_daw_json_string ( ParseTag< JsonParseTypes::KeyValue ,
OutputIterator  it,
parse_to_t const &  value 
)
constexpr

◆ to_daw_json_string() [7/19]

template<typename JsonMember , typename OutputIterator , typename parse_to_t >
constexpr OutputIterator daw::json::DAW_JSON_VER::json_details::to_daw_json_string ( ParseTag< JsonParseTypes::KeyValueArray ,
OutputIterator  it,
parse_to_t const &  value 
)
constexpr

◆ to_daw_json_string() [8/19]

template<typename JsonMember , typename OutputIterator , typename Optional >
constexpr OutputIterator daw::json::DAW_JSON_VER::json_details::to_daw_json_string ( ParseTag< JsonParseTypes::Null ,
OutputIterator  it,
Optional const &  value 
)
inlineconstexpr

◆ to_daw_json_string() [9/19]

template<typename JsonMember , typename OutputIterator , typename parse_to_t >
constexpr OutputIterator daw::json::DAW_JSON_VER::json_details::to_daw_json_string ( ParseTag< JsonParseTypes::Null ,
OutputIterator  it,
parse_to_t const &  value 
)
inlineconstexpr

◆ to_daw_json_string() [10/19]

template<typename JsonMember , typename OutputIterator , typename parse_to_t >
OutputIterator daw::json::DAW_JSON_VER::json_details::to_daw_json_string ( ParseTag< JsonParseTypes::Real ,
OutputIterator  it,
parse_to_t const &  value 
)
inline

◆ to_daw_json_string() [11/19]

template<typename JsonMember , typename OutputIterator , typename parse_to_t >
constexpr OutputIterator daw::json::DAW_JSON_VER::json_details::to_daw_json_string ( ParseTag< JsonParseTypes::Signed ,
OutputIterator  it,
parse_to_t const &  value 
)
constexpr

◆ to_daw_json_string() [12/19]

template<typename JsonMember , typename OutputIterator , typename parse_to_t >
constexpr OutputIterator daw::json::DAW_JSON_VER::json_details::to_daw_json_string ( ParseTag< JsonParseTypes::SizedArray ,
OutputIterator  it,
parse_to_t const &  value 
)
constexpr

◆ to_daw_json_string() [13/19]

template<typename JsonMember , typename OutputIterator , typename parse_to_t >
constexpr OutputIterator daw::json::DAW_JSON_VER::json_details::to_daw_json_string ( ParseTag< JsonParseTypes::StringEscaped ,
OutputIterator  it,
parse_to_t const &  value 
)
inlineconstexpr

◆ to_daw_json_string() [14/19]

template<typename JsonMember , typename OutputIterator , typename parse_to_t >
constexpr OutputIterator daw::json::DAW_JSON_VER::json_details::to_daw_json_string ( ParseTag< JsonParseTypes::StringRaw ,
OutputIterator  it,
parse_to_t const &  value 
)
inlineconstexpr

◆ to_daw_json_string() [15/19]

template<typename JsonMember , typename OutputIterator , typename parse_to_t >
constexpr OutputIterator daw::json::DAW_JSON_VER::json_details::to_daw_json_string ( ParseTag< JsonParseTypes::Tuple ,
OutputIterator  it,
parse_to_t const &  value 
)
constexpr

◆ to_daw_json_string() [16/19]

template<typename JsonMember , typename OutputIterator , typename parse_to_t >
constexpr OutputIterator daw::json::DAW_JSON_VER::json_details::to_daw_json_string ( ParseTag< JsonParseTypes::Unknown ,
OutputIterator  it,
parse_to_t const &  value 
)
inlineconstexpr

◆ to_daw_json_string() [17/19]

template<typename JsonMember , typename OutputIterator , typename parse_to_t >
constexpr OutputIterator daw::json::DAW_JSON_VER::json_details::to_daw_json_string ( ParseTag< JsonParseTypes::Unsigned ,
OutputIterator  it,
parse_to_t const &  value 
)
constexpr

◆ to_daw_json_string() [18/19]

template<typename JsonMember , typename OutputIterator , typename parse_to_t >
constexpr OutputIterator daw::json::DAW_JSON_VER::json_details::to_daw_json_string ( ParseTag< JsonParseTypes::Variant ,
OutputIterator  it,
parse_to_t const &  value 
)
inlineconstexpr

◆ to_daw_json_string() [19/19]

template<typename JsonMember , typename OutputIterator , typename parse_to_t >
constexpr OutputIterator daw::json::DAW_JSON_VER::json_details::to_daw_json_string ( ParseTag< JsonParseTypes::VariantTagged ,
OutputIterator  it,
parse_to_t const &  value 
)
inlineconstexpr

◆ to_daw_json_string_tuple()

template<typename JsonMember , typename OutputIterator , typename parse_to_t , std::size_t... Is>
OutputIterator daw::json::DAW_JSON_VER::json_details::to_daw_json_string_tuple ( OutputIterator  it,
parse_to_t const &  value,
std::index_sequence< Is... >   
)

◆ to_json_ordered_str()

template<size_t TupleIdx, typename JsonMember , typename OutputIterator , template< class... > class Tuple, typename... Args>
constexpr void daw::json::DAW_JSON_VER::json_details::to_json_ordered_str ( std::size_t &  array_idx,
OutputIterator &  it,
Tuple< Args... > const &  tp 
)
constexpr

◆ to_json_str()

template<std::size_t pos, typename JsonMember , typename OutputIterator , typename Tuple , typename Value , typename Visited >
constexpr void daw::json::DAW_JSON_VER::json_details::to_json_str ( bool &  is_first,
OutputIterator &  it,
Tuple const &  tp,
Value const &  ,
Visited &  visited_members 
)
inlineconstexpr

◆ to_nibble()

constexpr UInt8 daw::json::DAW_JSON_VER::json_details::to_nibble ( unsigned char  chr)
inlineconstexpr

◆ to_nibble_char()

template<typename Char >
constexpr char daw::json::DAW_JSON_VER::json_details::to_nibble_char ( Char  c)
constexpr

◆ to_variant_string()

template<std::size_t idx, typename JsonMembers , typename OutputIterator , typename parse_to_t >
constexpr void daw::json::DAW_JSON_VER::json_details::to_variant_string ( OutputIterator &  it,
parse_to_t const &  value 
)
constexpr

◆ u32toC()

constexpr char daw::json::DAW_JSON_VER::json_details::u32toC ( UInt32  value)
constexpr

◆ uneval_func()

template<typename T >
T daw::json::DAW_JSON_VER::json_details::uneval_func ( )

◆ unsigned_parser()

template<typename Unsigned , JsonRangeCheck RangeChecked, bool KnownBounds, typename ParseState , std::enable_if_t< KnownBounds, std::nullptr_t > = nullptr>
static constexpr Unsigned daw::json::DAW_JSON_VER::json_details::unsigned_parser ( constexpr_exec_tag  ,
ParseState &  parse_state 
)
staticconstexpr

◆ utf32_to_utf8()

template<typename OutputIterator >
constexpr void daw::json::DAW_JSON_VER::json_details::utf32_to_utf8 ( std::uint32_t  cp,
OutputIterator &  it 
)
constexpr

Variable Documentation

◆ all_json_members_must_exist_v

template<typename T , typename ParseState >
constexpr bool daw::json::DAW_JSON_VER::json_details::all_json_members_must_exist_v
inlineconstexpr
Initial value:
=
not ignore_unknown_members_v<T> and
( is_exact_class_mapping_v<T> or
ParseState::use_exact_mappings_by_default )

◆ basic_option_bits_start

template<typename Option , typename Options >
constexpr unsigned daw::json::DAW_JSON_VER::json_details::basic_option_bits_start
inlineconstexpr
Initial value:
=
option_bits_start_impl<Option, Options>::template calc(
std::make_index_sequence<pack_size_v<Options>>{ } )

◆ basic_policy_bits_start

template<typename Policy , typename Policies >
constexpr unsigned daw::json::DAW_JSON_VER::json_details::basic_policy_bits_start
inlineconstexpr
Initial value:
=
option_bits_start_impl<Policy, Policies>::template calc(
std::make_index_sequence<pack_size_v<Policies>>{ } )

◆ bool_opts_set

template<json_options_t CurrentOptions, auto option, auto... options>
constexpr json_options_t daw::json::DAW_JSON_VER::json_details::bool_opts_set
inlineconstexpr
Initial value:
=
set_bits( bool_opts, CurrentOptions, option, options... )
constexpr json_options_t set_bits(JsonOptionList< OptionList... >, json_options_t value, Option pol, Options... pols)
Definition: daw_json_option_bits.h:138
constexpr auto bool_opts
Definition: daw_json_type_options.h:81

◆ can_defer_construction_v

template<typename Constructor , typename... Members>
constexpr bool daw::json::DAW_JSON_VER::json_details::can_defer_construction_v
inlineconstexpr
Initial value:
=
std::is_invocable_v<Constructor, typename Members::parse_to_t...>

◆ can_deref_v

template<typename T >
constexpr bool daw::json::DAW_JSON_VER::json_details::can_deref_v = can_deref<T>::value
inlineconstexpr

◆ can_random_v

template<bool IsKnown>
constexpr bool daw::json::DAW_JSON_VER::json_details::can_random_v = IsKnown
inlineconstexpr

◆ class_opts_set

template<json_options_t CurrentOptions, auto option, auto... options>
constexpr json_options_t daw::json::DAW_JSON_VER::json_details::class_opts_set
inlineconstexpr
Initial value:
=
set_bits( class_opts, CurrentOptions, option, options... )
constexpr auto class_opts
Definition: daw_json_type_options.h:167

◆ construct_value_tp_invoke

template<typename Constructor >
constexpr auto daw::json::DAW_JSON_VER::json_details::construct_value_tp_invoke
inlineconstexpr
Initial value:
=
construct_value_tp_invoke_t<Constructor>{ }

◆ default_json_option_value

template<typename >
constexpr auto daw::json::DAW_JSON_VER::json_details::default_json_option_value
inlineconstexpr
Initial value:
= [] {
struct unknown_policy {};
return unknown_policy{ };
}( )

◆ default_json_option_value< AllowEscapeCharacter >

Initial value:
=
AllowEscapeCharacter::Allow

◆ default_json_option_value< AllowEscapedNames >

Initial value:
=
AllowEscapedNames::no

◆ default_json_option_value< CheckedParseMode >

Initial value:
=
CheckedParseMode::yes

◆ default_json_option_value< EightBitModes >

Initial value:
=
EightBitModes::AllowFull

◆ default_json_option_value< EmptyStringNull >

Initial value:
=
EmptyStringNull::no

◆ default_json_option_value< ExcludeSpecialEscapes >

Initial value:
=
ExcludeSpecialEscapes::no

◆ default_json_option_value< ExecModeTypes >

Initial value:
=
ExecModeTypes::compile_time

◆ default_json_option_value< ForceFullNameCheck >

Initial value:
=
ForceFullNameCheck::no

◆ default_json_option_value< IEEE754Precise >

Initial value:
=
IEEE754Precise::no

◆ default_json_option_value< JsonCustomTypes >

Initial value:
=
JsonCustomTypes::String

◆ default_json_option_value< JsonNullable >

Initial value:
=
JsonNullable::MustExist

◆ default_json_option_value< JsonRangeCheck >

Initial value:
=
JsonRangeCheck::Never

◆ default_json_option_value< LiteralAsStringOpt >

Initial value:
=
LiteralAsStringOpt::Never

◆ default_json_option_value< MinifiedDocument >

Initial value:
=
MinifiedDocument::no

◆ default_json_option_value< MustVerifyEndOfDataIsValid >

Initial value:
=
MustVerifyEndOfDataIsValid::no

◆ default_json_option_value< PolicyCommentTypes >

Initial value:
=
PolicyCommentTypes::none

◆ default_json_option_value< TemporarilyMutateBuffer >

Initial value:
=
TemporarilyMutateBuffer::no

◆ default_json_option_value< UseExactMappingsByDefault >

Initial value:
=
UseExactMappingsByDefault::no

◆ default_json_option_value< ZeroTerminatedString >

Initial value:
=
ZeroTerminatedString::no

◆ default_key_name

constexpr char const daw::json::DAW_JSON_VER::json_details::default_key_name[] = "key"
inlineconstexpr

◆ default_option_flag

template<typename OptionList >
constexpr json_options_t daw::json::DAW_JSON_VER::json_details::default_option_flag
inlinestaticconstexpr
Initial value:
=
default_option_flag_t<OptionList>::value

◆ default_policy_flag

constexpr json_options_t daw::json::DAW_JSON_VER::json_details::default_policy_flag
inlinestaticconstexpr
Initial value:
=
default_policy_flag_t<policy_list>::value

◆ default_value_name

constexpr char const daw::json::DAW_JSON_VER::json_details::default_value_name[] = "value"
inlineconstexpr

◆ digits100

constexpr auto daw::json::DAW_JSON_VER::json_details::digits100
inlineconstexpr
Initial value:
= [] {
std::array<char[2], 100> result{ };
for( size_t n = 0; n < 100; ++n ) {
result[n][0] =
static_cast<char>( ( n % 10 ) + static_cast<unsigned char>( '0' ) );
result[n][1] =
static_cast<char>( ( n / 10 ) + static_cast<unsigned char>( '0' ) );
}
return result;
}( )

◆ dpow10_tbl

constexpr double daw::json::DAW_JSON_VER::json_details::dpow10_tbl[]
inlineconstexpr

◆ exec_mode_from_tag

template<typename ExecMode >
constexpr ExecModeTypes daw::json::DAW_JSON_VER::json_details::exec_mode_from_tag
inlineconstexpr
Initial value:
=
exec_mode_from_tag_t<ExecMode>::value

◆ has_deduced_type_mapping_v

template<typename T >
constexpr bool daw::json::DAW_JSON_VER::json_details::has_deduced_type_mapping_v
inlineconstexpr
Initial value:
=
json_deduced_type_map<T>::type_map_found

◆ has_dependent_member_v

template<typename JsonMember >
constexpr bool daw::json::DAW_JSON_VER::json_details::has_dependent_member_v
inlineconstexpr
Initial value:
=
daw::is_detected_v<dependent_member_t, JsonMember>

◆ has_empty_member_v

template<typename T >
constexpr bool daw::json::DAW_JSON_VER::json_details::has_empty_member_v
inlineconstexpr
Initial value:
=
daw::is_detected_v<has_empty_member_test, T>

◆ has_from_string_v

template<typename T >
constexpr bool daw::json::DAW_JSON_VER::json_details::has_from_string_v
inlineconstexpr
Initial value:
=
daw::is_detected_v<from_string_test, T>

◆ has_insert_end_v

template<typename Container , typename Value >
constexpr bool daw::json::DAW_JSON_VER::json_details::has_insert_end_v
inlineconstexpr
Initial value:
=
daw::is_detected<detect_insert_end, Container, Value>::value

◆ has_istream_op_v

template<typename T >
constexpr bool daw::json::DAW_JSON_VER::json_details::has_istream_op_v
inlineconstexpr
Initial value:
=
daw::is_detected_v<has_rshift_test, std::stringstream, T>

◆ has_json_data_contract_trait_v

template<typename T >
constexpr bool daw::json::DAW_JSON_VER::json_details::has_json_data_contract_trait_v
inlineconstexpr
Initial value:
=
has_json_data_contract_trait<T>::value

◆ has_json_link_quick_map_v

template<typename T >
constexpr bool daw::json::DAW_JSON_VER::json_details::has_json_link_quick_map_v
inlineconstexpr
Initial value:
=
has_json_link_quick_map<T>::value

◆ has_json_member_constructor_v

template<typename T >
constexpr bool daw::json::DAW_JSON_VER::json_details::has_json_member_constructor_v
inlineconstexpr
Initial value:
=
daw::is_detected<json_member_constructor_t, T>::value

◆ has_json_member_parse_to_v

template<typename T >
constexpr bool daw::json::DAW_JSON_VER::json_details::has_json_member_parse_to_v
inlineconstexpr
Initial value:
=
daw::is_detected<json_member_constructor_t, T>::value

◆ has_json_to_json_data_v

template<typename T >
constexpr bool daw::json::DAW_JSON_VER::json_details::has_json_to_json_data_v
inlineconstexpr
Initial value:
=
daw::is_detected<json_parser_to_json_data_t, T>::value

◆ has_op_bool_v

template<typename T >
constexpr bool daw::json::DAW_JSON_VER::json_details::has_op_bool_v
inlineconstexpr
Initial value:
=
daw::is_detected_v<has_op_bool_test, T>

◆ has_op_star_v

template<typename T >
constexpr bool daw::json::DAW_JSON_VER::json_details::has_op_star_v
inlineconstexpr
Initial value:
=
daw::is_detected_v<has_op_star_test, T>

◆ has_ostream_op_v

template<typename T >
constexpr bool daw::json::DAW_JSON_VER::json_details::has_ostream_op_v
inlineconstexpr
Initial value:
=
daw::is_detected_v<has_lshift_test, std::stringstream, T>

◆ has_push_back_v

template<typename Container , typename Value >
constexpr bool daw::json::DAW_JSON_VER::json_details::has_push_back_v
inlineconstexpr
Initial value:
=
daw::is_detected<detect_push_back, Container, Value>::value

◆ has_switcher_v

template<typename JsonMember >
constexpr bool daw::json::DAW_JSON_VER::json_details::has_switcher_v
inlineconstexpr
Initial value:
=
daw::is_detected_v<switcher_t, JsonMember>

◆ has_unnamed_default_type_mapping_v

template<typename T >
constexpr bool daw::json::DAW_JSON_VER::json_details::has_unnamed_default_type_mapping_v
inlineconstexpr
Initial value:
=
has_json_deduced_type<T>::value

◆ is_a_json_tagged_variant_v

template<typename T >
constexpr bool daw::json::DAW_JSON_VER::json_details::is_a_json_tagged_variant_v
inlineconstexpr
Initial value:
=
is_a_json_tagged_variant<T>::value

◆ is_a_json_type_v

template<typename T >
constexpr bool daw::json::DAW_JSON_VER::json_details::is_a_json_type_v = is_a_json_type<T>::value
inlineconstexpr

◆ is_allocator_v

template<typename Allocator >
constexpr bool daw::json::DAW_JSON_VER::json_details::is_allocator_v
inlineconstexpr
Initial value:
= std::conjunction<
daw::is_detected<has_allocate_test, Allocator>,
daw::is_detected<has_deallocate_test, Allocator>>::value

◆ is_an_ordered_member_v

template<typename T >
constexpr bool daw::json::DAW_JSON_VER::json_details::is_an_ordered_member_v
inlineconstexpr
Initial value:
=
daw::is_detected_v<ordered_member_t, T>

◆ is_associative_container_v

template<typename AssociativeContainer >
constexpr bool daw::json::DAW_JSON_VER::json_details::is_associative_container_v
inlineconstexpr
Initial value:
=
is_associative_container<AssociativeContainer>::value

◆ is_container_opted_into_json_iostreams_v

template<typename T >
constexpr bool daw::json::DAW_JSON_VER::json_details::is_container_opted_into_json_iostreams_v
inlineconstexpr
Initial value:
=
daw::is_detected<is_container_opted_into_json_iostreams, T>::value

◆ is_container_v

template<typename Container >
constexpr bool daw::json::DAW_JSON_VER::json_details::is_container_v = is_container<Container>::value
inlineconstexpr

◆ is_digit

constexpr auto daw::json::DAW_JSON_VER::json_details::is_digit
inlineconstexpr
Initial value:
= []( char c ) -> daw::UInt8 {
return static_cast<unsigned>( static_cast<unsigned char>( c ) ) -
static_cast<unsigned>(
static_cast<unsigned char>( '0' ) ) <
10U
? daw::UInt8{ 0 }
: daw::UInt8{ 0xFFU };
}

◆ is_guaranteed_rvo_v

template<typename ParsePolicy >
constexpr bool daw::json::DAW_JSON_VER::json_details::is_guaranteed_rvo_v
inlineconstexpr
Initial value:
=
ParsePolicy::exec_tag_t::always_rvo

◆ is_json_class_map_v

template<typename JsonType >
constexpr bool daw::json::DAW_JSON_VER::json_details::is_json_class_map_v
inlineconstexpr
Initial value:
=
daw::is_detected_v<is_json_class_map_test, JsonType>

◆ is_json_map_alias_v

template<typename T >
constexpr bool daw::json::DAW_JSON_VER::json_details::is_json_map_alias_v
inlineconstexpr
Initial value:
=
daw::is_detected_v<json_map_alias_test, T>

◆ is_json_nullable_v

template<typename JsonType >
constexpr bool daw::json::DAW_JSON_VER::json_details::is_json_nullable_v
inlinestaticconstexpr
Initial value:
=
is_json_nullable<JsonType>::value

◆ is_mutable_string

template<typename String >
constexpr bool daw::json::DAW_JSON_VER::json_details::is_mutable_string
constexpr
Initial value:
=
json_details::is_mutable_string_v<String>

◆ is_mutable_string_v

template<typename String >
constexpr bool daw::json::DAW_JSON_VER::json_details::is_mutable_string_v
inlineconstexpr
Initial value:
=
not std::is_const_v<std::remove_pointer_t<std::remove_reference_t<
decltype( std::data( std::declval<String &&>( ) ) )>>>

◆ is_no_name_v

template<typename JsonMember >
constexpr bool daw::json::DAW_JSON_VER::json_details::is_no_name_v = is_no_name<JsonMember>::value
inlineconstexpr

◆ is_nullability_compatable_v

template<JsonNullable ClassNullability, JsonNullable DependentNullability>
constexpr bool daw::json::DAW_JSON_VER::json_details::is_nullability_compatable_v
inlineconstexpr
Initial value:
=
( DependentNullability == JsonNullable::MustExist ) or
( ClassNullability == JsonNullable::Nullable or
ClassNullability == JsonNullable::NullVisible )

◆ is_nullable_json_value_v

template<JsonNullable nullable>
constexpr bool daw::json::DAW_JSON_VER::json_details::is_nullable_json_value_v
inlineconstexpr
Initial value:
=
is_nullable_json_value<nullable>::value

◆ is_nullable_type

template<typename T >
constexpr bool daw::json::DAW_JSON_VER::json_details::is_nullable_type
inlineconstexpr
Initial value:
=
daw::is_detected<underlying_nullable_type, T>::value

◆ is_opted_into_json_iostreams_v

template<typename T >
constexpr bool daw::json::DAW_JSON_VER::json_details::is_opted_into_json_iostreams_v
inlineconstexpr
Initial value:
=
daw::is_detected<is_opted_into_json_iostreams, T>::value

◆ is_option_flag

template<typename Option >
constexpr bool daw::json::DAW_JSON_VER::json_details::is_option_flag = json_option_bits_width<Option> > 0
inlineconstexpr

◆ is_readable_v

template<typename T >
constexpr bool daw::json::DAW_JSON_VER::json_details::is_readable_v
inlineconstexpr
Initial value:
=
has_op_bool_v<T> or has_empty_member_v<T>

◆ is_ref_string

template<typename String >
constexpr bool daw::json::DAW_JSON_VER::json_details::is_ref_string
constexpr
Initial value:
=
not is_rvalue_string<String> and
std::is_const_v<std::remove_reference_t<String>>

◆ is_rvalue_string

template<typename String >
constexpr bool daw::json::DAW_JSON_VER::json_details::is_rvalue_string = std::is_rvalue_reference_v<String>
constexpr

◆ is_string_v

template<typename String >
constexpr bool daw::json::DAW_JSON_VER::json_details::is_string_v = is_string<String>::value
inlineconstexpr

◆ is_string_view_like_v

template<typename T >
constexpr bool daw::json::DAW_JSON_VER::json_details::is_string_view_like_v
inlineconstexpr
Initial value:
=
is_string_view_like<T>::value

◆ is_string_view_like_v< basic_json_value< T > >

template<typename T >
constexpr bool daw::json::DAW_JSON_VER::json_details::is_string_view_like_v< basic_json_value< T > > = false
inlineconstexpr

◆ is_submember_tagged_variant_v

template<typename T >
constexpr bool daw::json::DAW_JSON_VER::json_details::is_submember_tagged_variant_v
inlineconstexpr
Initial value:
=
daw::is_detected<is_submember_tagged_variant_t, T>::value

◆ is_tuple_v

template<typename T >
constexpr bool daw::json::DAW_JSON_VER::json_details::is_tuple_v = is_tuple<T>::value
inlineconstexpr

◆ is_valid_optional_v

template<typename Optional >
constexpr bool daw::json::DAW_JSON_VER::json_details::is_valid_optional_v
inlineconstexpr
Initial value:
=
daw::is_detected<deref_t, Optional>::value

◆ json_class_constructor

template<typename T , typename Default >
constexpr auto daw::json::DAW_JSON_VER::json_details::json_class_constructor
inlineconstexpr
Initial value:
=
json_class_constructor_t<T, Default>{ }

◆ json_custom_opts_set

template<json_options_t CurrentOptions, auto option, auto... options>
constexpr json_options_t daw::json::DAW_JSON_VER::json_details::json_custom_opts_set
inlineconstexpr
Initial value:
=
set_bits( json_custom_opts, CurrentOptions, option, options... )
constexpr auto json_custom_opts
Definition: daw_json_type_options.h:212

◆ json_option_bits_width

template<typename >
constexpr unsigned daw::json::DAW_JSON_VER::json_details::json_option_bits_width = 0
inlineconstexpr

◆ json_option_bits_width< AllowEscapeCharacter >

Initial value:
=
1

◆ json_option_bits_width< AllowEscapedNames >

template<>
constexpr unsigned daw::json::DAW_JSON_VER::json_details::json_option_bits_width< AllowEscapedNames > = 1
inlineconstexpr

◆ json_option_bits_width< CheckedParseMode >

template<>
constexpr unsigned daw::json::DAW_JSON_VER::json_details::json_option_bits_width< CheckedParseMode > = 1
inlineconstexpr

◆ json_option_bits_width< EightBitModes >

template<>
constexpr unsigned daw::json::DAW_JSON_VER::json_details::json_option_bits_width< EightBitModes > = 1
inlineconstexpr

◆ json_option_bits_width< EmptyStringNull >

template<>
constexpr unsigned daw::json::DAW_JSON_VER::json_details::json_option_bits_width< EmptyStringNull > = 1
inlineconstexpr

◆ json_option_bits_width< ExcludeSpecialEscapes >

Initial value:
=
1

◆ json_option_bits_width< ExecModeTypes >

template<>
constexpr unsigned daw::json::DAW_JSON_VER::json_details::json_option_bits_width< ExecModeTypes > = 2
inlineconstexpr

◆ json_option_bits_width< ForceFullNameCheck >

template<>
constexpr unsigned daw::json::DAW_JSON_VER::json_details::json_option_bits_width< ForceFullNameCheck > = 1
inlineconstexpr

◆ json_option_bits_width< IEEE754Precise >

template<>
constexpr unsigned daw::json::DAW_JSON_VER::json_details::json_option_bits_width< IEEE754Precise > = 1
inlineconstexpr

◆ json_option_bits_width< JsonCustomTypes >

template<>
constexpr unsigned daw::json::DAW_JSON_VER::json_details::json_option_bits_width< JsonCustomTypes > = 2
inlineconstexpr

◆ json_option_bits_width< JsonNullable >

template<>
constexpr unsigned daw::json::DAW_JSON_VER::json_details::json_option_bits_width< JsonNullable > = 2
inlineconstexpr

◆ json_option_bits_width< JsonRangeCheck >

template<>
constexpr unsigned daw::json::DAW_JSON_VER::json_details::json_option_bits_width< JsonRangeCheck > = 1
inlineconstexpr

◆ json_option_bits_width< LiteralAsStringOpt >

template<>
constexpr unsigned daw::json::DAW_JSON_VER::json_details::json_option_bits_width< LiteralAsStringOpt > = 2
inlineconstexpr

◆ json_option_bits_width< MinifiedDocument >

template<>
constexpr unsigned daw::json::DAW_JSON_VER::json_details::json_option_bits_width< MinifiedDocument > = 1
inlineconstexpr

◆ json_option_bits_width< MustVerifyEndOfDataIsValid >

◆ json_option_bits_width< PolicyCommentTypes >

template<>
constexpr unsigned daw::json::DAW_JSON_VER::json_details::json_option_bits_width< PolicyCommentTypes > = 2
inlineconstexpr

◆ json_option_bits_width< TemporarilyMutateBuffer >

template<>
constexpr unsigned daw::json::DAW_JSON_VER::json_details::json_option_bits_width< TemporarilyMutateBuffer > = 1
inlineconstexpr

◆ json_option_bits_width< UseExactMappingsByDefault >

◆ json_option_bits_width< ZeroTerminatedString >

Initial value:
=
1

◆ number_opts_set

template<json_options_t CurrentOptions, auto option, auto... options>
constexpr json_options_t daw::json::DAW_JSON_VER::json_details::number_opts_set
inlineconstexpr
Initial value:
=
set_bits( number_opts, CurrentOptions, option, options... )
constexpr auto number_opts
Definition: daw_json_type_options.h:68

◆ number_parse_type_impl_v

template<typename T >
constexpr JsonParseTypes daw::json::DAW_JSON_VER::json_details::number_parse_type_impl_v
inlineconstexpr
Initial value:
= [] {
static_assert( daw::is_arithmetic<T>::value, "Unexpected non-number" );
if constexpr( daw::is_floating_point<T>::value ) {
return JsonParseTypes::Real;
} else if constexpr( daw::is_signed<T>::value ) {
return JsonParseTypes::Signed;
} else if constexpr( daw::is_unsigned<T>::value ) {
return JsonParseTypes::Unsigned;
}
}( )

◆ number_parse_type_v

template<typename T >
constexpr JsonParseTypes daw::json::DAW_JSON_VER::json_details::number_parse_type_v = number_parse_type_test<T>( )
inlineconstexpr

◆ parse_space_needed_v

template<typename >
constexpr std::size_t daw::json::DAW_JSON_VER::json_details::parse_space_needed_v = 1U
inlineconstexpr

◆ parse_space_needed_v< simd_exec_tag >

template<>
constexpr std::size_t daw::json::DAW_JSON_VER::json_details::parse_space_needed_v< simd_exec_tag > = 16U
inlineconstexpr

◆ policy_bits_start

template<typename Policy >
constexpr unsigned daw::json::DAW_JSON_VER::json_details::policy_bits_start
inlineconstexpr
Initial value:
=
basic_policy_bits_start<Policy, policy_list>

◆ string_opts_set

template<json_options_t CurrentOptions, auto option, auto... options>
constexpr json_options_t daw::json::DAW_JSON_VER::json_details::string_opts_set
inlineconstexpr
Initial value:
=
set_bits( string_opts, CurrentOptions, option, options... )
constexpr auto string_opts
Definition: daw_json_type_options.h:123

◆ string_raw_opts_set

template<json_options_t CurrentOptions, auto option, auto... options>
constexpr json_options_t daw::json::DAW_JSON_VER::json_details::string_raw_opts_set
inlineconstexpr
Initial value:
=
set_bits( string_raw_opts, CurrentOptions, option, options... )
constexpr auto string_raw_opts
Definition: daw_json_type_options.h:155

◆ tuple_opts_set

template<json_options_t CurrentOptions, auto option, auto... options>
constexpr json_options_t daw::json::DAW_JSON_VER::json_details::tuple_opts_set
inlineconstexpr
Initial value:
=
set_bits( tuple_opts, CurrentOptions, option, options... )
constexpr auto tuple_opts
Definition: daw_json_type_options.h:178