DAW JSON Link
Namespaces | Classes | Typedefs | Functions | Variables
DAW_JSON_NS::json_details Namespace Reference

Namespaces

 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  base_int_type_impl
 
struct  base_int_type_impl< T, true >
 
struct  basic_appender
 
struct  basic_stateful_json_value_state
 
struct  cannot_deduce_variant_element_types
 
struct  handler_result_holder
 
struct  has_json_data_contract_trait
 
struct  json_array_detect
 
struct  json_data_contract_constructor_impl
 
struct  json_data_contract_constructor_impl< T, true, true >
 
struct  json_identity
 
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  key_table_t
 
class  location_info_t
 
struct  locations_info_t
 
struct  missing_default_type_mapping
 
struct  missing_member
 
struct  missing_token
 
struct  NoAllocator
 
struct  ordered_member_subtype
 
struct  ordered_member_subtype< T, true >
 
struct  ordered_member_wrapper
 
struct  unknown_variant_type
 

Typedefs

template<typename T >
using base_int_type_t = typename base_int_type_impl< T, std::is_enum_v< T > >::type
 
template<typename T >
using can_deref = daw::is_detected< dereffed_type, T >
 
template<typename T >
using cant_deref = daw::not_trait< can_deref< T > >
 
template<typename T >
using deref_t = daw::remove_cvref_t< decltype(deref_detect(std::declval< T >()))>
 
template<typename T >
using dereffed_type = daw::remove_cvref_t< decltype(dereffed_type_impl(daw::tag< 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< Nullable==JsonNullable::Never 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 > >
 
template<typename T >
using force_aggregate_construction_test = decltype(force_aggregate_construction_func< T >())
 
template<typename JsonMember >
using from_json_result_t = json_result< unnamed_default_type_mapping< JsonMember > >
 
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_json_data_constract_constructor_test = typename json_data_contract_trait_t< T >::constructor
 
template<typename T >
using has_unnamed_default_type_mapping = daw::not_trait< std::is_same< unnamed_default_type_mapping< T >, DAW_JSON_NS::missing_json_data_contract_for< T > >>
 
template<typename T >
using is_a_json_tagged_variant_test = typename T::i_am_a_json_tagged_variant
 
template<typename Container >
using is_container_opted_into_json_iostreams = is_opted_into_json_iostreams< typename Container::value_type >
 
template<typename T >
using is_opted_into_json_iostreams = typename json_data_contract< T >::opt_into_iostreams
 
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_vector = daw::not_trait< std::is_same< vector_detect::detector< T >, vector_detect::not_vector > >
 
template<typename JsonMember >
using json_base_type = typename JsonMember::base_type
 
template<typename T , typename Default = default_constructor<T>>
using json_class_constructor_t = std::conditional_t< daw::is_detected_v< json_data_contract_constructor_t, T >, json_data_contract_constructor_t< T >, Default >
 
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_t = typename json_data_contract_constructor_impl< T, daw::is_detected_v< json_data_contract_trait_t, T >, daw::is_detected_v< has_json_data_constract_constructor_test, T > >::type
 
template<JSONNAMETYPE Name, typename T >
using json_link_quick_map_t = typename decltype(json_link_quick_map< Name, T >())::mapped_type
 
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
 
template<typename T >
using json_parser_to_json_data_t = decltype(DAW_JSON_NS::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<(daw::is_integral_v< Unsigned > or std::is_enum_v< Unsigned >), std::conditional_t<(sizeof(Unsigned) > sizeof(MaxArithUnsigned)), Unsigned, MaxArithUnsigned >, Unsigned >
 
template<typename T >
using must_verify_end_of_data_is_valid_t = typename T::must_verify_end_of_data_is_valid
 
template<typename T >
using ordered_member_subtype_t = typename ordered_member_subtype< T, is_an_ordered_member_v< T > >::type
 
template<typename T >
using ordered_member_t = typename T::i_am_an_ordered_member
 
template<typename JsonMember >
using tag_member_t = typename JsonMember::tag_member
 
template<typename T >
using underlying_nullable_type = decltype(*std::declval< T >())
 
template<typename T , JSONNAMETYPE Name = no_name>
using unnamed_default_type_mapping = daw::if_t< json_details::is_a_json_type_v< T >, T, daw::if_t< has_json_data_contract_trait_v< T >, json_class< Name, T, json_class_constructor_t< T > >, daw::if_t< has_json_link_quick_map_v< T >, json_link_quick_map_t< Name, T >, daw::if_t< std::disjunction_v< daw::is_arithmetic< T >, std::is_enum< T > >, json_number< Name, T >, daw::if_t< std::conjunction_v< cant_deref< T >, is_vector< T > >, json_array_detect< Name, vector_detect::detector< T >, T >, DAW_JSON_NS::missing_json_data_contract_for< T > >> >> >
 
template<typename T , JsonNullable Nullable>
using unwrap_type = std::conditional_t< std::conjunction_v< std::bool_constant< Nullable==JsonNullable::Nullable >, daw::is_detected< dereffed_type, T > >, daw::detected_t< dereffed_type, T >, T >
 

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 ParseState >
constexpr DAW_ATTRIBUTE_FLATTEN void class_cleanup_now (ParseState &parse_state)
 
template<typename Value , typename Constructor , typename ParseState , typename... Args>
static constexpr DAW_ATTRIBUTE_FLATTEN auto construct_value (Constructor &&ctor, ParseState &parse_state, Args &&...args)
 
template<typename Value , typename Constructor , typename ParseState , typename... Args>
static constexpr DAW_ATTRIBUTE_FLATTEN auto construct_value_tp (Constructor &&ctor, ParseState &parse_state, std::tuple< Args... > &&tp_args)
 
template<typename Result >
static constexpr DAW_ATTRIBUTE_FLATTEN Result copy_sign (constexpr_exec_tag, Result to, Result from)
 
template<typename Result >
static DAW_ATTRIBUTE_FLATTEN Result copy_sign (runtime_exec_tag, Result to, Result from)
 
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)
 
constexpr void deref_detect (...)
 
template<typename T >
constexpr auto deref_detect (T &&value) -> decltype(*value)
 
template<typename T >
auto dereffed_type_impl (daw::tag_t< T >) -> decltype(*(std::declval< T & >()))
 
template<typename... MemberNames>
static constexpr bool do_hashes_collide ()
 
template<std::size_t pos, bool from_start = false, std::size_t N, typename ParseState , bool B>
static constexpr ParseState find_class_member (locations_info_t< N, B > &locations, ParseState &parse_state, bool is_nullable, daw::string_view member_name)
 
template<JsonBaseParseTypes PT>
constexpr std::size_t find_json_element (std::initializer_list< JsonBaseParseTypes > pts)
 
static std::ptrdiff_t find_lsb_set (runtime_exec_tag, UInt32 value)
 
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 T >
auto force_aggregate_construction_func () -> typename json_data_contract< T >::force_aggregate_construction
 
template<typename... Ts>
constexpr std::conditional_t< std::conjunction_v< has_unnamed_default_type_mapping< Ts >... >, json_tagged_variant_type_list< unnamed_default_type_mapping< Ts >... >, missing_default_type_mapping< unnamed_default_type_mapping< 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, DAW_JSON_NS::basic_json_value< ParseState > jv)
 
template<typename Handler , typename ParseState >
constexpr handler_result_holder handle_on_bool (Handler &&handler, DAW_JSON_NS::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, DAW_JSON_NS::basic_json_value< ParseState > jv)
 
template<typename Handler , typename ParseState >
constexpr handler_result_holder handle_on_error (Handler &&handler, DAW_JSON_NS::basic_json_value< ParseState > jv)
 
template<typename Handler , typename ParseState >
constexpr handler_result_holder handle_on_null (Handler &&handler, DAW_JSON_NS::basic_json_value< ParseState > &jv)
 
template<typename Handler , typename ParseState >
constexpr handler_result_holder handle_on_number (Handler &&handler, DAW_JSON_NS::basic_json_value< ParseState > &jv)
 
template<typename Handler , typename ParseState >
constexpr handler_result_holder handle_on_string (Handler &&handler, DAW_JSON_NS::basic_json_value< ParseState > &jv)
 
template<typename Handler , typename ParsePolicy >
constexpr handler_result_holder handle_on_value (Handler &&handler, DAW_JSON_NS::basic_json_pair< ParsePolicy > p)
 
static constexpr DAW_ATTRIBUTE_FLATTEN 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<JSONNAMETYPE Name, typename T >
constexpr DAW_ATTRIBUTE_HIDDEN auto json_link_quick_map ()
 
constexpr bool json_path_compare (daw::string_view json_path_item, daw::string_view member_name)
 
template<typename ParseState , typename... JsonMembers>
constexpr auto make_locations_info ()
 
template<bool is_unchecked_input, char... keys>
static DAW_ATTRIBUTE_FLATTEN char const * mem_move_to_next_of (runtime_exec_tag, char const *first, char const *last)
 
template<bool is_unchecked_input, typename ExecTag , std::enable_if_t< std::is_base_of_v< runtime_exec_tag, ExecTag >, std::nullptr_t > = nullptr>
static DAW_ATTRIBUTE_FLATTEN char const * mem_skip_string (ExecTag const &tag, char const *first, char const *const last)
 
template<bool is_unchecked_input, typename ExecTag , std::enable_if_t< std::is_base_of_v< runtime_exec_tag, ExecTag >, std::nullptr_t > = nullptr>
static DAW_ATTRIBUTE_FLATTEN char const * mem_skip_until_end_of_string (ExecTag const &tag, char const *first, char const *const last)
 
template<bool is_unchecked_input>
static DAW_ATTRIBUTE_FLATTEN char const * mem_skip_until_end_of_string (runtime_exec_tag tag, char const *first, char const *const last, std::ptrdiff_t &first_escape)
 
template<typename JsonMember , typename OutputIterator , typename T >
constexpr OutputIterator member_to_string (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_v< T >, 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 , std::size_t N, typename ParseState , bool B>
constexpr json_result< JsonMember > parse_class_member (locations_info_t< N, B > &locations, ParseState &parse_state)
 
static constexpr DAW_ATTRIBUTE_FLATTEN unsigned parse_digit (char c)
 
template<typename Value >
static constexpr DAW_ATTRIBUTE_FLATTEN void parse_digits (char const *first, char const *const last, Value &v)
 
template<typename JsonClass , typename... JsonMembers, std::size_t... Is, typename ParseState >
static constexpr json_result< JsonClass > parse_json_class (ParseState &parse_state, std::index_sequence< Is... >)
 
template<typename ParseState >
constexpr DAW_ONLY_FLATTEN daw::string_view parse_name (ParseState &parse_state)
 
template<std::size_t N, typename JsonClass , bool KnownBounds, typename... JsonClasses, typename ParseState >
constexpr DAW_ONLY_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 (std::size_t &member_index, ParseState &parse_state)
 
template<typename JsonClass , typename... JsonMembers, typename ParseState >
static constexpr json_result< JsonClass > parse_ordered_json_class (ParseState &parse_state)
 
template<typename Result , bool KnownRange, typename ParseState , std::enable_if_t< KnownRange, std::nullptr_t > = nullptr>
static constexpr DAW_ATTRIBUTE_FLATTEN Result parse_real (ParseState &parse_state)
 
template<typename Result , bool KnownRange, typename ParseState , std::enable_if_t< not KnownRange, std::nullptr_t > = nullptr>
constexpr DAW_ATTRIBUTE_FLATTEN Result parse_real (ParseState &parse_state)
 
template<bool is_unchecked_input, typename Unsigned >
static constexpr DAW_ATTRIBUTE_FLATTEN char const * parse_real_digits_while_number (char const *first, char const *const last, Unsigned &v)
 
template<bool AllowHighEight, typename JsonMember , bool KnownBounds, typename ParseState >
constexpr auto parse_string_known_stdstring (ParseState &parse_state)
 
template<typename JsonMember , bool KnownBounds = false, typename ParseState >
constexpr json_result< JsonMember > parse_value (ParseTag< JsonParseTypes::Array >, ParseState &)
 
template<typename JsonMember , bool KnownBounds, typename ParseState >
constexpr DAW_ONLY_FLATTEN json_result< JsonMember > parse_value (ParseTag< JsonParseTypes::Array >, ParseState &parse_state)
 
template<typename JsonMember , bool KnownBounds, typename ParseState >
constexpr DAW_ONLY_INLINE json_result< JsonMember > parse_value (ParseTag< JsonParseTypes::Bool >, ParseState &parse_state)
 
template<typename JsonMember , bool KnownBounds = false, typename ParseState >
constexpr json_result< JsonMember > parse_value (ParseTag< JsonParseTypes::Bool >, ParseState &parse_state)
 
template<typename JsonMember , bool KnownBounds, typename ParseState >
constexpr DAW_ONLY_FLATTEN json_result< JsonMember > parse_value (ParseTag< JsonParseTypes::Class >, ParseState &parse_state)
 
template<typename JsonMember , bool KnownBounds = false, typename ParseState >
constexpr json_result< JsonMember > parse_value (ParseTag< JsonParseTypes::Class >, ParseState &parse_state)
 
template<typename JsonMember , bool KnownBounds, typename ParseState >
constexpr json_result< JsonMember > parse_value (ParseTag< JsonParseTypes::Custom >, ParseState &parse_state)
 
template<typename JsonMember , bool KnownBounds, typename ParseState >
constexpr DAW_ONLY_INLINE json_result< JsonMember > parse_value (ParseTag< JsonParseTypes::Date >, ParseState &parse_state)
 
template<typename JsonMember , bool KnownBounds = false, typename ParseState >
constexpr json_result< JsonMember > parse_value (ParseTag< JsonParseTypes::Date >, ParseState &parse_state)
 
template<typename JsonMember , bool KnownBounds, typename ParseState >
constexpr DAW_ONLY_FLATTEN json_result< JsonMember > parse_value (ParseTag< JsonParseTypes::KeyValue >, ParseState &parse_state)
 
template<typename JsonMember , bool KnownBounds = false, typename ParseState >
constexpr json_result< JsonMember > parse_value (ParseTag< JsonParseTypes::KeyValue >, ParseState &parse_state)
 
template<typename JsonMember , bool KnownBounds, typename ParseState >
constexpr DAW_ONLY_FLATTEN json_result< JsonMember > parse_value (ParseTag< JsonParseTypes::KeyValueArray >, ParseState &parse_state)
 
template<typename JsonMember , bool KnownBounds = false, typename ParseState >
constexpr json_result< JsonMember > parse_value (ParseTag< JsonParseTypes::KeyValueArray >, ParseState &parse_state)
 
template<typename JsonMember , bool KnownBounds, typename ParseState >
constexpr DAW_ONLY_INLINE json_result< JsonMember > parse_value (ParseTag< JsonParseTypes::Null >, ParseState &parse_state)
 
template<typename JsonMember , bool KnownBounds = false, typename ParseState >
constexpr json_result< JsonMember > parse_value (ParseTag< JsonParseTypes::Null >, ParseState &parse_state)
 
template<typename JsonMember , bool KnownBounds, typename ParseState >
constexpr DAW_ONLY_INLINE json_result< JsonMember > parse_value (ParseTag< JsonParseTypes::Real >, ParseState &parse_state)
 
template<typename JsonMember , bool KnownBounds = false, typename ParseState >
constexpr json_result< JsonMember > parse_value (ParseTag< JsonParseTypes::Real >, ParseState &parse_state)
 
template<typename JsonMember , bool KnownBounds, typename ParseState >
constexpr DAW_ONLY_INLINE json_result< JsonMember > parse_value (ParseTag< JsonParseTypes::Signed >, ParseState &parse_state)
 
template<typename JsonMember , bool KnownBounds = false, typename ParseState >
constexpr json_result< JsonMember > parse_value (ParseTag< JsonParseTypes::Signed >, ParseState &parse_state)
 
template<typename JsonMember , bool KnownBounds, typename ParseState >
constexpr json_result< JsonMember > parse_value (ParseTag< JsonParseTypes::StringEscaped >, ParseState &parse_state)
 
template<typename JsonMember , bool KnownBounds, typename ParseState >
constexpr DAW_ONLY_INLINE json_result< JsonMember > parse_value (ParseTag< JsonParseTypes::StringRaw >, ParseState &parse_state)
 
template<typename JsonMember , bool KnownBounds = false, typename ParseState >
constexpr json_result< JsonMember > parse_value (ParseTag< JsonParseTypes::StringRaw >, ParseState &parse_state)
 
template<typename JsonMember , bool KnownBounds, typename ParseState >
constexpr DAW_ATTRIBUTE_FLATTEN json_result< JsonMember > parse_value (ParseTag< JsonParseTypes::Unknown >, ParseState &parse_state)
 
template<typename JsonMember , bool KnownBounds = false, typename ParseState >
constexpr json_result< JsonMember > parse_value (ParseTag< JsonParseTypes::Unknown >, ParseState &parse_state)
 
template<typename JsonMember , bool KnownBounds, typename ParseState >
constexpr DAW_ONLY_INLINE json_result< JsonMember > parse_value (ParseTag< JsonParseTypes::Unsigned >, ParseState &parse_state)
 
template<typename JsonMember , bool KnownBounds = false, typename ParseState >
constexpr json_result< JsonMember > parse_value (ParseTag< JsonParseTypes::Unsigned >, ParseState &parse_state)
 
template<typename JsonMember , bool , typename ParseState >
constexpr DAW_ONLY_INLINE json_result< JsonMember > parse_value (ParseTag< JsonParseTypes::Variant >, ParseState &parse_state)
 
template<typename JsonMember , bool KnownBounds = false, typename ParseState >
constexpr json_result< JsonMember > parse_value (ParseTag< JsonParseTypes::Variant >, ParseState &parse_state)
 
template<typename JsonMember , bool , typename ParseState >
constexpr DAW_ONLY_INLINE json_result< JsonMember > parse_value (ParseTag< JsonParseTypes::VariantTagged >, ParseState &parse_state)
 
template<typename JsonMember , bool KnownBounds, std::size_t N, typename ParseState , bool B>
constexpr json_result< JsonMember > parse_value (ParseTag< JsonParseTypes::VariantTagged >, ParseState &parse_state)
 
template<typename JsonMember , bool KnownBounds = false, typename ParseState >
constexpr json_result< JsonMember > parse_value (ParseTag< JsonParseTypes::VariantTagged >, ParseState &parse_state)
 
template<JsonBaseParseTypes BPT, typename JsonMembers , typename ParseState >
constexpr DAW_ONLY_FLATTEN json_result< JsonMembers > parse_variant_value (ParseState &parse_state)
 
template<typename Result , typename TypeList , std::size_t pos = 0, typename ParseState >
constexpr DAW_ATTRIBUTE_FLATTEN Result parse_visit (std::size_t idx, ParseState &parse_state)
 
constexpr auto pop_json_path (daw::string_view &path)
 
template<typename Result , typename Unsigned >
static constexpr DAW_ATTRIBUTE_FLATTEN Result power10 (constexpr_exec_tag, Result result, Unsigned p)
 
template<typename Result , typename Unsigned >
static constexpr DAW_ATTRIBUTE_FLATTEN 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, std::index_sequence< Is... >, Tuple const &args, Value const &value)
 
template<typename... JsonMembers, typename OutputIterator , typename Tuple , typename Value , std::size_t... Is>
constexpr OutputIterator serialize_ordered_json_class (OutputIterator it, std::index_sequence< Is... >, Tuple const &args, Value const &value)
 
template<bool is_unchecked_input>
static constexpr DAW_ATTRIBUTE_FLATTEN char const * skip_digits (char const *first, char const *const last)
 
template<typename ParseState >
static constexpr ParseState skip_false (ParseState &parse_state)
 
template<typename JsonMember , typename ParseState >
constexpr DAW_ATTRIBUTE_FLATTEN ParseState skip_known_value (ParseState &parse_state)
 
template<typename ParseState >
static constexpr ParseState skip_null (ParseState &parse_state)
 
template<typename ParseState >
static constexpr ParseState skip_number (ParseState &parse_state)
 
template<LiteralAsStringOpt literal_as_string, bool KnownBounds = false, typename ParseState >
constexpr DAW_ONLY_INLINE void skip_quote_when_literal_as_string (ParseState &parse_state)
 
template<typename ParseState >
static constexpr DAW_ATTRIBUTE_FLATTEN ParseState skip_string (ParseState &parse_state)
 
template<typename ParseState >
static constexpr DAW_ATTRIBUTE_FLATTEN ParseState skip_string_nq (ParseState &parse_state)
 
template<typename ParseState >
static constexpr ParseState skip_true (ParseState &parse_state)
 
template<typename ParseState >
static constexpr ParseState skip_value (ParseState &parse_state)
 
template<std::size_t , typename JsonMember , typename OutputIterator , typename Value , typename VisitedMembers , std::enable_if_t< not has_tag_member_v< JsonMember >, std::nullptr_t > = nullptr>
constexpr void tags_to_json_str (bool &, OutputIterator const &, Value const &, VisitedMembers const &)
 
template<std::size_t pos, typename JsonMember , typename OutputIterator , typename Value , typename VisitedMembers , std::enable_if_t< has_tag_member_v< JsonMember >, std::nullptr_t > = nullptr>
constexpr void tags_to_json_str (bool &is_first, OutputIterator it, Value const &v, VisitedMembers &visited_members)
 
template<typename... Args>
void test_map (std::map< Args... > const &)
 
template<typename... Args>
void test_map (std::unordered_map< Args... > const &)
 
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::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::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<size_t TupleIdx, typename JsonMember , typename OutputIterator , typename... Args>
constexpr void to_json_ordered_str (std::size_t &array_idx, OutputIterator &it, std::tuple< Args... > const &tp)
 
template<std::size_t pos, typename JsonMember , typename OutputIterator , typename... Args, typename Value , typename Visited >
constexpr void to_json_str (bool &is_first, OutputIterator &it, std::tuple< Args... > 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 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
 
constexpr char const default_key_name [] = "key"
 
constexpr char const default_value_name [] = "value"
 
constexpr auto digits100
 
template<typename T >
constexpr bool has_basic_type_map_v
 
template<typename Container , typename Value >
constexpr bool has_insert_end_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 Container , typename Value >
constexpr bool has_push_back_v
 
template<typename JsonMember >
constexpr bool has_tag_member_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 = daw::is_detected_v<json_type_t, T>
 
template<typename Allocator >
constexpr bool is_allocator_v
 
template<typename T >
constexpr bool is_an_ordered_member_v
 
template<typename T >
constexpr bool is_container_opted_into_json_iostreams_v
 
template<typename ParsePolicy >
constexpr bool use_direct_construction_v
 
template<typename JsonType >
static constexpr bool is_json_nullable_v
 
template<typename T >
constexpr bool is_nullable_type
 
template<typename T >
constexpr bool is_opted_into_json_iostreams_v
 
template<typename T >
constexpr bool is_submember_tagged_variant_v
 
template<typename Optional >
constexpr bool is_valid_optional_v
 
template<typename T >
constexpr auto json_class_constructor = json_class_constructor_t<T>{ }
 
template<char... keys>
static constexpr key_table_t key_table
 
template<typename ParsePolicy >
constexpr bool must_verify_end_of_data_is_valid_v
 If the parse policy has a type alias must_verify_end_of_data_is_valid this trait is true. This is used to ensure that after the JSON value is parse that only whitespace or nothing follows. More...
 
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
 

Typedef Documentation

◆ base_int_type_t

template<typename T >
using DAW_JSON_NS::json_details::base_int_type_t = typedef typename base_int_type_impl<T, std::is_enum_v<T> >::type

◆ can_deref

template<typename T >
using DAW_JSON_NS::json_details::can_deref = typedef daw::is_detected<dereffed_type, T>

◆ cant_deref

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

◆ deref_t

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

◆ dereffed_type

template<typename T >
using DAW_JSON_NS::json_details::dereffed_type = typedef daw::remove_cvref_t<decltype( dereffed_type_impl( daw::tag<T> ) )>

◆ detect_insert_end

template<typename Container , typename Value >
using DAW_JSON_NS::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_NS::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_NS::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_NS::json_details::determine_variant_element_types = typedef std::conditional_t< Nullable == JsonNullable::Never 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> >

◆ force_aggregate_construction_test

◆ from_json_result_t

template<typename JsonMember >
using DAW_JSON_NS::json_details::from_json_result_t = typedef json_result<unnamed_default_type_mapping<JsonMember> >

◆ has_allocate_test

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

◆ has_deallocate_test

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

◆ has_json_data_constract_constructor_test

template<typename T >
using DAW_JSON_NS::json_details::has_json_data_constract_constructor_test = typedef typename json_data_contract_trait_t<T>::constructor

◆ has_unnamed_default_type_mapping

◆ is_a_json_tagged_variant_test

template<typename T >
using DAW_JSON_NS::json_details::is_a_json_tagged_variant_test = typedef typename T::i_am_a_json_tagged_variant

◆ is_container_opted_into_json_iostreams

template<typename Container >
using DAW_JSON_NS::json_details::is_container_opted_into_json_iostreams = typedef is_opted_into_json_iostreams<typename Container::value_type>

◆ is_opted_into_json_iostreams

template<typename T >
using DAW_JSON_NS::json_details::is_opted_into_json_iostreams = typedef typename json_data_contract<T>::opt_into_iostreams

◆ is_submember_tagged_variant_t

template<typename T >
using DAW_JSON_NS::json_details::is_submember_tagged_variant_t = typedef typename json_data_contract<T>::type::i_am_a_submember_tagged_variant

◆ is_vector

template<typename T >
using DAW_JSON_NS::json_details::is_vector = typedef daw::not_trait< std::is_same<vector_detect::detector<T>, vector_detect::not_vector> >

◆ json_base_type

template<typename JsonMember >
using DAW_JSON_NS::json_details::json_base_type = typedef typename JsonMember::base_type

◆ json_class_constructor_t

template<typename T , typename Default = default_constructor<T>>
using DAW_JSON_NS::json_details::json_class_constructor_t = typedef std::conditional_t< daw::is_detected_v<json_data_contract_constructor_t, T>, json_data_contract_constructor_t<T>, Default>

◆ json_class_parse_result_impl

template<typename Constructor , typename... Members>
using DAW_JSON_NS::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_NS::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_NS::json_details::json_class_parse_result_t = typedef daw::remove_cvref_t<json_class_parse_result_impl<Constructor, Members...> >

◆ json_data_contract_constructor_t

template<typename T >
using DAW_JSON_NS::json_details::json_data_contract_constructor_t = typedef typename json_data_contract_constructor_impl< T, daw::is_detected_v<json_data_contract_trait_t, T>, daw::is_detected_v<has_json_data_constract_constructor_test, T> >::type

◆ json_link_quick_map_t

template<JSONNAMETYPE Name, typename T >
using DAW_JSON_NS::json_details::json_link_quick_map_t = typedef typename decltype( json_link_quick_map<Name, T>( ) )::mapped_type

◆ json_member_constructor_t

template<typename T >
using DAW_JSON_NS::json_details::json_member_constructor_t = typedef typename T::constructor_t

◆ json_member_parse_to_t

template<typename T >
using DAW_JSON_NS::json_details::json_member_parse_to_t = typedef typename T::parse_to_t

◆ json_parser_to_json_data_t

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

◆ json_result

template<typename JsonMember >
using DAW_JSON_NS::json_details::json_result = typedef typename JsonMember::parse_to_t

◆ json_type_t

template<typename T >
using DAW_JSON_NS::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_NS::json_details::max_unsigned_t = typedef std::conditional_t< (daw::is_integral_v<Unsigned> or std::is_enum_v<Unsigned>), std::conditional_t<( sizeof( Unsigned ) > sizeof( MaxArithUnsigned ) ), Unsigned, MaxArithUnsigned>, Unsigned>

◆ must_verify_end_of_data_is_valid_t

template<typename T >
using DAW_JSON_NS::json_details::must_verify_end_of_data_is_valid_t = typedef typename T::must_verify_end_of_data_is_valid

◆ ordered_member_subtype_t

template<typename T >
using DAW_JSON_NS::json_details::ordered_member_subtype_t = typedef typename ordered_member_subtype<T, is_an_ordered_member_v<T> >::type

◆ ordered_member_t

template<typename T >
using DAW_JSON_NS::json_details::ordered_member_t = typedef typename T::i_am_an_ordered_member

◆ tag_member_t

template<typename JsonMember >
using DAW_JSON_NS::json_details::tag_member_t = typedef typename JsonMember::tag_member

◆ underlying_nullable_type

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

◆ unnamed_default_type_mapping

template<typename T , JSONNAMETYPE Name = no_name>
using DAW_JSON_NS::json_details::unnamed_default_type_mapping = typedef daw::if_t< json_details::is_a_json_type_v<T>, T, daw::if_t< has_json_data_contract_trait_v<T>, json_class<Name, T, json_class_constructor_t<T> >, daw::if_t< has_json_link_quick_map_v<T>, json_link_quick_map_t<Name, T>, daw::if_t< std::disjunction_v<daw::is_arithmetic<T>, std::is_enum<T> >, json_number<Name, T>, daw::if_t<std::conjunction_v<cant_deref<T>, is_vector<T> >, json_array_detect<Name, vector_detect::detector<T>, T>, DAW_JSON_NS::missing_json_data_contract_for<T> >> >> >

◆ unwrap_type

template<typename T , JsonNullable Nullable>
using DAW_JSON_NS::json_details::unwrap_type = typedef std::conditional_t< std::conjunction_v<std::bool_constant<Nullable == JsonNullable::Nullable>, daw::is_detected<dereffed_type, T> >, daw::detected_t<dereffed_type, T>, T>

Function Documentation

◆ as_copy()

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

◆ byte_from_nibbles()

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

◆ class_cleanup_now()

template<typename ParseState >
constexpr DAW_ATTRIBUTE_FLATTEN void DAW_JSON_NS::json_details::class_cleanup_now ( ParseState &  parse_state)
inlineconstexpr

◆ construct_value()

template<typename Value , typename Constructor , typename ParseState , typename... Args>
static constexpr DAW_ATTRIBUTE_FLATTEN auto DAW_JSON_NS::json_details::construct_value ( Constructor &&  ctor,
ParseState &  parse_state,
Args &&...  args 
)
inlinestaticconstexpr

◆ construct_value_tp()

template<typename Value , typename Constructor , typename ParseState , typename... Args>
static constexpr DAW_ATTRIBUTE_FLATTEN auto DAW_JSON_NS::json_details::construct_value_tp ( Constructor &&  ctor,
ParseState &  parse_state,
std::tuple< Args... > &&  tp_args 
)
inlinestaticconstexpr

◆ copy_sign() [1/2]

template<typename Result >
static constexpr DAW_ATTRIBUTE_FLATTEN Result DAW_JSON_NS::json_details::copy_sign ( constexpr_exec_tag  ,
Result  to,
Result  from 
)
inlinestaticconstexpr

◆ copy_sign() [2/2]

template<typename Result >
static DAW_ATTRIBUTE_FLATTEN Result DAW_JSON_NS::json_details::copy_sign ( runtime_exec_tag  ,
Result  to,
Result  from 
)
inlinestatic

◆ decode_utf16() [1/2]

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

◆ decode_utf16() [2/2]

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

◆ deref_detect() [1/2]

constexpr void DAW_JSON_NS::json_details::deref_detect (   ...)
inlineconstexpr

◆ deref_detect() [2/2]

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

◆ dereffed_type_impl()

template<typename T >
auto DAW_JSON_NS::json_details::dereffed_type_impl ( daw::tag_t< T >  ) -> decltype(*(std::declval< T & >()))

◆ do_hashes_collide()

template<typename... MemberNames>
static constexpr bool DAW_JSON_NS::json_details::do_hashes_collide ( )
inlinestaticconstexpr

◆ find_class_member()

template<std::size_t pos, bool from_start = false, std::size_t N, typename ParseState , bool B>
static constexpr ParseState DAW_JSON_NS::json_details::find_class_member ( locations_info_t< N, B > &  locations,
ParseState &  parse_state,
bool  is_nullable,
daw::string_view  member_name 
)
inlinestaticconstexpr

◆ find_json_element()

template<JsonBaseParseTypes PT>
constexpr std::size_t DAW_JSON_NS::json_details::find_json_element ( std::initializer_list< JsonBaseParseTypes pts)
constexpr

◆ find_lsb_set()

static std::ptrdiff_t DAW_JSON_NS::json_details::find_lsb_set ( runtime_exec_tag  ,
UInt32  value 
)
inlinestatic

◆ find_range() [1/2]

template<typename ParsePolicy , typename String >
constexpr std::pair<bool, ParsePolicy> DAW_JSON_NS::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_NS::json_details::find_range ( String &&  str,
daw::string_view  start_path,
Allocator &  alloc 
)
constexpr

◆ find_range2()

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

◆ force_aggregate_construction_func()

template<typename T >
auto DAW_JSON_NS::json_details::force_aggregate_construction_func ( ) -> typename json_data_contract< T >::force_aggregate_construction

◆ get_variant_type_list() [1/2]

template<typename... Ts>
constexpr std::conditional_t< std::conjunction_v<has_unnamed_default_type_mapping<Ts>...>, json_tagged_variant_type_list<unnamed_default_type_mapping<Ts>...>, missing_default_type_mapping<unnamed_default_type_mapping<Ts>...> > DAW_JSON_NS::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_NS::json_details::get_variant_type_list ( T const *  )
constexpr

◆ handle_on_array_end()

template<typename Handler >
constexpr handler_result_holder DAW_JSON_NS::json_details::handle_on_array_end ( Handler &&  handler)
inlineconstexpr

◆ handle_on_array_start()

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

◆ handle_on_bool()

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

◆ handle_on_class_end()

template<typename Handler >
constexpr handler_result_holder DAW_JSON_NS::json_details::handle_on_class_end ( Handler &&  handler)
inlineconstexpr

◆ handle_on_class_start()

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

◆ handle_on_error()

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

◆ handle_on_null()

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

◆ handle_on_number()

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

◆ handle_on_string()

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

◆ handle_on_value()

template<typename Handler , typename ParsePolicy >
constexpr handler_result_holder DAW_JSON_NS::json_details::handle_on_value ( Handler &&  handler,
DAW_JSON_NS::basic_json_pair< ParsePolicy >  p 
)
inlineconstexpr

◆ is_escaped()

static constexpr DAW_ATTRIBUTE_FLATTEN bool DAW_JSON_NS::json_details::is_escaped ( char const *  ptr,
char const *  min_ptr 
)
inlinestaticconstexpr

◆ is_made_of_eight_digits_cx()

static constexpr bool DAW_JSON_NS::json_details::is_made_of_eight_digits_cx ( const char *  ptr)
inlinestaticconstexpr

◆ is_null() [1/2]

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

◆ is_null() [2/2]

template<typename T >
constexpr bool DAW_JSON_NS::json_details::is_null ( T const &  )
inlineconstexpr

◆ json_get_key()

template<typename Key , typename Value >
constexpr Key const& DAW_JSON_NS::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_NS::json_details::json_get_value ( std::pair< Key, Value > const &  kv)
inlineconstexpr

◆ json_link_quick_map()

template<JSONNAMETYPE Name, typename T >
constexpr DAW_ATTRIBUTE_HIDDEN auto DAW_JSON_NS::json_details::json_link_quick_map ( )
inlineconstexpr

◆ json_path_compare()

constexpr bool DAW_JSON_NS::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 auto DAW_JSON_NS::json_details::make_locations_info ( )
constexpr

◆ mem_move_to_next_of()

template<bool is_unchecked_input, char... keys>
static DAW_ATTRIBUTE_FLATTEN char const* DAW_JSON_NS::json_details::mem_move_to_next_of ( runtime_exec_tag  ,
char const *  first,
char const *  last 
)
inlinestatic

◆ mem_skip_string()

template<bool is_unchecked_input, typename ExecTag , std::enable_if_t< std::is_base_of_v< runtime_exec_tag, ExecTag >, std::nullptr_t > = nullptr>
static DAW_ATTRIBUTE_FLATTEN char const* DAW_JSON_NS::json_details::mem_skip_string ( ExecTag const &  tag,
char const *  first,
char const *const  last 
)
inlinestatic

◆ mem_skip_until_end_of_string() [1/2]

template<bool is_unchecked_input, typename ExecTag , std::enable_if_t< std::is_base_of_v< runtime_exec_tag, ExecTag >, std::nullptr_t > = nullptr>
static DAW_ATTRIBUTE_FLATTEN char const* DAW_JSON_NS::json_details::mem_skip_until_end_of_string ( ExecTag const &  tag,
char const *  first,
char const *const  last 
)
inlinestatic

◆ mem_skip_until_end_of_string() [2/2]

template<bool is_unchecked_input>
static DAW_ATTRIBUTE_FLATTEN char const* DAW_JSON_NS::json_details::mem_skip_until_end_of_string ( runtime_exec_tag  tag,
char const *  first,
char const *const  last,
std::ptrdiff_t &  first_escape 
)
inlinestatic

◆ member_to_string()

template<typename JsonMember , typename OutputIterator , typename T >
constexpr OutputIterator DAW_JSON_NS::json_details::member_to_string ( OutputIterator  it,
T const &  value 
)
inlineconstexpr

◆ needs_slow_path()

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

◆ number_parse_type_test()

template<typename T >
constexpr auto DAW_JSON_NS::json_details::number_parse_type_test ( ) -> std::enable_if_t<std::is_enum_v<T>, JsonParseTypes>
constexpr

◆ output_hex()

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

◆ parse_16_digits()

constexpr UInt64 DAW_JSON_NS::json_details::parse_16_digits ( const char *const  str)
inlineconstexpr

◆ parse_8_digits()

constexpr UInt64 DAW_JSON_NS::json_details::parse_8_digits ( const char *const  str)
inlineconstexpr

◆ parse_class_member()

template<std::size_t member_position, typename JsonMember , std::size_t N, typename ParseState , bool B>
constexpr json_result<JsonMember> DAW_JSON_NS::json_details::parse_class_member ( locations_info_t< N, B > &  locations,
ParseState &  parse_state 
)
constexpr

◆ parse_digit()

static constexpr DAW_ATTRIBUTE_FLATTEN unsigned DAW_JSON_NS::json_details::parse_digit ( char  c)
inlinestaticconstexpr

◆ parse_digits()

template<typename Value >
static constexpr DAW_ATTRIBUTE_FLATTEN void DAW_JSON_NS::json_details::parse_digits ( char const *  first,
char const *const  last,
Value &  v 
)
inlinestaticconstexpr

◆ parse_json_class()

template<typename JsonClass , typename... JsonMembers, std::size_t... Is, typename ParseState >
static constexpr json_result<JsonClass> DAW_JSON_NS::json_details::parse_json_class ( ParseState &  parse_state,
std::index_sequence< Is... >   
)
staticconstexpr

◆ parse_name()

template<typename ParseState >
constexpr DAW_ONLY_FLATTEN daw::string_view DAW_JSON_NS::json_details::parse_name ( ParseState &  parse_state)
constexpr

◆ parse_nth_class()

template<std::size_t N, typename JsonClass , bool KnownBounds, typename... JsonClasses, typename ParseState >
constexpr DAW_ONLY_FLATTEN json_result<JsonClass> DAW_JSON_NS::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_NS::json_details::parse_ordered_class_member ( 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_NS::json_details::parse_ordered_json_class ( ParseState &  parse_state)
staticconstexpr

◆ parse_real() [1/2]

template<typename Result , bool KnownRange, typename ParseState , std::enable_if_t< KnownRange, std::nullptr_t > = nullptr>
static constexpr DAW_ATTRIBUTE_FLATTEN Result DAW_JSON_NS::json_details::parse_real ( ParseState &  parse_state)
inlinestaticconstexpr

◆ parse_real() [2/2]

template<typename Result , bool KnownRange, typename ParseState , std::enable_if_t< not KnownRange, std::nullptr_t > = nullptr>
constexpr DAW_ATTRIBUTE_FLATTEN Result DAW_JSON_NS::json_details::parse_real ( ParseState &  parse_state)
inlineconstexpr

◆ parse_real_digits_while_number()

template<bool is_unchecked_input, typename Unsigned >
static constexpr DAW_ATTRIBUTE_FLATTEN char const* DAW_JSON_NS::json_details::parse_real_digits_while_number ( char const *  first,
char const *const  last,
Unsigned &  v 
)
inlinestaticconstexpr

◆ parse_string_known_stdstring()

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

◆ parse_value() [1/31]

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

◆ parse_value() [2/31]

template<typename JsonMember , bool KnownBounds, typename ParseState >
constexpr DAW_ONLY_FLATTEN json_result<JsonMember> DAW_JSON_NS::json_details::parse_value ( ParseTag< JsonParseTypes::Array ,
ParseState &  parse_state 
)
constexpr

◆ parse_value() [3/31]

template<typename JsonMember , bool KnownBounds, typename ParseState >
constexpr DAW_ONLY_INLINE json_result<JsonMember> DAW_JSON_NS::json_details::parse_value ( ParseTag< JsonParseTypes::Bool ,
ParseState &  parse_state 
)
inlineconstexpr

◆ parse_value() [4/31]

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

◆ parse_value() [5/31]

template<typename JsonMember , bool KnownBounds, typename ParseState >
constexpr DAW_ONLY_FLATTEN json_result<JsonMember> DAW_JSON_NS::json_details::parse_value ( ParseTag< JsonParseTypes::Class ,
ParseState &  parse_state 
)
constexpr

◆ parse_value() [6/31]

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

◆ parse_value() [7/31]

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

◆ parse_value() [8/31]

template<typename JsonMember , bool KnownBounds, typename ParseState >
constexpr DAW_ONLY_INLINE json_result<JsonMember> DAW_JSON_NS::json_details::parse_value ( ParseTag< JsonParseTypes::Date ,
ParseState &  parse_state 
)
inlineconstexpr

◆ parse_value() [9/31]

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

◆ parse_value() [10/31]

template<typename JsonMember , bool KnownBounds, typename ParseState >
constexpr DAW_ONLY_FLATTEN json_result<JsonMember> DAW_JSON_NS::json_details::parse_value ( ParseTag< JsonParseTypes::KeyValue ,
ParseState &  parse_state 
)
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/31]

template<typename JsonMember , bool KnownBounds = false, typename ParseState >
constexpr json_result<JsonMember> DAW_JSON_NS::json_details::parse_value ( ParseTag< JsonParseTypes::KeyValue ,
ParseState &  parse_state 
)
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/31]

template<typename JsonMember , bool KnownBounds, typename ParseState >
constexpr DAW_ONLY_FLATTEN json_result<JsonMember> DAW_JSON_NS::json_details::parse_value ( ParseTag< JsonParseTypes::KeyValueArray ,
ParseState &  parse_state 
)
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/31]

template<typename JsonMember , bool KnownBounds = false, typename ParseState >
constexpr json_result<JsonMember> DAW_JSON_NS::json_details::parse_value ( ParseTag< JsonParseTypes::KeyValueArray ,
ParseState &  parse_state 
)
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/31]

template<typename JsonMember , bool KnownBounds, typename ParseState >
constexpr DAW_ONLY_INLINE json_result<JsonMember> DAW_JSON_NS::json_details::parse_value ( ParseTag< JsonParseTypes::Null ,
ParseState &  parse_state 
)
inlineconstexpr

◆ parse_value() [15/31]

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

◆ parse_value() [16/31]

template<typename JsonMember , bool KnownBounds, typename ParseState >
constexpr DAW_ONLY_INLINE json_result<JsonMember> DAW_JSON_NS::json_details::parse_value ( ParseTag< JsonParseTypes::Real ,
ParseState &  parse_state 
)
inlineconstexpr

◆ parse_value() [17/31]

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

◆ parse_value() [18/31]

template<typename JsonMember , bool KnownBounds, typename ParseState >
constexpr DAW_ONLY_INLINE json_result<JsonMember> DAW_JSON_NS::json_details::parse_value ( ParseTag< JsonParseTypes::Signed ,
ParseState &  parse_state 
)
inlineconstexpr

◆ parse_value() [19/31]

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

◆ parse_value() [20/31]

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

◆ parse_value() [21/31]

template<typename JsonMember , bool KnownBounds, typename ParseState >
constexpr DAW_ONLY_INLINE json_result<JsonMember> DAW_JSON_NS::json_details::parse_value ( ParseTag< JsonParseTypes::StringRaw ,
ParseState &  parse_state 
)
inlineconstexpr

◆ parse_value() [22/31]

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

◆ parse_value() [23/31]

template<typename JsonMember , bool KnownBounds, typename ParseState >
constexpr DAW_ATTRIBUTE_FLATTEN json_result<JsonMember> DAW_JSON_NS::json_details::parse_value ( ParseTag< JsonParseTypes::Unknown ,
ParseState &  parse_state 
)
constexpr

◆ parse_value() [24/31]

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

◆ parse_value() [25/31]

template<typename JsonMember , bool KnownBounds, typename ParseState >
constexpr DAW_ONLY_INLINE json_result<JsonMember> DAW_JSON_NS::json_details::parse_value ( ParseTag< JsonParseTypes::Unsigned ,
ParseState &  parse_state 
)
inlineconstexpr

◆ parse_value() [26/31]

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

◆ parse_value() [27/31]

template<typename JsonMember , bool , typename ParseState >
constexpr DAW_ONLY_INLINE json_result<JsonMember> DAW_JSON_NS::json_details::parse_value ( ParseTag< JsonParseTypes::Variant ,
ParseState &  parse_state 
)
constexpr

◆ parse_value() [28/31]

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

◆ parse_value() [29/31]

template<typename JsonMember , bool , typename ParseState >
constexpr DAW_ONLY_INLINE json_result<JsonMember> DAW_JSON_NS::json_details::parse_value ( ParseTag< JsonParseTypes::VariantTagged ,
ParseState &  parse_state 
)
inlineconstexpr

◆ parse_value() [30/31]

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

◆ parse_value() [31/31]

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

◆ parse_variant_value()

template<JsonBaseParseTypes BPT, typename JsonMembers , typename ParseState >
constexpr DAW_ONLY_FLATTEN json_result<JsonMembers> DAW_JSON_NS::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_ATTRIBUTE_FLATTEN Result DAW_JSON_NS::json_details::parse_visit ( std::size_t  idx,
ParseState &  parse_state 
)
constexpr

◆ pop_json_path()

constexpr auto DAW_JSON_NS::json_details::pop_json_path ( daw::string_view &  path)
constexpr

◆ power10() [1/2]

template<typename Result , typename Unsigned >
static constexpr DAW_ATTRIBUTE_FLATTEN Result DAW_JSON_NS::json_details::power10 ( constexpr_exec_tag  ,
Result  result,
Unsigned  p 
)
inlinestaticconstexpr

◆ power10() [2/2]

template<typename Result , typename Unsigned >
static constexpr DAW_ATTRIBUTE_FLATTEN Result DAW_JSON_NS::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_NS::json_details::serialize_json_class ( OutputIterator  it,
std::index_sequence< Is... >  ,
Tuple const &  args,
Value const &  value 
)
inlineconstexpr

◆ serialize_ordered_json_class()

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

◆ skip_digits()

template<bool is_unchecked_input>
static constexpr DAW_ATTRIBUTE_FLATTEN char const* DAW_JSON_NS::json_details::skip_digits ( char const *  first,
char const *const  last 
)
inlinestaticconstexpr

◆ skip_false()

template<typename ParseState >
static constexpr ParseState DAW_JSON_NS::json_details::skip_false ( ParseState &  parse_state)
staticconstexpr

◆ skip_known_value()

template<typename JsonMember , typename ParseState >
constexpr DAW_ATTRIBUTE_FLATTEN ParseState DAW_JSON_NS::json_details::skip_known_value ( ParseState &  parse_state)
inlineconstexpr

◆ skip_null()

template<typename ParseState >
static constexpr ParseState DAW_JSON_NS::json_details::skip_null ( ParseState &  parse_state)
staticconstexpr

◆ skip_number()

template<typename ParseState >
static constexpr ParseState DAW_JSON_NS::json_details::skip_number ( ParseState &  parse_state)
staticconstexpr

◆ skip_quote_when_literal_as_string()

template<LiteralAsStringOpt literal_as_string, bool KnownBounds = false, typename ParseState >
constexpr DAW_ONLY_INLINE void DAW_JSON_NS::json_details::skip_quote_when_literal_as_string ( ParseState &  parse_state)
inlineconstexpr

◆ skip_string()

template<typename ParseState >
static constexpr DAW_ATTRIBUTE_FLATTEN ParseState DAW_JSON_NS::json_details::skip_string ( ParseState &  parse_state)
inlinestaticconstexpr

◆ skip_string_nq()

template<typename ParseState >
static constexpr DAW_ATTRIBUTE_FLATTEN ParseState DAW_JSON_NS::json_details::skip_string_nq ( ParseState &  parse_state)
inlinestaticconstexpr

◆ skip_true()

template<typename ParseState >
static constexpr ParseState DAW_JSON_NS::json_details::skip_true ( ParseState &  parse_state)
staticconstexpr

◆ skip_value()

template<typename ParseState >
static constexpr ParseState DAW_JSON_NS::json_details::skip_value ( ParseState &  parse_state)
inlinestaticconstexpr

◆ tags_to_json_str() [1/2]

template<std::size_t , typename JsonMember , typename OutputIterator , typename Value , typename VisitedMembers , std::enable_if_t< not has_tag_member_v< JsonMember >, std::nullptr_t > = nullptr>
constexpr void DAW_JSON_NS::json_details::tags_to_json_str ( bool &  ,
OutputIterator const &  ,
Value const &  ,
VisitedMembers const &   
)
inlineconstexpr

◆ tags_to_json_str() [2/2]

template<std::size_t pos, typename JsonMember , typename OutputIterator , typename Value , typename VisitedMembers , std::enable_if_t< has_tag_member_v< JsonMember >, std::nullptr_t > = nullptr>
constexpr void DAW_JSON_NS::json_details::tags_to_json_str ( bool &  is_first,
OutputIterator  it,
Value const &  v,
VisitedMembers &  visited_members 
)
constexpr

◆ test_map() [1/2]

template<typename... Args>
void DAW_JSON_NS::json_details::test_map ( std::map< Args... > const &  )

◆ test_map() [2/2]

template<typename... Args>
void DAW_JSON_NS::json_details::test_map ( std::unordered_map< Args... > const &  )

◆ to_daw_json_string() [1/17]

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

◆ to_daw_json_string() [2/17]

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

◆ to_daw_json_string() [3/17]

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

◆ to_daw_json_string() [4/17]

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

◆ to_daw_json_string() [5/17]

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

◆ to_daw_json_string() [6/17]

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

◆ to_daw_json_string() [7/17]

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

◆ to_daw_json_string() [8/17]

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

◆ to_daw_json_string() [9/17]

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

◆ to_daw_json_string() [10/17]

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

◆ to_daw_json_string() [11/17]

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

◆ to_daw_json_string() [12/17]

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

◆ to_daw_json_string() [13/17]

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

◆ to_daw_json_string() [14/17]

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

◆ to_daw_json_string() [15/17]

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

◆ to_daw_json_string() [16/17]

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

◆ to_daw_json_string() [17/17]

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

◆ to_json_ordered_str()

template<size_t TupleIdx, typename JsonMember , typename OutputIterator , typename... Args>
constexpr void DAW_JSON_NS::json_details::to_json_ordered_str ( std::size_t &  array_idx,
OutputIterator &  it,
std::tuple< Args... > const &  tp 
)
constexpr

◆ to_json_str()

template<std::size_t pos, typename JsonMember , typename OutputIterator , typename... Args, typename Value , typename Visited >
constexpr void DAW_JSON_NS::json_details::to_json_str ( bool &  is_first,
OutputIterator &  it,
std::tuple< Args... > const &  tp,
Value const &  ,
Visited &  visited_members 
)
inlineconstexpr

◆ to_nibble()

constexpr UInt8 DAW_JSON_NS::json_details::to_nibble ( unsigned char  chr)
inlineconstexpr

◆ to_nibble_char()

template<typename Char >
constexpr char DAW_JSON_NS::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_NS::json_details::to_variant_string ( OutputIterator &  it,
parse_to_t const &  value 
)
constexpr

◆ u32toC()

constexpr char DAW_JSON_NS::json_details::u32toC ( UInt32  value)
constexpr

◆ uneval_func()

template<typename T >
T DAW_JSON_NS::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_NS::json_details::unsigned_parser ( constexpr_exec_tag  ,
ParseState &  parse_state 
)
staticconstexpr

◆ utf32_to_utf8()

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

Variable Documentation

◆ can_defer_construction_v

template<typename Constructor , typename... Members>
constexpr bool DAW_JSON_NS::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_NS::json_details::can_deref_v = can_deref<T>::value
inlineconstexpr

◆ can_random_v

template<bool IsKnown>
constexpr bool DAW_JSON_NS::json_details::can_random_v = IsKnown
inlineconstexpr

◆ default_key_name

constexpr char const DAW_JSON_NS::json_details::default_key_name[] = "key"
inlineconstexpr

◆ default_value_name

constexpr char const DAW_JSON_NS::json_details::default_value_name[] = "value"
inlineconstexpr

◆ digits100

constexpr auto DAW_JSON_NS::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;
}( )

◆ has_basic_type_map_v

template<typename T >
constexpr bool DAW_JSON_NS::json_details::has_basic_type_map_v
inlineconstexpr
Initial value:
=
daw::is_detected_v<::DAW_JSON_NS::json_link_basic_type_map, T>

◆ has_insert_end_v

template<typename Container , typename Value >
constexpr bool DAW_JSON_NS::json_details::has_insert_end_v
inlineconstexpr
Initial value:
=
daw::is_detected_v<detect_insert_end, Container, Value>

◆ has_json_data_contract_trait_v

template<typename T >
constexpr bool DAW_JSON_NS::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_NS::json_details::has_json_link_quick_map_v
inlineconstexpr
Initial value:
=
decltype( json_link_quick_map<no_name, T>( ) )::value

◆ has_json_member_constructor_v

template<typename T >
constexpr bool DAW_JSON_NS::json_details::has_json_member_constructor_v
inlineconstexpr
Initial value:
=
daw::is_detected_v<json_member_constructor_t, T>

◆ has_json_member_parse_to_v

template<typename T >
constexpr bool DAW_JSON_NS::json_details::has_json_member_parse_to_v
inlineconstexpr
Initial value:
=
daw::is_detected_v<json_member_constructor_t, T>

◆ has_json_to_json_data_v

template<typename T >
constexpr bool DAW_JSON_NS::json_details::has_json_to_json_data_v
inlineconstexpr
Initial value:
=
daw::is_detected_v<json_parser_to_json_data_t, T>

◆ has_push_back_v

template<typename Container , typename Value >
constexpr bool DAW_JSON_NS::json_details::has_push_back_v
inlineconstexpr
Initial value:
=
daw::is_detected_v<detect_push_back, Container, Value>

◆ has_tag_member_v

template<typename JsonMember >
constexpr bool DAW_JSON_NS::json_details::has_tag_member_v
inlineconstexpr
Initial value:
=
daw::is_detected_v<tag_member_t, JsonMember>

◆ has_unnamed_default_type_mapping_v

template<typename T >
constexpr bool DAW_JSON_NS::json_details::has_unnamed_default_type_mapping_v
inlineconstexpr
Initial value:
=
has_unnamed_default_type_mapping<T>::value

◆ is_a_json_tagged_variant_v

template<typename T >
constexpr bool DAW_JSON_NS::json_details::is_a_json_tagged_variant_v
inlineconstexpr
Initial value:
=
daw::is_detected_v<is_a_json_tagged_variant_test, T>

◆ is_a_json_type_v

template<typename T >
constexpr bool DAW_JSON_NS::json_details::is_a_json_type_v = daw::is_detected_v<json_type_t, T>
inlineconstexpr

◆ is_allocator_v

template<typename Allocator >
constexpr bool DAW_JSON_NS::json_details::is_allocator_v
inlineconstexpr
Initial value:
=
daw::is_detected_v<has_allocate_test, Allocator>
and daw::is_detected_v<has_deallocate_test, Allocator>

◆ is_an_ordered_member_v

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

◆ is_container_opted_into_json_iostreams_v

template<typename T >
constexpr bool DAW_JSON_NS::json_details::is_container_opted_into_json_iostreams_v
inlineconstexpr
Initial value:
=
daw::is_detected_v<is_container_opted_into_json_iostreams, T>

◆ use_direct_construction_v

template<typename ParsePolicy >
constexpr bool DAW_JSON_NS::json_details::use_direct_construction_v
inlineconstexpr
Initial value:
=
ParsePolicy::exec_tag_t::always_rvo

◆ is_json_nullable_v

template<typename JsonType >
constexpr bool DAW_JSON_NS::json_details::is_json_nullable_v
inlinestaticconstexpr
Initial value:
=
JsonType::expected_type == JsonParseTypes::Null

◆ is_nullable_type

template<typename T >
constexpr bool DAW_JSON_NS::json_details::is_nullable_type
inlineconstexpr
Initial value:
=
daw::is_detected_v<underlying_nullable_type, T>

◆ is_opted_into_json_iostreams_v

template<typename T >
constexpr bool DAW_JSON_NS::json_details::is_opted_into_json_iostreams_v
inlineconstexpr
Initial value:
=
daw::is_detected_v<is_opted_into_json_iostreams, T>

◆ is_submember_tagged_variant_v

template<typename T >
constexpr bool DAW_JSON_NS::json_details::is_submember_tagged_variant_v
inlineconstexpr
Initial value:
=
daw::is_detected_v<is_submember_tagged_variant_t, T>

◆ is_valid_optional_v

template<typename Optional >
constexpr bool DAW_JSON_NS::json_details::is_valid_optional_v
inlineconstexpr
Initial value:
=
daw::is_detected_v<deref_t, Optional>

◆ json_class_constructor

template<typename T >
constexpr auto DAW_JSON_NS::json_details::json_class_constructor = json_class_constructor_t<T>{ }
inlineconstexpr

◆ key_table

template<char... keys>
constexpr key_table_t DAW_JSON_NS::json_details::key_table
inlinestaticconstexpr
Initial value:
= [] {
auto result = key_table_t{ };
(void)( ( result.values[static_cast<unsigned char>( keys )] = true ) |
... );
return result;
}( )

◆ must_verify_end_of_data_is_valid_v

template<typename ParsePolicy >
constexpr bool DAW_JSON_NS::json_details::must_verify_end_of_data_is_valid_v
inlineconstexpr
Initial value:
=
daw::is_detected_v<must_verify_end_of_data_is_valid_t, ParsePolicy>

If the parse policy has a type alias must_verify_end_of_data_is_valid this trait is true. This is used to ensure that after the JSON value is parse that only whitespace or nothing follows.

◆ number_parse_type_impl_v

template<typename T >
constexpr JsonParseTypes DAW_JSON_NS::json_details::number_parse_type_impl_v
inlineconstexpr
Initial value:
= [] {
static_assert( daw::is_arithmetic_v<T>, "Unexpected non-number" );
if constexpr( daw::is_floating_point_v<T> ) {
return JsonParseTypes::Real;
} else if constexpr( daw::is_signed_v<T> ) {
return JsonParseTypes::Signed;
} else if constexpr( daw::is_unsigned_v<T> ) {
return JsonParseTypes::Unsigned;
}
}( )

◆ number_parse_type_v

template<typename T >
constexpr JsonParseTypes DAW_JSON_NS::json_details::number_parse_type_v = number_parse_type_test<T>( )
inlineconstexpr

◆ parse_space_needed_v

template<typename >
constexpr std::size_t DAW_JSON_NS::json_details::parse_space_needed_v = 1U
inlineconstexpr

◆ parse_space_needed_v< simd_exec_tag >

template<>
constexpr std::size_t DAW_JSON_NS::json_details::parse_space_needed_v< simd_exec_tag > = 16U
inlineconstexpr