DAW JSON Link
daw_json_link_types.h
Go to the documentation of this file.
1 // Copyright (c) Darrell Wright
2 //
3 // Distributed under the Boost Software License, version 1.0. (see accompanying
4 // file LICENSE or copy at http://www.boost.org/LICENSE_1_0.txt)
5 //
6 // Official repository: https://github.com/beached/daw_json_link
7 //
8 
9 #pragma once
10 
12 #include "impl/daw_json_traits.h"
13 #include "impl/version.h"
14 
15 #include <daw/daw_attributes.h>
16 #include <daw/daw_string_view.h>
17 #include <daw/daw_traits.h>
18 #include <daw/daw_visit.h>
19 
20 #include <cstddef>
21 #include <string_view>
22 #include <tuple>
23 #include <type_traits>
24 
25 namespace daw::json {
26  inline namespace DAW_JSON_VER {
32  template<typename... JsonMembers>
35  static_assert(
36  std::conjunction_v<json_details::is_a_json_type<JsonMembers>...>,
37  "Only JSON Link mapping types can appear in a "
38  "json_member_list(e.g. json_number, json_string...)" );
39 
40  static_assert(
41  not std::disjunction_v<json_details::is_no_name<JsonMembers>...>,
42  "All members must have a name and not no_name in a "
43  "json_member_list" );
54  template<typename OutputIterator, typename Value,
55  template<class...> class Tuple, typename... Ts>
56  [[maybe_unused, nodiscard]] static inline constexpr OutputIterator
57  serialize( OutputIterator it, Tuple<Ts...> const &args, Value const &v ) {
58  static_assert(
59  sizeof...( Ts ) == sizeof...( JsonMembers ),
60  "The method to_json_data in the json_data_contract does not match "
61  "the mapping. The number of members is not the same." );
62  static_assert(
63  ( (not std::is_rvalue_reference_v<Ts>)and... ),
64  "The Tuple contains rvalue references. The values "
65  "passed are now dangling. daw::forward_nonrvalue_as_tuple in "
66  "<daw/daw_tuple_forward.h> can forward only non-rvalue refs and "
67  "store the temporaries" );
68  return json_details::serialize_json_class<JsonMembers...>(
69  it, args, v, std::index_sequence_for<Ts...>{ } );
70  }
71 
72  template<typename Constructor>
73  using result_type =
74  json_details::json_class_parse_result_t<Constructor, JsonMembers...>;
84  template<typename JsonClass, typename ParseState>
85  [[maybe_unused,
86  nodiscard]] DAW_ATTRIB_FLATTEN static inline constexpr json_details::
87  json_result<JsonClass>
88  parse_to_class( ParseState &parse_state, template_param<JsonClass> ) {
89  static_assert( json_details::is_no_name_v<JsonClass> );
90  static_assert( json_details::is_a_json_type_v<JsonClass> );
92  typename JsonClass::base_type>,
93  "Unexpected type" );
94  return json_details::parse_json_class<JsonClass, JsonMembers...>(
95  parse_state, std::index_sequence_for<JsonMembers...>{ } );
96  }
97  };
98 
99  template<typename JsonMember>
100  struct json_class_map {
102  using i_am_a_json_map_alias = void;
104  static_assert( json_details::is_a_json_type_v<json_member>,
105  "Only JSON Link mapping types can appear in a "
106  "json_class_map(e.g. json_number, json_string...)" );
107 
108  static_assert(
109  json_details::is_no_name_v<json_member>,
110  "The JSONMember cannot be named, it does not make sense in "
111  "this context" );
112 
113  template<typename OutputIterator, typename Member, typename Value>
114  [[maybe_unused, nodiscard]] static inline constexpr OutputIterator
115  serialize( OutputIterator it, Member const &m, Value const & ) {
116  return json_details::member_to_string( template_arg<json_member>, it,
117  m );
118  }
119 
120  template<typename Constructor>
121  using result_type =
123 
124  template<typename JsonClass, typename ParseState>
125  [[maybe_unused,
126  nodiscard]] DAW_ATTRIB_FLATTEN static constexpr json_details::
127  json_result<JsonClass>
128  parse_to_class( ParseState &parse_state, template_param<JsonClass> ) {
129  static_assert( json_details::is_a_json_type_v<JsonClass> );
131  typename JsonClass::base_type>,
132  "Unexpected type" );
133  // Using construct_value here as the result of aliased type is used to
134  // construct our result and the Constructor maybe different. This
135  // happens with BigInt and string.
136  using Constructor = typename JsonClass::constructor_t;
138  template_args<JsonClass, Constructor>, parse_state,
139  json_details::parse_value<json_member, false>(
141  }
142  };
143 
144  /***
145  *
146  * Allows specifying an unnamed json mapping where the
147  * result is a tuple
148  */
149  template<typename... Members>
151  std::tuple<typename Members::parse_to_t...> members;
152 
153  template<typename... Ts>
154  explicit constexpr tuple_json_mapping( Ts &&...values )
155  : members{ DAW_FWD2( Ts, values )... } {}
156  };
157 
158  template<typename... Members>
160  using type = json_member_list<Members...>;
161 
162  [[nodiscard, maybe_unused]] static inline auto const &
164  return value.members;
165  }
166  };
167 
168  /***
169  * In a json_ordered_member_list, this allows specifying the position in the
170  * array to parse this member from
171  * @tparam Index Position in array where member is
172  * @tparam JsonMember type of value( e.g. int, json_string )
173  */
174  template<std::size_t Index, typename JsonMember>
177  using i_am_a_json_type = void;
178  static constexpr std::size_t member_index = Index;
179  static_assert(
181  "Missing specialization of daw::json::json_data_contract for class "
182  "mapping or specialization of daw::json::json_link_basic_type_map" );
184  using parse_to_t = typename json_member::parse_to_t;
185  };
186 
187  namespace json_details {
188  template<typename JsonMember>
190  std::conditional_t<is_an_ordered_member_v<JsonMember>, JsonMember,
192  } // namespace json_details
193 
194  /***
195  * Allow extracting elements from a JSON array and constructing from it.
196  * Members can be either normal C++ no_name members, or an ordered_member
197  * with a position. All ordered members must have a value greater than the
198  * previous. The first element in the list, unless it is specified as an
199  * ordered_member, is 0. A non-ordered_member item will be 1 more than the
200  * previous item in the list. All items must have an index greater than the
201  * previous. In Javascript these are also called tuples.
202  * @tparam JsonMembers A list of json_TYPE mappings or a json_TYPE mapping
203  * wrapped into a ordered_json_member
204  */
205  template<typename... JsonMembers>
209 
218  template<typename OutputIterator, typename Value,
219  template<class...> class Tuple, typename... Ts>
220  [[maybe_unused, nodiscard]] static inline constexpr OutputIterator
221  serialize( OutputIterator it, Tuple<Ts...> const &args, Value const &v ) {
222  static_assert( sizeof...( Ts ) == sizeof...( JsonMembers ),
223  "Argument count is incorrect" );
224  static_assert(
225  ( (not std::is_rvalue_reference_v<Ts>)and... ),
226  "The Tuple contains rvalue references. The values "
227  "passed are now dangling. daw::forward_nonrvalue_as_tuple in "
228  "<daw/daw_tuple_forward.h> can forward only non-rvalue refs and "
229  "store the temporaries" );
230  static_assert(
231  std::conjunction<json_details::is_a_json_type<
233  "Only value JSON types can be used" );
236  it, args, v, std::index_sequence_for<Ts...>{ } );
237  }
238 
239  template<typename Constructor>
252  template<typename JsonClass, typename ParseState>
253  [[maybe_unused,
254  nodiscard]] static inline constexpr json_details::json_result<JsonClass>
255  parse_to_class( ParseState &parse_state, template_param<JsonClass> ) {
258  typename JsonClass::base_type>,
259  "Unexpected type" );
260 
262  template_args<JsonClass,
264  parse_state );
265  }
266  };
267 
268  /***
269  * Parse a tagged variant like class where the tag member is in the same
270  * class that is being discriminated. The container type, that will
271  * specialize json_data_construct on, must support the get_if, get_index
272  * @tparam TagMember JSON element to pass to Switcher. Does not have to be
273  * declared in member list
274  * @tparam Switcher A callable that returns an index into JsonClasses when
275  * passed the TagMember object
276  * @tparam JsonClasses List of alternative classes that are mapped via a
277  * json_data_contract
278  */
279  template<typename TagMember, typename Switcher, typename... JsonClasses>
283 
290  template<typename OutputIterator, typename Value>
291  [[maybe_unused, nodiscard]] static inline constexpr OutputIterator
292  serialize( OutputIterator it, Value const &v ) {
293 
294  return daw::visit_nt( v, [&]( auto const &alternative ) {
295  using Alternative = daw::remove_cvref_t<decltype( alternative )>;
296  static_assert(
297  std::disjunction_v<std::is_same<Alternative, JsonClasses>...>,
298  "Unexpected alternative type" );
299  static_assert( json_details::has_json_to_json_data_v<Alternative>,
300  "Alternative type does not have a to_json_data_member "
301  "in it's json_data_contract specialization" );
302 
304  template_arg<json_base::json_class<Alternative>>, it, alternative );
305  } );
306  }
307 
308  template<typename Constructor>
310  Constructor, json_details::json_deduced_type<
311  daw::traits::first_type<JsonClasses...>>>;
321  template<typename JsonClass, typename ParseState>
322  [[maybe_unused, nodiscard]] static inline constexpr json_details::
323  from_json_result_t<JsonClass>
324  parse_to_class( ParseState &parse_state, template_param<JsonClass> ) {
327  typename JsonClass::base_type>,
328  "Unexpected type" );
329  using tag_class_t = tuple_json_mapping<TagMember>;
330 
331  std::size_t const idx = [parse_state]( ) mutable {
332  return Switcher{ }( std::get<0>(
335  .members ) );
336  }( );
337  daw_json_assert_weak( idx < sizeof...( JsonClasses ),
338  ErrorReason::UnexpectedJSONVariantType );
340  0, JsonClass, false, json_base::json_class<JsonClasses>...>(
341  idx, parse_state );
342  }
343  };
344 
345  /**************************************************
346  * Member types - These are the mapping classes to
347  * describe the constructor of your classes
348  **************************************************/
349 
350  namespace json_base {
351  template<typename T, json_details::json_options_t Options,
352  typename Constructor>
353  struct json_number {
354  using i_am_a_json_type = void;
355  using wrapped_type = T;
356  static constexpr daw::string_view name = no_name;
357  static constexpr bool must_be_class_member = false;
358 
359  static constexpr JsonNullable nullable =
360  json_details::get_bits_for<JsonNullable>( number_opts, Options );
362  static_assert( traits::not_same<void, base_type>::value,
363  "Failed to detect base type" );
364 
365  static_assert( daw::is_arithmetic<base_type>::value,
366  "json_number requires an arithmetic type" );
367 
369  nullable != JsonNullable::MustExist, Constructor, base_type>::type;
370 
371  static_assert(
372  std::disjunction_v<
374  typename std::is_invocable_r<parse_to_t, Constructor>::type>,
375  "Default ctor of constructor must match that of base" );
376  using constructor_t = Constructor;
377 
378  static constexpr JsonParseTypes expected_type =
379  get_parse_type_v<json_details::number_parse_type_v<base_type>,
380  nullable>;
381 
383  json_details::number_parse_type_v<base_type>;
384 
386  json_details::get_bits_for<LiteralAsStringOpt>( number_opts,
387  Options );
388 
389  static constexpr JsonRangeCheck range_check =
390  json_details::get_bits_for<JsonRangeCheck>( number_opts, Options );
391 
394 
395  template<JSONNAMETYPE NewName>
396  using with_name =
399  };
400 
401  } // namespace json_base
402 
412  template<JSONNAMETYPE Name, typename T,
413  json_details::json_options_t Options, typename Constructor>
414  struct json_number : json_base::json_number<T, Options, Constructor> {
415 
416  static constexpr daw::string_view name = Name;
417 #if not defined( DAW_JSON_NO_FAIL_ON_NO_NAME_NAME )
418  static_assert( name != no_name,
419  "For no_name mappings, use the json_number_no_name "
420  "variant without a name argument" );
421 #endif
422 
423  template<JSONNAMETYPE NewName>
426  };
427 
428  template<typename T = double,
430  typename Constructor = default_constructor<T>>
431  using json_number_no_name = json_base::json_number<T, Options, Constructor>;
432 
433  template<typename T = std::optional<double>,
434  json_details::json_options_t Options = number_opts_def,
435  typename Constructor = nullable_constructor<T>>
436  using json_number_null_no_name = json_base::json_number<
437  T, json_details::number_opts_set<Options, JsonNullDefault>, Constructor>;
438 
447  template<typename T = double,
449  typename Constructor = default_constructor<T>>
450  using json_checked_number_no_name = json_base::json_number<
451  T,
452  json_details::number_opts_set<Options, JsonRangeCheck::CheckForNarrowing>,
453  Constructor>;
454 
463  template<typename T = std::optional<double>,
464  json_details::json_options_t Options = number_opts_def,
465  typename Constructor = nullable_constructor<T>>
466  using json_checked_number_null_no_name = json_base::json_number<
467  T,
470  Constructor>;
471 
472  namespace json_base {
473  template<typename T, json_details::json_options_t Options,
474  typename Constructor>
475  struct json_bool {
476  using i_am_a_json_type = void;
477  static constexpr daw::string_view name = no_name;
478  static constexpr JsonNullable nullable =
479  json_details::get_bits_for<JsonNullable>( bool_opts, Options );
480  static constexpr bool must_be_class_member = false;
481  using wrapped_type = T;
483  static_assert( traits::not_same<void, base_type>::value,
484  "Failed to detect base type" );
485 
487  nullable != JsonNullable::MustExist, Constructor, base_type>::type;
488 
489  using constructor_t = Constructor;
490 
491  static constexpr JsonParseTypes expected_type =
492  get_parse_type_v<JsonParseTypes::Bool, nullable>;
495 
497  json_details::get_bits_for<LiteralAsStringOpt>( bool_opts, Options );
498 
501 
502  template<JSONNAMETYPE NewName>
503  using with_name =
506  };
507  } // namespace json_base
508 
516  template<JSONNAMETYPE Name, typename T,
517  json_details::json_options_t Options, typename Constructor>
518  struct json_bool : json_base::json_bool<T, Options, Constructor> {
519 
520  static constexpr daw::string_view name = Name;
521 #if not defined( DAW_JSON_NO_FAIL_ON_NO_NAME_NAME )
522  static_assert( name != no_name,
523  "For no_name mappings, use the json_bool_no_name variant "
524  "without a name argument" );
525 #endif
526 
527  template<JSONNAMETYPE NewName>
530  };
531 
532  template<typename T = bool,
534  typename Constructor = default_constructor<T>>
535  using json_bool_no_name = json_base::json_bool<T, Options, Constructor>;
536 
537  template<typename T = std::optional<bool>,
538  json_details::json_options_t Options = bool_opts_def,
539  typename Constructor = nullable_constructor<T>>
540  using json_bool_null_no_name = json_base::json_bool<
541  T, json_details::bool_opts_set<Options, JsonNullDefault>, Constructor>;
542 
543  namespace json_base {
544  template<typename String, json_details::json_options_t Options,
545  typename Constructor>
547  using i_am_a_json_type = void;
548  static constexpr JsonNullable nullable =
549  json_details::get_bits_for<JsonNullable>( string_raw_opts, Options );
550  static constexpr bool must_be_class_member = false;
551  using constructor_t = Constructor;
554  static_assert( traits::not_same<void, base_type>::value,
555  "Failed to detect base type" );
556 
558  nullable != JsonNullable::MustExist, Constructor, base_type>::type;
559 
560  static constexpr daw::string_view name = no_name;
561  static constexpr JsonParseTypes expected_type =
562  get_parse_type_v<JsonParseTypes::StringRaw, nullable>;
567 
568  static constexpr EmptyStringNull empty_is_null =
569  json_details::get_bits_for<EmptyStringNull>( string_raw_opts,
570  Options );
571  static constexpr EightBitModes eight_bit_mode =
572  json_details::get_bits_for<EightBitModes>( string_raw_opts, Options );
573 
575  json_details::get_bits_for<AllowEscapeCharacter>( string_raw_opts,
576  Options );
577 
578  template<JSONNAMETYPE NewName>
579  using with_name =
582  };
583  } // namespace json_base
584 
600  template<JSONNAMETYPE Name, typename String,
601  json_details::json_options_t Options, typename Constructor>
603  : json_base::json_string_raw<String, Options, Constructor> {
604  using i_am_a_json_type = void;
605 
606  static constexpr daw::string_view name = Name;
607 #if not defined( DAW_JSON_NO_FAIL_ON_NO_NAME_NAME )
608  static_assert( name != no_name,
609  "For no_name mappings, use the json_string_raw_no_name "
610  "variant without a name argument" );
611 #endif
612 
613  template<JSONNAMETYPE NewName>
615  using without_name =
617  };
618 
619  template<typename T = std::string,
621  typename Constructor = default_constructor<T>>
623  json_base::json_string_raw<T, Options, Constructor>;
624 
625  template<typename T = std::optional<std::string>,
626  json_details::json_options_t Options = string_raw_opts_def,
627  typename Constructor = nullable_constructor<T>>
628  using json_string_raw_null_no_name = json_base::json_string_raw<
629  T, json_details::string_raw_opts_set<Options, JsonNullDefault>,
630  Constructor>;
631 
632  namespace json_base {
633  template<typename String, json_details::json_options_t Options,
634  typename Constructor>
635  struct json_string {
636  using i_am_a_json_type = void;
637  static constexpr JsonNullable nullable =
638  json_details::get_bits_for<JsonNullable>( string_opts, Options );
639  static constexpr bool must_be_class_member = false;
640  using constructor_t = Constructor;
643  static_assert( traits::not_same<void, base_type>::value,
644  "Failed to detect base type" );
645 
647  nullable != JsonNullable::MustExist, Constructor, char const *,
648  char const *>::type;
649 
650  static constexpr daw::string_view name = no_name;
651  static constexpr JsonParseTypes expected_type =
652  get_parse_type_v<JsonParseTypes::StringEscaped, nullable>;
655  static constexpr EmptyStringNull empty_is_null =
656  json_details::get_bits_for<EmptyStringNull>( string_opts, Options );
657  static constexpr EightBitModes eight_bit_mode =
658  json_details::get_bits_for<EightBitModes>( string_opts, Options );
659 
662 
663  template<JSONNAMETYPE NewName>
664  using with_name =
667  };
668  } // namespace json_base
669 
683  template<JSONNAMETYPE Name, typename String,
684  json_details::json_options_t Options, typename Constructor>
685  struct json_string : json_base::json_string<String, Options, Constructor> {
686  static constexpr daw::string_view name = Name;
687 #if not defined( DAW_JSON_NO_FAIL_ON_NO_NAME_NAME )
688  static_assert( name != no_name,
689  "For no_name mappings, use the json_string_no_name "
690  "variant of mapping type" );
691 #endif
692 
693  template<JSONNAMETYPE NewName>
695 
697  };
698 
699  template<typename T = std::string,
701  typename Constructor = default_constructor<T>>
702  using json_string_no_name = json_base::json_string<T, Options, Constructor>;
703 
704  template<typename T = std::optional<std::string>,
705  json_details::json_options_t Options = string_opts_def,
706  typename Constructor = nullable_constructor<T>>
707  using json_string_null_no_name = json_base::json_string<
708  T, json_details::string_opts_set<Options, JsonNullDefault>, Constructor>;
709 
710  namespace json_base {
711  template<typename T, typename Constructor, JsonNullable Nullable>
712  struct json_date {
713  using i_am_a_json_type = void;
714  using constructor_t = Constructor;
715  using wrapped_type = T;
716  static constexpr bool must_be_class_member = false;
718  static_assert( traits::not_same<void, base_type>::value,
719  "Failed to detect base type" );
720 
722  Nullable != JsonNullable::MustExist, Constructor, char const *,
723  std::size_t>::type;
724 
725  static constexpr daw::string_view name = no_name;
726  static constexpr JsonParseTypes expected_type =
727  get_parse_type_v<JsonParseTypes::Date, Nullable>;
732  static constexpr JsonNullable nullable = Nullable;
733 
734  template<JSONNAMETYPE NewName>
735  using with_name =
738  };
739  } // namespace json_base
740 
748  template<JSONNAMETYPE Name, typename T, typename Constructor,
750  struct json_date : json_base::json_date<T, Constructor, Nullable> {
751  static constexpr daw::string_view name = Name;
752 #if not defined( DAW_JSON_NO_FAIL_ON_NO_NAME_NAME )
753  static_assert( name != no_name,
754  "For no_name mappings, use the json_date_no_name variant "
755  "without a name argument" );
756 #endif
757 
758  template<JSONNAMETYPE NewName>
760 
762  };
763 
764  template<typename T, typename Constructor = default_constructor<T>,
765  JsonNullable Nullable = JsonNullable::MustExist>
766  using json_date_no_name = json_base::json_date<T, Constructor, Nullable>;
767 
768  template<typename T, typename Constructor = nullable_constructor<T>>
770  json_base::json_date<T, Constructor, JsonNullDefault>;
771 
772  namespace json_base {
773  template<typename T, typename Constructor,
775  struct json_class {
776  using i_am_a_json_type = void;
777  static constexpr daw::string_view name = no_name;
778  using wrapped_type = T;
779  static constexpr bool must_be_class_member = false;
780  static constexpr JsonNullable nullable =
781  json_details::get_bits_for<JsonNullable>( class_opts, Options );
785 
786  static_assert( traits::not_same<void, base_type>::value,
787  "Failed to detect base type" );
788 
790 
791  using parse_to_t = typename std::conditional_t<
793  daw::traits::identity<base_type>,
794  daw::traits::identity<
795  typename data_contract::template result_type<constructor_t>>>::type;
796 
797  static constexpr JsonParseTypes expected_type =
798  get_parse_type_v<JsonParseTypes::Class, nullable>;
803 
804  template<JSONNAMETYPE NewName>
805  using with_name =
808  };
809  } // namespace json_base
810 
820  template<JSONNAMETYPE Name, typename T, typename Constructor,
822  struct json_class : json_base::json_class<T, Constructor, Options> {
823 
824  static constexpr daw::string_view name = Name;
825 #if not defined( DAW_JSON_NO_FAIL_ON_NO_NAME_NAME )
826  static_assert( name != no_name,
827  "For no_name mappings, use the json_class_no_name variant "
828  "without a name argument" );
829 #endif
830  template<JSONNAMETYPE NewName>
832 
834  };
835 
836  template<typename T, typename Constructor = default_constructor<T>,
837  json_details::json_options_t Options = class_opts_def>
838  using json_class_no_name = json_base::json_class<T, Constructor, Options>;
839 
840  template<typename T, typename Constructor = nullable_constructor<T>,
841  json_details::json_options_t Options = class_opts_def>
842  using json_class_null_no_name = json_base::json_class<
843  T, Constructor, json_details::class_opts_set<Options, JsonNullDefault>>;
844 
845  /***
846  * A type to hold the types for parsing variants.
847  * @tparam JsonElements Up to one of a JsonElement that is a JSON number,
848  * string, object, or array
849  */
850  template<typename... JsonElements>
852  [[deprecated( "Use json_variant_type list, removal in v4" )]] =
853  json_variant_type_list<JsonElements...>;
854 
855  template<typename>
857 
862  template<typename... JsonElements>
864  json_variant_type_list<JsonElements...>> {
865  static_assert(
866  sizeof...( JsonElements ) <= 5U,
867  "There can be at most 5 items, one for each JsonBaseParseTypes" );
868 
869  static_assert(
870  std::conjunction<
872  "Missing specialization of daw::json::json_data_contract for class "
873  "mapping or specialization of daw::json::json_link_basic_type_map" );
874 
875  static constexpr std::size_t base_map[5] = {
876  json_details::find_json_element<JsonBaseParseTypes::Number>(
878  JsonElements>::underlying_json_type... } ),
879  json_details::find_json_element<JsonBaseParseTypes::Bool>(
881  JsonElements>::underlying_json_type... } ),
882  json_details::find_json_element<JsonBaseParseTypes::String>(
884  JsonElements>::underlying_json_type... } ),
885  json_details::find_json_element<JsonBaseParseTypes::Class>(
887  JsonElements>::underlying_json_type... } ),
888  json_details::find_json_element<JsonBaseParseTypes::Array>(
890  JsonElements>::underlying_json_type... } ) };
891  };
892 
893  namespace json_base {
894  template<typename T, typename JsonElements, typename Constructor,
895  JsonNullable Nullable>
896  struct json_variant {
897  using i_am_a_json_type = void;
898  static constexpr bool must_be_class_member = false;
899  static_assert(
900  std::is_same<typename JsonElements::i_am_variant_type_list,
901  void>::value,
902  "Expected a json_variant_type_list" );
903  using wrapped_type = T;
907  static_assert( traits::not_same<void, base_type>::value,
908  "Failed to detect base type" );
909  using parse_to_t = T;
910  static constexpr daw::string_view name = no_name;
911  static constexpr JsonParseTypes expected_type =
912  get_parse_type_v<JsonParseTypes::Variant, Nullable>;
915 
918  using json_elements = JsonElements;
920  static constexpr JsonNullable nullable = Nullable;
921 
922  template<JSONNAMETYPE NewName>
923  using with_name = daw::json::json_variant<NewName, T, JsonElements,
924  Constructor, Nullable>;
926  };
927  } // namespace json_base
928 
929  /***
930  * Link to a nullable JSON variant
931  * @tparam Name name of JSON member to link to
932  * @tparam T type that has specialization of
933  * daw::json::json_data_contract
934  * @tparam JsonElements a json_variant_type_list
935  * @tparam Constructor A callable used to construct T. The
936  * default supports normal and aggregate construction
937  */
938  template<JSONNAMETYPE Name, typename T, typename JsonElements,
939  typename Constructor, JsonNullable Nullable>
941  : json_base::json_variant<T, JsonElements, Constructor, Nullable> {
942  static constexpr daw::string_view name = Name;
943 #if not defined( DAW_JSON_NO_FAIL_ON_NO_NAME_NAME )
944  static_assert( name != no_name,
945  "For no_name mappings, use the json_variant_no_name "
946  "variant without a name argument" );
947 #endif
948  template<JSONNAMETYPE NewName>
949  using with_name =
951 
952  using without_name =
954  };
955 
956  template<typename T, typename JsonElements,
957  typename Constructor = default_constructor<T>,
960  json_base::json_variant<T, JsonElements, Constructor,
962 
963  template<typename T, typename JsonElements,
964  typename Constructor = nullable_constructor<T>>
966  json_base::json_variant<T, JsonElements, Constructor, JsonNullDefault>;
967 
968  namespace json_base {
969  template<typename T, typename TagMember, typename Switcher,
970  typename JsonElements, typename Constructor,
971  JsonNullable Nullable>
973  using i_am_a_json_type = void;
974  using i_am_a_tagged_variant = void;
975  static constexpr JsonNullable nullable = Nullable;
976  static constexpr bool must_be_class_member = true;
977  static_assert(
978  std::is_same<typename JsonElements::i_am_variant_type_list,
979  void>::value,
980  "Expected a json_member_list" );
981 
982  using wrapped_type = T;
983 
984  static_assert( json_details::is_a_json_type_v<TagMember>,
985  "The TagMember type must have a name and be a "
986  "member of the same object as this" );
988  nullable, TagMember::nullable>,
989  "The TagMember nullability mullable type" );
990  using dependent_member = TagMember;
991 
992  using switcher = Switcher;
996  static_assert( traits::not_same<void, base_type>::value,
997  "Failed to detect base type" );
998  using parse_to_t = T;
999  static constexpr daw::string_view name = no_name;
1000  static constexpr JsonParseTypes expected_type =
1001  get_parse_type_v<JsonParseTypes::VariantTagged, Nullable>;
1006  using json_elements = JsonElements;
1007 
1008  template<JSONNAMETYPE NewName>
1009  using with_name =
1010  daw::json::json_tagged_variant<NewName, T, TagMember, Switcher,
1011  JsonElements, Constructor, Nullable>;
1013  };
1014  } // namespace json_base
1015 
1016  /***
1017  * Link to a nullable variant like data type that is discriminated via
1018  * another member.
1019  * @tparam Name name of JSON member to link to
1020  * @tparam T type of value to construct
1021  * @tparam TagMember JSON element to pass to Switcher. Does not have to be
1022  * declared in member list
1023  * @tparam Switcher A callable that returns an index into JsonElements when
1024  * passed the TagMember object in parent member list
1025  * @tparam JsonElements a json_tagged_variant_type_list, defaults to type
1026  * elements of T when T is a std::variant and they are all auto mappable
1027  * @tparam Constructor A callable used to construct T. The
1028  * default supports normal and aggregate construction
1029  */
1030  template<JSONNAMETYPE Name, typename T, typename TagMember,
1031  typename Switcher, typename JsonElements, typename Constructor,
1034  : json_base::json_tagged_variant<T, TagMember, Switcher, JsonElements,
1035  Constructor, Nullable> {
1036 
1037  static constexpr daw::string_view name = Name;
1038 #if not defined( DAW_JSON_NO_FAIL_ON_NO_NAME_NAME )
1039  static_assert(
1040  name != no_name,
1041  "For no_name mappings, use the json_tagged_variant_no_name variant "
1042  "without a name argument" );
1043 #endif
1044 
1045  template<JSONNAMETYPE NewName>
1046  using with_name =
1047  json_tagged_variant<NewName, T, TagMember, Switcher, JsonElements,
1048  Constructor, Nullable>;
1049 
1051  json_base::json_tagged_variant<T, TagMember, Switcher, JsonElements,
1052  Constructor, Nullable>;
1053  };
1054 
1055  template<typename T, typename TagMember, typename Switcher,
1056  typename JsonElements = json_details::
1057  determine_variant_element_types<JsonNullable::MustExist, T>,
1058  typename Constructor = default_constructor<T>,
1061  json_base::json_tagged_variant<T, TagMember, Switcher, JsonElements,
1062  Constructor, Nullable>;
1063 
1064  template<typename T, typename TagMember, typename Switcher,
1065  typename JsonElements = json_details::
1066  determine_variant_element_types<JsonNullable::MustExist, T>,
1067  typename Constructor = default_constructor<T>>
1069  json_base::json_tagged_variant<T, TagMember, Switcher, JsonElements,
1070  Constructor, JsonNullDefault>;
1071 
1072  namespace json_base {
1073  template<typename T, typename FromJsonConverter, typename ToJsonConverter,
1075  struct json_custom {
1076  using i_am_a_json_type = void;
1077  using to_converter_t = ToJsonConverter;
1078  using from_converter_t = FromJsonConverter;
1079  using constructor_t = FromJsonConverter;
1080  static constexpr bool must_be_class_member = false;
1081 
1082  static constexpr JsonNullable nullable =
1083  json_details::get_bits_for<JsonNullable>( json_custom_opts, Options );
1084 
1086  static_assert( traits::not_same<void, base_type>::value,
1087  "Failed to detect base type" );
1088 
1090  nullable != JsonNullable::MustExist, FromJsonConverter,
1091  std::string_view>::type;
1092 
1093  static_assert(
1094  std::is_invocable_v<ToJsonConverter, parse_to_t> or
1095  std::is_invocable_r<char *, ToJsonConverter, char *,
1096  parse_to_t>::value,
1097  "ToConverter must be callable with T or T and and OutputIterator" );
1098  static constexpr daw::string_view name = no_name;
1099  static constexpr JsonParseTypes expected_type =
1100  get_parse_type_v<JsonParseTypes::Custom, nullable>;
1103 
1105  json_details::get_bits_for<JsonCustomTypes>( json_custom_opts,
1106  Options );
1107 
1110 
1111  template<JSONNAMETYPE NewName>
1112  using with_name = daw::json::json_custom<NewName, T, FromJsonConverter,
1113  ToJsonConverter, Options>;
1115  };
1116  } // namespace json_base
1117 
1127  template<JSONNAMETYPE Name, typename T, typename FromJsonConverter,
1128  typename ToJsonConverter, json_details::json_options_t Options>
1130  : json_base::json_custom<T, FromJsonConverter, ToJsonConverter, Options> {
1131 
1132  static constexpr daw::string_view name = Name;
1133 #if not defined( DAW_JSON_NO_FAIL_ON_NO_NAME_NAME )
1134  static_assert( name != no_name,
1135  "For no_name mappings, use the json_custom_no_name "
1136  "variant without a name argument" );
1137 #endif
1138 
1139  template<JSONNAMETYPE NewName>
1140  using with_name =
1142 
1145  };
1146 
1147  template<typename T,
1148  typename FromJsonConverter = default_from_json_converter_t<T>,
1149  typename ToJsonConverter = default_to_json_converter_t<T>,
1152  json_base::json_custom<T, FromJsonConverter, ToJsonConverter, Options>;
1153 
1154  template<typename T,
1155  typename FromJsonConverter = default_from_json_converter_t<T>,
1156  typename ToJsonConverter = default_to_json_converter_t<T>,
1158  using json_custom_lit_no_name = json_base::json_custom<
1159  T, FromJsonConverter, ToJsonConverter,
1160  json_details::json_custom_opts_set<Options, JsonCustomTypes::Literal>>;
1161 
1162  template<typename T,
1163  typename FromJsonConverter = default_from_json_converter_t<T>,
1164  typename ToJsonConverter = default_to_json_converter_t<T>,
1166  using json_custom_null_no_name = json_base::json_custom<
1167  T, FromJsonConverter, ToJsonConverter,
1168  json_details::json_custom_opts_set<Options, JsonNullDefault>>;
1169 
1170  template<typename T,
1171  typename FromJsonConverter = default_from_json_converter_t<T>,
1172  typename ToJsonConverter = default_to_json_converter_t<T>,
1174  using json_custom_lit_null_no_name = json_base::json_custom<
1175  T, FromJsonConverter, ToJsonConverter,
1177  JsonNullDefault>>;
1178 
1179  namespace json_base {
1180  template<typename JsonElement, typename Container, typename Constructor,
1181  JsonNullable Nullable>
1182  struct json_array {
1183  using i_am_a_json_type = void;
1184  static constexpr bool must_be_class_member = false;
1185  static_assert(
1186  json_details::has_unnamed_default_type_mapping_v<JsonElement>,
1187  "Missing specialization of daw::json::json_data_contract for class "
1188  "mapping or specialization of daw::json::json_link_basic_type_map" );
1190  using json_element_parse_to_t = typename json_element_t::parse_to_t;
1191 
1192  static_assert( traits::not_same_v<json_element_t, void>,
1193  "Unknown JsonElement type." );
1194  static_assert( json_details::is_a_json_type_v<json_element_t>,
1195  "Error determining element type" );
1196  using constructor_t = Constructor;
1197 
1199  static_assert( traits::not_same_v<void, base_type>,
1200  "Failed to detect base type" );
1201 
1203  Nullable != JsonNullable::MustExist, Constructor,
1204  json_element_parse_to_t const *,
1205  json_element_parse_to_t const *>::type;
1206 
1207  static constexpr daw::string_view name = no_name;
1208 
1209  static constexpr JsonParseTypes expected_type =
1210  get_parse_type_v<JsonParseTypes::Array, Nullable>;
1211 
1214 
1215  static_assert( json_element_t::name == no_name,
1216  "All elements of json_array must be have no_name" );
1219  static constexpr JsonNullable nullable = Nullable;
1220 
1221  template<JSONNAMETYPE NewName>
1222  using with_name = daw::json::json_array<NewName, JsonElement, Container,
1223  Constructor, Nullable>;
1225  };
1226  } // namespace json_base
1227 
1239  template<JSONNAMETYPE Name, typename JsonElement, typename Container,
1240  typename Constructor, JsonNullable Nullable>
1241  struct json_array
1242  : json_base::json_array<JsonElement, Container, Constructor, Nullable> {
1243 
1244  static constexpr daw::string_view name = Name;
1245 #if not defined( DAW_JSON_NO_FAIL_ON_NO_NAME_NAME )
1246  static_assert( name != no_name,
1247  "For no_name mappings, use the json_array_no_name variant "
1248  "without a name argument" );
1249 #endif
1250  template<JSONNAMETYPE NewName>
1251  using with_name =
1253 
1256  };
1257 
1258  template<
1259  typename JsonElement,
1260  typename Container = std::vector<
1262  typename Constructor = default_constructor<Container>,
1265  json_base::json_array<JsonElement, Container, Constructor, Nullable>;
1266 
1267  template<
1268  typename JsonElement,
1269  typename Container = std::vector<
1270  typename json_details::json_deduced_type<JsonElement>::parse_to_t>,
1271  typename Constructor = nullable_constructor<Container>>
1273  json_base::json_array<JsonElement, Container, Constructor,
1274  JsonNullDefault>;
1275 
1276  namespace json_base {
1277  template<typename JsonElement, typename SizeMember, typename Container,
1278  typename Constructor, JsonNullable Nullable>
1280  using i_am_a_json_type = void;
1281  static constexpr bool must_be_class_member = true;
1282  static constexpr JsonNullable nullable = Nullable;
1283  static_assert(
1284  json_details::has_unnamed_default_type_mapping_v<JsonElement>,
1285  "Missing specialization of daw::json::json_data_contract for class "
1286  "mapping or specialization of daw::json::json_link_basic_type_map" );
1288 
1289  static_assert( json_details::is_a_json_type_v<SizeMember>,
1290  "The SizeMember type must have a name and be a "
1291  "member of the same object as this" );
1293  nullable, SizeMember::nullable>,
1294  "The SizeMember cannot be a nullable type" );
1295  using dependent_member = SizeMember;
1296 
1297  using json_element_parse_to_t = typename json_element_t::parse_to_t;
1298 
1299  static_assert( traits::not_same_v<json_element_t, void>,
1300  "Unknown JsonElement type." );
1301  static_assert( json_details::is_a_json_type_v<json_element_t>,
1302  "Error determining element type" );
1303  using constructor_t = Constructor;
1305  static_assert( traits::not_same_v<void, base_type>,
1306  "Failed to detect base type" );
1307 
1309  nullable != JsonNullable::MustExist, Constructor,
1311  std::size_t>::type;
1312 
1313  static constexpr daw::string_view name = no_name;
1314 
1315  static constexpr JsonParseTypes expected_type =
1316  get_parse_type_v<JsonParseTypes::SizedArray, nullable>;
1317 
1320 
1321  static_assert( json_element_t::name == no_name,
1322  "All elements of json_array must be have no_name" );
1325 
1326  template<JSONNAMETYPE NewName>
1327  using with_name =
1328  daw::json::json_sized_array<NewName, JsonElement, SizeMember,
1329  Container, Constructor, nullable>;
1331  };
1332  } // namespace json_base
1333 
1334  template<JSONNAMETYPE Name, typename JsonElement, typename SizeMember,
1335  typename Container, typename Constructor, JsonNullable Nullable>
1337  : json_base::json_sized_array<JsonElement, SizeMember, Container,
1338  Constructor, Nullable> {
1339 
1340  static constexpr daw::string_view name = Name;
1341 #if not defined( DAW_JSON_NO_FAIL_ON_NO_NAME_NAME )
1342  static_assert(
1343  name != no_name,
1344  "For no_name mappings, use the json_sized_array_no_name variant "
1345  "without a name argument" );
1346 #endif
1347  template<JSONNAMETYPE NewName>
1348  using with_name = json_sized_array<NewName, SizeMember, JsonElement,
1349  Container, Constructor, Nullable>;
1350 
1352  json_base::json_sized_array<JsonElement, SizeMember, Container,
1353  Constructor, Nullable>;
1354  };
1355 
1356  template<
1357  typename JsonElement, typename SizeMember,
1358  typename Container = std::vector<
1360  typename Constructor = default_constructor<Container>,
1363  json_base::json_sized_array<JsonElement, SizeMember, Container,
1364  Constructor, Nullable>;
1365 
1366  template<
1367  typename JsonElement, typename SizeMember,
1368  typename Container = std::vector<
1369  typename json_details::json_deduced_type<JsonElement>::parse_to_t>,
1370  typename Constructor = nullable_constructor<Container>>
1372  json_base::json_sized_array<JsonElement, SizeMember, Container,
1373  Constructor, JsonNullDefault>;
1374 
1375  namespace json_base {
1376  template<typename Container, typename JsonValueType, typename JsonKeyType,
1377  typename Constructor, JsonNullable Nullable>
1379  using i_am_a_json_type = void;
1380  static constexpr bool must_be_class_member = false;
1384 
1385  static_assert( traits::not_same_v<void, base_type>,
1386  "Failed to detect base type" );
1387 
1388  static_assert(
1389  json_details::has_unnamed_default_type_mapping_v<JsonValueType>,
1390  "Missing specialization of daw::json::json_data_contract for class "
1391  "mapping or specialization of daw::json::json_link_basic_type_map" );
1392 
1394 
1395  static_assert( traits::not_same_v<json_element_t, void>,
1396  "Unknown JsonValueType type." );
1397  static_assert( json_element_t::name == no_name,
1398  "Value member name must be the default no_name" );
1399  static_assert(
1400  json_details::has_unnamed_default_type_mapping_v<JsonKeyType>,
1401  "Missing specialization of daw::json::json_data_contract for class "
1402  "mapping or specialization of daw::json::json_link_basic_type_map" );
1403 
1405 
1406  static_assert( traits::not_same_v<json_key_t, void>,
1407  "Unknown JsonKeyType type." );
1408  static_assert( json_details::is_no_name_v<json_key_t>,
1409  "Key member name must be the default no_name" );
1410 
1412  Nullable != JsonNullable::MustExist, Constructor,
1413  std::pair<typename json_key_t::parse_to_t const,
1414  typename json_element_t::parse_to_t> const *,
1415  std::pair<typename json_key_t::parse_to_t const,
1416  typename json_element_t::parse_to_t> const *>::type;
1417 
1418  static constexpr daw::string_view name = no_name;
1419  static constexpr JsonParseTypes expected_type =
1420  get_parse_type_v<JsonParseTypes::KeyValue, Nullable>;
1425  static constexpr JsonNullable nullable = Nullable;
1426 
1427  template<JSONNAMETYPE NewName>
1428  using with_name =
1429  daw::json::json_key_value<NewName, Container, JsonValueType,
1430  JsonKeyType, Constructor, Nullable>;
1432  };
1433  } // namespace json_base
1434 
1449  template<JSONNAMETYPE Name, typename Container, typename JsonValueType,
1450  typename JsonKeyType, typename Constructor, JsonNullable Nullable>
1452  : json_base::json_key_value<Container, JsonValueType, JsonKeyType,
1453  Constructor, Nullable> {
1454 
1455  static constexpr daw::string_view name = Name;
1456 #if not defined( DAW_JSON_NO_FAIL_ON_NO_NAME_NAME )
1457  static_assert( name != no_name,
1458  "For no_name mappings, use the json_key_value_no_name "
1459  "variant without a name argument" );
1460 #endif
1461 
1462  template<JSONNAMETYPE NewName>
1463  using with_name = json_key_value<NewName, Container, JsonValueType,
1464  JsonKeyType, Constructor, Nullable>;
1466  json_base::json_key_value<Container, JsonValueType, JsonKeyType,
1467  Constructor, Nullable>;
1468  };
1469 
1470  template<typename Container,
1471  typename JsonValueType = typename Container::mapped_type,
1472  typename JsonKeyType = typename Container::key_type,
1473  typename Constructor = default_constructor<Container>,
1476  json_base::json_key_value<Container, JsonValueType, JsonKeyType,
1477  Constructor, Nullable>;
1478 
1479  template<typename Container,
1480  typename JsonValueType = typename Container::mapped_type,
1481  typename JsonKeyType = typename Container::key_type,
1482  typename Constructor = nullable_constructor<Container>>
1484  json_base::json_key_value<Container, JsonValueType, JsonKeyType,
1485  Constructor, JsonNullDefault>;
1486 
1487  namespace json_base {
1488  template<typename Container, typename JsonValueType, typename JsonKeyType,
1489  typename Constructor, JsonNullable Nullable>
1491  using i_am_a_json_type = void;
1492  static constexpr bool must_be_class_member = false;
1496  static_assert( traits::not_same_v<void, base_type>,
1497  "Failed to detect base type" );
1498 
1500  Nullable != JsonNullable::MustExist, Constructor, base_type>::type;
1501 
1505 
1506  static_assert( traits::not_same_v<json_key_t, void>,
1507  "Unknown JsonKeyType type." );
1508  static_assert( daw::string_view( json_key_t::name ) !=
1509  daw::string_view( no_name ),
1510  "Must supply a valid key member name" );
1514 
1517  std::conditional_t<
1521  class_opts_def>;
1522  static_assert( traits::not_same_v<json_value_t, void>,
1523  "Unknown JsonValueType type." );
1524  static_assert( daw::string_view( json_value_t::name ) !=
1525  daw::string_view( no_name ),
1526  "Must supply a valid value member name" );
1527  static_assert( daw::string_view( json_key_t::name ) !=
1528  daw::string_view( json_value_t::name ),
1529  "Key and Value member names cannot be the same" );
1530  static constexpr daw::string_view name = no_name;
1531  static constexpr JsonParseTypes expected_type =
1532  get_parse_type_v<JsonParseTypes::KeyValueArray, Nullable>;
1537  static constexpr JsonNullable nullable = Nullable;
1538 
1539  template<JSONNAMETYPE NewName>
1540  using with_name =
1541  daw::json::json_key_value_array<NewName, Container, JsonValueType,
1542  JsonKeyType, Constructor, Nullable>;
1544  };
1545  } // namespace json_base
1546 
1562  template<JSONNAMETYPE Name, typename Container, typename JsonValueType,
1563  typename JsonKeyType, typename Constructor, JsonNullable Nullable>
1565  : json_base::json_key_value_array<Container, JsonValueType, JsonKeyType,
1566  Constructor, Nullable> {
1567 
1568  static constexpr daw::string_view name = Name;
1569 #if not defined( DAW_JSON_NO_FAIL_ON_NO_NAME_NAME )
1570  static_assert(
1571  name != no_name,
1572  "For no_name mappings, use the json_key_value_array_no_name variant "
1573  "without a name argument" );
1574 #endif
1575 
1576  template<JSONNAMETYPE NewName>
1577  using with_name =
1578  json_key_value_array<NewName, Container, JsonValueType, JsonKeyType,
1579  Constructor, Nullable>;
1581  json_base::json_key_value_array<Container, JsonValueType, JsonKeyType,
1582  Constructor, Nullable>;
1583  };
1584 
1585  template<typename Container,
1586  typename JsonValueType = typename Container::mapped_type,
1587  typename JsonKeyType = typename Container::key_type,
1588  typename Constructor = default_constructor<Container>,
1591  json_base::json_key_value_array<Container, JsonValueType, JsonKeyType,
1592  Constructor, Nullable>;
1593 
1594  template<typename Container,
1595  typename JsonValueType = typename Container::mapped_type,
1596  typename JsonKeyType = typename Container::key_type,
1597  typename Constructor = nullable_constructor<Container>>
1599  json_base::json_key_value_array<Container, JsonValueType, JsonKeyType,
1600  Constructor, JsonNullDefault>;
1601 
1602  namespace json_base {
1603  template<typename Tuple, typename Constructor,
1605  struct json_tuple {
1606  using i_am_a_json_type = void;
1607  static constexpr daw::string_view name = no_name;
1608 
1610  static constexpr bool must_be_class_member = false;
1611  static constexpr bool force_aggregate_construction = false;
1612 
1613  static constexpr JsonNullable nullable =
1614  json_details::get_bits_for<JsonNullable>( tuple_opts, Options );
1615 
1617 
1620 
1621  static_assert( traits::not_same<void, base_type>::value,
1622  "Failed to detect base type" );
1623 
1625  nullable != JsonNullable::MustExist, Constructor, base_type>::type;
1626 
1627  static constexpr JsonParseTypes expected_type =
1628  get_parse_type_v<JsonParseTypes::Tuple, nullable>;
1633 
1634  template<JSONNAMETYPE NewName>
1635  using with_name =
1638  };
1639  } // namespace json_base
1640 
1641  template<JSONNAMETYPE Name, typename Tuple, typename Constructor,
1643  struct json_tuple : json_base::json_tuple<Tuple, Constructor, Options> {
1644  static constexpr daw::string_view name = Name;
1645 #if not defined( DAW_JSON_NO_FAIL_ON_NO_NAME_NAME )
1646  static_assert( name != no_name,
1647  "For no_name mappings, use the json_tuple_no_name "
1648  "variant without a name argument" );
1649 #endif
1650 
1651  template<JSONNAMETYPE NewName>
1653 
1655  };
1656 
1657  template<typename Tuple, typename Constructor = default_constructor<Tuple>,
1658  json_details::json_options_t Options = tuple_opts_def>
1660  json_base::json_tuple<Tuple, Constructor, Options>;
1661 
1662  template<typename Tuple, typename Constructor = default_constructor<Tuple>,
1663  json_details::json_options_t Options = tuple_opts_def>
1664  using json_tuple_null_no_name = json_base::json_tuple<
1665  Tuple, Constructor,
1666  json_details::tuple_opts_set<Options, JsonNullDefault>>;
1667 
1668  /***
1669  * An untyped JSON value
1670  */
1672 
1673  /***
1674  * A name/value pair of string_view/json_value
1675  */
1677 
1678  /***
1679  * json_raw allows for raw JSON access to the member data. It requires a
1680  * type that is constructable from (char const *, std::size_t) arguments and
1681  * for serialization requires that it can be passed to std::begin/std::end
1682  * and the iterator returned has a value_type of char
1683  * @tparam Name json member name
1684  * @tparam T type to hold raw JSON data, defaults to json_value
1685  * @tparam Constructor A callable used to construct T.
1686  * @tparam Nullable Does the value have to exist in the document or can it
1687  * have a null value
1688  */
1689  template<JSONNAMETYPE Name, typename T = json_value,
1690  typename Constructor = default_constructor<T>,
1692  struct json_raw;
1693 
1694  namespace json_base {
1695  template<typename T, typename Constructor, JsonNullable Nullable>
1696  struct json_raw {
1697  using i_am_a_json_type = void;
1698  static constexpr bool must_be_class_member = false;
1700  using constructor_t = Constructor;
1701  static constexpr JsonNullable nullable = Nullable;
1703  static_assert( traits::not_same_v<void, base_type>,
1704  "Failed to detect base type" );
1705 
1707  nullable != JsonNullable::MustExist, Constructor, char const *,
1708  char const *>::type;
1709 
1710  static constexpr daw::string_view name = no_name;
1711 
1712  static constexpr JsonParseTypes expected_type =
1713  get_parse_type_v<JsonParseTypes::Unknown, nullable>;
1716 
1719 
1720  template<JSONNAMETYPE NewName>
1721  using with_name =
1724  };
1725  } // namespace json_base
1726 
1727  /***
1728  * json_raw allows for raw JSON access to the member data. It requires a
1729  * type that is constructable from (char const *, std::size_t) arguments and
1730  * for serialization requires that it can be passed to std::begin/std::end
1731  * and the iterator returned has a value_type of char. Any whitespace
1732  * surrounding the value may not be preserved. The default T json_value
1733  * allows for delaying the parsing of this member until later
1734  * @tparam Name json member name
1735  * @tparam T type to hold raw JSON data, defaults to json_value
1736  * @tparam Constructor A callable used to construct T.
1737  * @tparam Nullable Does the value have to exist in the document or can it
1738  * have a null value
1739  */
1740  template<JSONNAMETYPE Name, typename T, typename Constructor,
1742  struct json_raw : json_base::json_raw<T, Constructor, Nullable> {
1743  static constexpr daw::string_view name = Name;
1744 #if not defined( DAW_JSON_NO_FAIL_ON_NO_NAME_NAME )
1745  static_assert( name != no_name,
1746  "For no_name mappings, use the json_raw_no_name "
1747  "variant without a name argument" );
1748 #endif
1749 
1750  template<JSONNAMETYPE NewName>
1752 
1754  };
1755 
1756  template<JSONNAMETYPE Name, typename T = json_value,
1757  typename Constructor = default_constructor<T>,
1760  [[deprecated( "Was renamed to json_raw, will be removed in v4" )]] =
1762 
1763  /***
1764  * json_raw_null allows for raw JSON access to the nullable member data.
1765  * It requires a type that is constructable from (char const *,
1766  * std::size_t) arguments and for serialization requires that it can be
1767  * passed to std::begin/std::end and the iterator returned has a
1768  * value_type of char. Any whitespace
1769  * surrounding the value may not be preserved. The default T json_value
1770  * allows for delaying the parsing of this member until later
1771  * @tparam Name json member name
1772  * @tparam T type to hold raw JSON data, defaults to json_value
1773  * @tparam Constructor A callable used to construct T.
1774  */
1775  template<JSONNAMETYPE Name, typename T = std::optional<json_value>,
1776  typename Constructor = nullable_constructor<T>>
1778 
1779  template<JSONNAMETYPE Name, typename T = std::optional<json_value>,
1780  typename Constructor = nullable_constructor<T>>
1782  [[deprecated( "Was renamed to json_raw_null, will be removed in v4" )]] =
1784 
1785  /***
1786  * json_raw allows for raw JSON access to the member data. It requires a
1787  * type that is constructable from (char const *, std::size_t) arguments and
1788  * for serialization requires that it can be passed to std::begin/std::end
1789  * and the iterator returned has a value_type of char. Any whitespace
1790  * surrounding the value may not be preserved. The default T json_value
1791  * allows for delaying the parsing of this member until later
1792  * @tparam T type to hold raw JSON data, defaults to json_value
1793  * @tparam Constructor A callable used to construct T.
1794  * @tparam Nullable Does the value have to exist in the document or can it
1795  * have a null value
1796  */
1797  template<typename T = json_value,
1798  typename Constructor = default_constructor<T>,
1800  using json_raw_no_name = json_base::json_raw<T, Constructor, Nullable>;
1801 
1802  /***
1803  * json_raw_null allows for raw JSON access to the nullable member data.
1804  * It requires a type that is constructable from (char const *,
1805  * std::size_t) arguments and for serialization requires that it can be
1806  * passed to std::begin/std::end and the iterator returned has a
1807  * value_type of char. Any whitespace
1808  * surrounding the value may not be preserved. The default T json_value
1809  * allows for delaying the parsing of this member until later
1810  * @tparam T type to hold raw JSON data, defaults to json_value
1811  * @tparam Constructor A callable used to construct T.
1812  */
1813  template<typename T = std::optional<json_value>,
1814  typename Constructor = nullable_constructor<T>>
1816  json_base::json_raw<T, Constructor, JsonNullDefault>;
1817 
1818  template<typename ParseState>
1819  struct json_data_contract<basic_json_value<ParseState>> {
1820  using type =
1822  };
1823 
1824  /***
1825  * This allows naming of well known types and using them to map members
1826  */
1827  template<JSONNAMETYPE Name, typename T>
1829  json_details::json_deduced_type<T>>::template with_name<Name>;
1830 
1831  template<typename T>
1833  json_details::ensure_mapped_t<json_details::json_deduced_type<T>>;
1834  } // namespace DAW_JSON_VER
1835 } // namespace daw::json
Definition: daw_json_value.h:316
#define daw_json_assert_weak(Bool,...)
Definition: daw_json_assert.h:189
#define JSONNAMETYPE
Definition: daw_json_name.h:107
ParseState & parse_state
Definition: daw_json_parse_class.h:201
Iterator & it
Definition: daw_json_traits.h:231
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... > > > > construction_result
Definition: daw_json_traits.h:96
constexpr bool has_json_data_contract_trait_v
Definition: daw_json_parse_common.h:185
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 json_deduced_type
Definition: daw_json_parse_common.h:931
constexpr OutputIterator serialize_ordered_json_class(OutputIterator it, Tuple const &args, Value const &value, std::index_sequence< Is... >)
Definition: daw_json_serialize_impl.h:135
constexpr OutputIterator member_to_string(template_param< JsonMember >, OutputIterator it, T const &value)
Definition: to_daw_json_string.h:1259
daw::not_trait< std::is_same< json_deduced_type< T >, missing_json_data_contract_for< T > >> has_json_deduced_type
Definition: daw_json_parse_common.h:935
constexpr char const default_value_name[]
Definition: daw_json_name.h:113
constexpr DAW_ATTRIB_FLATTEN json_result< JsonClass > parse_nth_class(std::size_t idx, ParseState &parse_state)
Definition: daw_json_parse_value.h:993
std::bool_constant< nullable !=JsonNullable::MustExist > is_nullable_json_value
Definition: daw_json_enums.h:88
std::conditional_t< is_an_ordered_member_v< JsonMember >, JsonMember, json_deduced_type< JsonMember > > ordered_member_wrapper
Definition: daw_json_link_types.h:191
std::bool_constant< daw::is_detected_v< json_type_t, T > > is_a_json_type
Definition: daw_json_traits.h:426
typename daw::detected_or_t< T, ordered_member_subtype_test, T > ordered_member_subtype_t
Definition: daw_json_parse_common.h:54
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_constructor_t
Definition: daw_json_traits.h:484
std::uint32_t json_options_t
Definition: daw_json_option_bits.h:23
std::bool_constant< JsonMember::name==no_name > is_no_name
Definition: daw_json_name.h:119
typename ensure_mapped< T >::type ensure_mapped_t
Definition: daw_json_link_types_fwd.h:631
copy_name_when< JsonMember, NewName, JsonMember::name==no_name > copy_name_when_noname
Definition: daw_json_traits.h:110
static constexpr json_result< JsonClass > parse_ordered_json_class(template_params< JsonClass, JsonMembers... >, ParseState &parse_state)
Definition: daw_json_parse_class.h:336
constexpr char const default_key_name[]
Definition: daw_json_name.h:112
constexpr json_options_t number_opts_set
Definition: daw_json_parse_common.h:317
constexpr OutputIterator serialize_json_class(OutputIterator it, Tuple const &args, Value const &value, std::index_sequence< Is... >)
Definition: daw_json_serialize_impl.h:86
static constexpr DAW_ATTRIB_FLATINLINE auto construct_value(template_params< Value, Constructor >, ParseState &parse_state, Args &&...args)
Definition: daw_json_parse_common.h:63
typename JsonMember::parse_to_t json_result
Definition: daw_json_parse_common.h:205
daw::remove_cvref_t< json_class_parse_result_impl< Constructor, Members... > > json_class_parse_result_t
Definition: daw_json_parse_common.h:954
typename std::conditional_t< is_nullable_json_value_v< Nullable >, dereffed_type< T >, T > unwrap_type
Definition: daw_json_parse_common.h:306
constexpr json_result< JsonClass > parse_json_class(ParseState &parse_state, std::index_sequence< Is... >)
Definition: daw_json_parse_class.h:238
constexpr json_options_t json_custom_opts_set
Definition: daw_json_parse_common.h:333
constexpr DAW_ATTRIB_INLINE json_result< JsonMember > parse_value(ParseState &parse_state, ParseTag< JsonParseTypes::Real >)
Definition: daw_json_parse_value.h:67
constexpr bool is_nullability_compatable_v
Definition: daw_json_traits.h:612
constexpr json_details::json_options_t string_opts_def
Definition: daw_json_type_options.h:124
EightBitModes
Definition: daw_json_type_options.h:104
JsonParseTypes
Definition: daw_json_enums.h:19
json_base::json_key_value< Container, JsonValueType, JsonKeyType, Constructor, Nullable > json_key_value_no_name
Definition: daw_json_link_types.h:1477
LiteralAsStringOpt
Definition: daw_json_type_options.h:38
json_base::json_class< T, Constructor, Options > json_class_no_name
Definition: daw_json_link_types.h:838
json_base::json_key_value< Container, JsonValueType, JsonKeyType, Constructor, JsonNullDefault > json_key_value_null_no_name
Definition: daw_json_link_types.h:1485
json_base::json_variant< T, JsonElements, Constructor, JsonNullDefault > json_variant_null_no_name
Definition: daw_json_link_types.h:966
constexpr json_details::json_options_t json_custom_opts_def
Definition: daw_json_type_options.h:213
constexpr auto bool_opts
Definition: daw_json_type_options.h:81
json_base::json_number< T, json_details::number_opts_set< Options, JsonRangeCheck::CheckForNarrowing, JsonNullDefault >, Constructor > json_checked_number_null_no_name
Definition: daw_json_link_types.h:470
json_base::json_custom< T, FromJsonConverter, ToJsonConverter, Options > json_custom_no_name
Definition: daw_json_link_types.h:1152
JsonCustomTypes
Definition: daw_json_type_options.h:197
typename json_data_contract< T >::type json_data_contract_trait_t
Definition: daw_json_traits.h:133
json_base::json_number< T, json_details::number_opts_set< Options, JsonRangeCheck::CheckForNarrowing >, Constructor > json_checked_number_no_name
Definition: daw_json_link_types.h:453
json_base::json_string_raw< T, json_details::string_raw_opts_set< Options, JsonNullDefault >, Constructor > json_string_raw_null_no_name
Definition: daw_json_link_types.h:630
json_base::json_key_value_array< Container, JsonValueType, JsonKeyType, Constructor, JsonNullDefault > json_key_value_array_null_no_name
Definition: daw_json_link_types.h:1600
json_base::json_bool< T, Options, Constructor > json_bool_no_name
Definition: daw_json_link_types.h:535
json_base::json_custom< T, FromJsonConverter, ToJsonConverter, json_details::json_custom_opts_set< Options, JsonCustomTypes::Literal, JsonNullDefault > > json_custom_lit_null_no_name
Definition: daw_json_link_types.h:1177
json_base::json_tuple< Tuple, Constructor, json_details::tuple_opts_set< Options, JsonNullDefault > > json_tuple_null_no_name
Definition: daw_json_link_types.h:1666
json_base::json_number< T, Options, Constructor > json_number_no_name
Definition: daw_json_link_types.h:431
json_base::json_tuple< Tuple, Constructor, Options > json_tuple_no_name
Definition: daw_json_link_types.h:1660
json_base::json_array< JsonElement, Container, Constructor, JsonNullDefault > json_array_null_no_name
Definition: daw_json_link_types.h:1274
json_base::json_variant< T, JsonElements, Constructor, JsonNullable::MustExist > json_variant_no_name
Definition: daw_json_link_types.h:961
constexpr auto string_raw_opts
Definition: daw_json_type_options.h:155
json_base::json_date< T, Constructor, JsonNullDefault > json_date_null_no_name
Definition: daw_json_link_types.h:770
json_base::json_array< JsonElement, Container, Constructor, Nullable > json_array_no_name
Definition: daw_json_link_types.h:1265
json_base::json_bool< T, json_details::bool_opts_set< Options, JsonNullDefault >, Constructor > json_bool_null_no_name
Definition: daw_json_link_types.h:541
std::integral_constant< JsonParseTypes, v > ParseTag
Definition: daw_json_enums.h:106
json_details::ensure_mapped_t< json_details::json_deduced_type< T > > json_link_no_name
Definition: daw_json_link_types.h:1833
json_base::json_tagged_variant< T, TagMember, Switcher, JsonElements, Constructor, JsonNullDefault > json_tagged_variant_null_no_name
Definition: daw_json_link_types.h:1070
JsonNullable
Definition: daw_json_enums.h:77
json_base::json_raw< T, Constructor, Nullable > json_raw_no_name
Definition: daw_json_link_types.h:1800
json_base::json_string< T, Options, Constructor > json_string_no_name
Definition: daw_json_link_types.h:702
json_base::json_sized_array< JsonElement, SizeMember, Container, Constructor, Nullable > json_sized_array_no_name
Definition: daw_json_link_types.h:1364
constexpr char const no_name[]
Definition: daw_json_name.h:109
constexpr json_details::json_options_t class_opts_def
Definition: daw_json_type_options.h:168
constexpr json_details::json_options_t bool_opts_def
Definition: daw_json_type_options.h:82
json_base::json_number< T, json_details::number_opts_set< Options, JsonNullDefault >, Constructor > json_number_null_no_name
Definition: daw_json_link_types.h:437
json_base::json_string< T, json_details::string_opts_set< Options, JsonNullDefault >, Constructor > json_string_null_no_name
Definition: daw_json_link_types.h:708
typename json_details::ensure_mapped_t< json_details::json_deduced_type< T > >::template with_name< Name > json_link
Definition: daw_json_link_types.h:1829
JsonBaseParseTypes
Definition: daw_json_enums.h:40
AllowEscapeCharacter
Definition: daw_json_type_options.h:136
json_base::json_key_value_array< Container, JsonValueType, JsonKeyType, Constructor, Nullable > json_key_value_array_no_name
Definition: daw_json_link_types.h:1592
json_base::json_class< T, Constructor, json_details::class_opts_set< Options, JsonNullDefault > > json_class_null_no_name
Definition: daw_json_link_types.h:843
std::bool_constant< std::disjunction_v< daw::is_detected< json_details::force_aggregate_construction_test, T >, daw::is_detected< json_details::force_aggregate_construction_test2, T > >> force_aggregate_construction
Definition: daw_json_traits.h:174
EmptyStringNull
Definition: daw_json_type_options.h:93
constexpr auto tuple_opts
Definition: daw_json_type_options.h:178
JsonRangeCheck
Definition: daw_json_type_options.h:52
constexpr json_details::json_options_t string_raw_opts_def
Definition: daw_json_type_options.h:156
json_base::json_raw< T, Constructor, JsonNullDefault > json_raw_null_no_name
Definition: daw_json_link_types.h:1816
constexpr JsonNullable JsonNullDefault
Definition: daw_json_enums.h:83
json_base::json_custom< T, FromJsonConverter, ToJsonConverter, json_details::json_custom_opts_set< Options, JsonNullDefault > > json_custom_null_no_name
Definition: daw_json_link_types.h:1168
constexpr auto json_custom_opts
Definition: daw_json_type_options.h:212
json_base::json_tagged_variant< T, TagMember, Switcher, JsonElements, Constructor, Nullable > json_tagged_variant_no_name
Definition: daw_json_link_types.h:1062
json_base::json_date< T, Constructor, Nullable > json_date_no_name
Definition: daw_json_link_types.h:766
basic_json_value< NoCommentSkippingPolicyChecked > json_value
Definition: daw_json_link_types.h:1671
constexpr auto class_opts
Definition: daw_json_type_options.h:167
constexpr auto string_opts
Definition: daw_json_type_options.h:123
json_base::json_sized_array< JsonElement, SizeMember, Container, Constructor, JsonNullDefault > json_sized_array_null_no_name
Definition: daw_json_link_types.h:1373
constexpr json_details::json_options_t number_opts_def
Definition: daw_json_type_options.h:69
constexpr auto number_opts
Definition: daw_json_type_options.h:68
json_base::json_string_raw< T, Options, Constructor > json_string_raw_no_name
Definition: daw_json_link_types.h:623
json_base::json_custom< T, FromJsonConverter, ToJsonConverter, json_details::json_custom_opts_set< Options, JsonCustomTypes::Literal > > json_custom_lit_no_name
Definition: daw_json_link_types.h:1160
Definition: daw_from_json.h:22
Definition: daw_json_value.h:41
Definition: daw_json_traits.h:190
Definition: to_daw_json_string.h:210
Definition: to_daw_json_string.h:131
Definition: daw_json_link_types.h:1242
static constexpr daw::string_view name
Definition: daw_json_link_types.h:1244
Definition: daw_json_link_types.h:1182
static constexpr JsonParseTypes expected_type
Definition: daw_json_link_types.h:1209
json_details::unwrap_type< Container, Nullable > base_type
Definition: daw_json_link_types.h:1198
static constexpr JsonNullable nullable
Definition: daw_json_link_types.h:1219
static constexpr daw::string_view name
Definition: daw_json_link_types.h:1207
void i_am_a_json_type
Definition: daw_json_link_types.h:1183
static constexpr JsonBaseParseTypes underlying_json_type
Definition: daw_json_link_types.h:1217
Constructor constructor_t
Definition: daw_json_link_types.h:1196
typename json_element_t::parse_to_t json_element_parse_to_t
Definition: daw_json_link_types.h:1190
static constexpr JsonParseTypes base_expected_type
Definition: daw_json_link_types.h:1212
json_details::json_deduced_type< JsonElement > json_element_t
Definition: daw_json_link_types.h:1189
typename json_details::construction_result< Nullable !=JsonNullable::MustExist, Constructor, json_element_parse_to_t const *, json_element_parse_to_t const * >::type parse_to_t
Definition: daw_json_link_types.h:1205
static constexpr bool must_be_class_member
Definition: daw_json_link_types.h:1184
Definition: daw_json_link_types.h:475
static constexpr JsonParseTypes expected_type
Definition: daw_json_link_types.h:491
static constexpr daw::string_view name
Definition: daw_json_link_types.h:477
json_details::unwrap_type< T, nullable > base_type
Definition: daw_json_link_types.h:482
static constexpr bool must_be_class_member
Definition: daw_json_link_types.h:480
static constexpr JsonBaseParseTypes underlying_json_type
Definition: daw_json_link_types.h:499
Constructor constructor_t
Definition: daw_json_link_types.h:489
static constexpr LiteralAsStringOpt literal_as_string
Definition: daw_json_link_types.h:496
void i_am_a_json_type
Definition: daw_json_link_types.h:476
static constexpr JsonNullable nullable
Definition: daw_json_link_types.h:478
typename json_details::construction_result< nullable !=JsonNullable::MustExist, Constructor, base_type >::type parse_to_t
Definition: daw_json_link_types.h:487
static constexpr JsonParseTypes base_expected_type
Definition: daw_json_link_types.h:493
T wrapped_type
Definition: daw_json_link_types.h:481
Definition: daw_json_link_types.h:775
json_details::unwrap_type< T, nullable > base_type
Definition: daw_json_link_types.h:782
json_details::json_class_constructor_t< base_type, Constructor > constructor_t
Definition: daw_json_link_types.h:784
static constexpr JsonParseTypes expected_type
Definition: daw_json_link_types.h:797
static constexpr JsonBaseParseTypes underlying_json_type
Definition: daw_json_link_types.h:801
T wrapped_type
Definition: daw_json_link_types.h:778
typename std::conditional_t< force_aggregate_construction< base_type >::value, daw::traits::identity< base_type >, daw::traits::identity< typename data_contract::template result_type< constructor_t > >>::type parse_to_t
Definition: daw_json_link_types.h:795
json_data_contract_trait_t< base_type > data_contract
Definition: daw_json_link_types.h:789
static constexpr daw::string_view name
Definition: daw_json_link_types.h:777
static constexpr bool must_be_class_member
Definition: daw_json_link_types.h:779
void i_am_a_json_type
Definition: daw_json_link_types.h:776
static constexpr JsonParseTypes base_expected_type
Definition: daw_json_link_types.h:799
static constexpr JsonNullable nullable
Definition: daw_json_link_types.h:780
Definition: daw_json_link_types.h:1075
static constexpr JsonNullable nullable
Definition: daw_json_link_types.h:1082
static constexpr daw::string_view name
Definition: daw_json_link_types.h:1098
static constexpr JsonParseTypes expected_type
Definition: daw_json_link_types.h:1099
FromJsonConverter from_converter_t
Definition: daw_json_link_types.h:1078
static constexpr bool must_be_class_member
Definition: daw_json_link_types.h:1080
static constexpr JsonCustomTypes custom_json_type
Definition: daw_json_link_types.h:1104
typename json_details::construction_result< nullable !=JsonNullable::MustExist, FromJsonConverter, std::string_view >::type parse_to_t
Definition: daw_json_link_types.h:1091
ToJsonConverter to_converter_t
Definition: daw_json_link_types.h:1077
FromJsonConverter constructor_t
Definition: daw_json_link_types.h:1079
void i_am_a_json_type
Definition: daw_json_link_types.h:1076
static constexpr JsonBaseParseTypes underlying_json_type
Definition: daw_json_link_types.h:1108
json_details::unwrap_type< T, nullable > base_type
Definition: daw_json_link_types.h:1085
static constexpr JsonParseTypes base_expected_type
Definition: daw_json_link_types.h:1101
Definition: daw_json_link_types.h:712
static constexpr bool must_be_class_member
Definition: daw_json_link_types.h:716
json_details::unwrap_type< T, Nullable > base_type
Definition: daw_json_link_types.h:717
typename json_details::construction_result< Nullable !=JsonNullable::MustExist, Constructor, char const *, std::size_t >::type parse_to_t
Definition: daw_json_link_types.h:723
static constexpr daw::string_view name
Definition: daw_json_link_types.h:725
static constexpr JsonNullable nullable
Definition: daw_json_link_types.h:732
void i_am_a_json_type
Definition: daw_json_link_types.h:713
Constructor constructor_t
Definition: daw_json_link_types.h:714
T wrapped_type
Definition: daw_json_link_types.h:715
static constexpr JsonParseTypes base_expected_type
Definition: daw_json_link_types.h:728
static constexpr JsonBaseParseTypes underlying_json_type
Definition: daw_json_link_types.h:730
static constexpr JsonParseTypes expected_type
Definition: daw_json_link_types.h:726
Definition: daw_json_link_types.h:1490
static constexpr JsonNullable nullable
Definition: daw_json_link_types.h:1537
static constexpr JsonParseTypes base_expected_type
Definition: daw_json_link_types.h:1533
static constexpr JsonBaseParseTypes underlying_json_type
Definition: daw_json_link_types.h:1535
static constexpr bool must_be_class_member
Definition: daw_json_link_types.h:1492
json_details::copy_name_when_noname< json_details::json_deduced_type< JsonKeyType >, json_details::default_key_name > json_key_t
Definition: daw_json_link_types.h:1504
json_details::copy_name_when_noname< json_details::json_deduced_type< JsonValueType >, json_details::default_value_name > json_value_t
Definition: daw_json_link_types.h:1513
static constexpr JsonParseTypes expected_type
Definition: daw_json_link_types.h:1531
json_details::json_class_constructor_t< base_type, Constructor > constructor_t
Definition: daw_json_link_types.h:1495
typename json_details::construction_result< Nullable !=JsonNullable::MustExist, Constructor, base_type >::type parse_to_t
Definition: daw_json_link_types.h:1500
void i_am_a_json_type
Definition: daw_json_link_types.h:1491
static constexpr daw::string_view name
Definition: daw_json_link_types.h:1530
json_details::unwrap_type< Container, Nullable > base_type
Definition: daw_json_link_types.h:1493
Definition: daw_json_link_types.h:1378
static constexpr JsonParseTypes expected_type
Definition: daw_json_link_types.h:1419
json_details::json_class_constructor_t< base_type, Constructor > constructor_t
Definition: daw_json_link_types.h:1383
void i_am_a_json_type
Definition: daw_json_link_types.h:1379
json_details::json_deduced_type< JsonValueType > json_element_t
Definition: daw_json_link_types.h:1393
static constexpr bool must_be_class_member
Definition: daw_json_link_types.h:1380
static constexpr daw::string_view name
Definition: daw_json_link_types.h:1418
json_details::json_deduced_type< JsonKeyType > json_key_t
Definition: daw_json_link_types.h:1404
static constexpr JsonParseTypes base_expected_type
Definition: daw_json_link_types.h:1421
json_details::unwrap_type< Container, Nullable > base_type
Definition: daw_json_link_types.h:1381
typename json_details::construction_result< Nullable !=JsonNullable::MustExist, Constructor, std::pair< typename json_key_t::parse_to_t const, typename json_element_t::parse_to_t > const *, std::pair< typename json_key_t::parse_to_t const, typename json_element_t::parse_to_t > const * >::type parse_to_t
Definition: daw_json_link_types.h:1416
static constexpr JsonNullable nullable
Definition: daw_json_link_types.h:1425
static constexpr JsonBaseParseTypes underlying_json_type
Definition: daw_json_link_types.h:1423
Definition: daw_json_link_types.h:353
T wrapped_type
Definition: daw_json_link_types.h:355
Constructor constructor_t
Definition: daw_json_link_types.h:376
static constexpr JsonParseTypes expected_type
Definition: daw_json_link_types.h:378
typename json_details::construction_result< nullable !=JsonNullable::MustExist, Constructor, base_type >::type parse_to_t
Definition: daw_json_link_types.h:369
static constexpr LiteralAsStringOpt literal_as_string
Definition: daw_json_link_types.h:385
json_details::unwrap_type< T, nullable > base_type
Definition: daw_json_link_types.h:361
static constexpr JsonParseTypes base_expected_type
Definition: daw_json_link_types.h:382
static constexpr JsonRangeCheck range_check
Definition: daw_json_link_types.h:389
static constexpr JsonBaseParseTypes underlying_json_type
Definition: daw_json_link_types.h:392
static constexpr daw::string_view name
Definition: daw_json_link_types.h:356
static constexpr JsonNullable nullable
Definition: daw_json_link_types.h:359
void i_am_a_json_type
Definition: daw_json_link_types.h:354
static constexpr bool must_be_class_member
Definition: daw_json_link_types.h:357
Definition: daw_json_link_types.h:1696
static constexpr daw::string_view name
Definition: daw_json_link_types.h:1710
Constructor constructor_t
Definition: daw_json_link_types.h:1700
json_details::unwrap_type< T, nullable > base_type
Definition: daw_json_link_types.h:1702
static constexpr JsonNullable nullable
Definition: daw_json_link_types.h:1701
static constexpr JsonParseTypes expected_type
Definition: daw_json_link_types.h:1712
static constexpr JsonParseTypes base_expected_type
Definition: daw_json_link_types.h:1714
typename json_details::construction_result< nullable !=JsonNullable::MustExist, Constructor, char const *, char const * >::type parse_to_t
Definition: daw_json_link_types.h:1708
static constexpr JsonBaseParseTypes underlying_json_type
Definition: daw_json_link_types.h:1717
static constexpr bool must_be_class_member
Definition: daw_json_link_types.h:1698
void i_am_a_json_type
Definition: daw_json_link_types.h:1697
Definition: daw_json_link_types.h:1279
static constexpr daw::string_view name
Definition: daw_json_link_types.h:1313
json_details::unwrap_type< Container, nullable > base_type
Definition: daw_json_link_types.h:1304
static constexpr bool must_be_class_member
Definition: daw_json_link_types.h:1281
typename json_details::construction_result< nullable !=JsonNullable::MustExist, Constructor, json_element_parse_to_t const *, json_element_parse_to_t const *, std::size_t >::type parse_to_t
Definition: daw_json_link_types.h:1311
static constexpr JsonNullable nullable
Definition: daw_json_link_types.h:1282
typename json_element_t::parse_to_t json_element_parse_to_t
Definition: daw_json_link_types.h:1297
static constexpr JsonBaseParseTypes underlying_json_type
Definition: daw_json_link_types.h:1323
static constexpr JsonParseTypes expected_type
Definition: daw_json_link_types.h:1315
SizeMember dependent_member
Definition: daw_json_link_types.h:1295
void i_am_a_json_type
Definition: daw_json_link_types.h:1280
json_details::json_deduced_type< JsonElement > json_element_t
Definition: daw_json_link_types.h:1287
static constexpr JsonParseTypes base_expected_type
Definition: daw_json_link_types.h:1318
Constructor constructor_t
Definition: daw_json_link_types.h:1303
Definition: daw_json_link_types.h:546
static constexpr JsonParseTypes base_expected_type
Definition: daw_json_link_types.h:563
static constexpr daw::string_view name
Definition: daw_json_link_types.h:560
static constexpr AllowEscapeCharacter allow_escape_character
Definition: daw_json_link_types.h:574
static constexpr JsonNullable nullable
Definition: daw_json_link_types.h:548
static constexpr JsonBaseParseTypes underlying_json_type
Definition: daw_json_link_types.h:565
typename json_details::construction_result< nullable !=JsonNullable::MustExist, Constructor, base_type >::type parse_to_t
Definition: daw_json_link_types.h:558
static constexpr bool must_be_class_member
Definition: daw_json_link_types.h:550
static constexpr JsonParseTypes expected_type
Definition: daw_json_link_types.h:561
static constexpr EightBitModes eight_bit_mode
Definition: daw_json_link_types.h:571
Constructor constructor_t
Definition: daw_json_link_types.h:551
String wrapped_type
Definition: daw_json_link_types.h:552
void i_am_a_json_type
Definition: daw_json_link_types.h:547
json_details::unwrap_type< String, nullable > base_type
Definition: daw_json_link_types.h:553
static constexpr EmptyStringNull empty_is_null
Definition: daw_json_link_types.h:568
Definition: daw_json_link_types.h:635
static constexpr daw::string_view name
Definition: daw_json_link_types.h:650
static constexpr JsonParseTypes base_expected_type
Definition: daw_json_link_types.h:653
String wrapped_type
Definition: daw_json_link_types.h:641
static constexpr EightBitModes eight_bit_mode
Definition: daw_json_link_types.h:657
void i_am_a_json_type
Definition: daw_json_link_types.h:636
static constexpr JsonBaseParseTypes underlying_json_type
Definition: daw_json_link_types.h:660
json_details::unwrap_type< String, nullable > base_type
Definition: daw_json_link_types.h:642
static constexpr JsonParseTypes expected_type
Definition: daw_json_link_types.h:651
static constexpr JsonNullable nullable
Definition: daw_json_link_types.h:637
static constexpr EmptyStringNull empty_is_null
Definition: daw_json_link_types.h:655
typename json_details::construction_result< nullable !=JsonNullable::MustExist, Constructor, char const *, char const * >::type parse_to_t
Definition: daw_json_link_types.h:648
static constexpr bool must_be_class_member
Definition: daw_json_link_types.h:639
Constructor constructor_t
Definition: daw_json_link_types.h:640
Definition: daw_json_link_types.h:972
T wrapped_type
Definition: daw_json_link_types.h:982
Switcher switcher
Definition: daw_json_link_types.h:992
void i_am_a_tagged_variant
Definition: daw_json_link_types.h:974
static constexpr JsonNullable nullable
Definition: daw_json_link_types.h:975
static constexpr bool must_be_class_member
Definition: daw_json_link_types.h:976
void i_am_a_json_type
Definition: daw_json_link_types.h:973
static constexpr JsonBaseParseTypes underlying_json_type
Definition: daw_json_link_types.h:1004
json_details::unwrap_type< T, Nullable > base_type
Definition: daw_json_link_types.h:993
static constexpr JsonParseTypes base_expected_type
Definition: daw_json_link_types.h:1002
static constexpr daw::string_view name
Definition: daw_json_link_types.h:999
T parse_to_t
Definition: daw_json_link_types.h:998
static constexpr JsonParseTypes expected_type
Definition: daw_json_link_types.h:1000
JsonElements json_elements
Definition: daw_json_link_types.h:1006
json_details::json_class_constructor_t< T, Constructor > constructor_t
Definition: daw_json_link_types.h:995
TagMember dependent_member
Definition: daw_json_link_types.h:990
Definition: daw_json_link_types.h:1605
static constexpr JsonNullable nullable
Definition: daw_json_link_types.h:1613
typename json_details::construction_result< nullable !=JsonNullable::MustExist, Constructor, base_type >::type parse_to_t
Definition: daw_json_link_types.h:1625
json_details::json_class_constructor_t< base_type, Constructor > constructor_t
Definition: daw_json_link_types.h:1619
static constexpr JsonParseTypes base_expected_type
Definition: daw_json_link_types.h:1629
Tuple wrapped_type
Definition: daw_json_link_types.h:1609
static constexpr daw::string_view name
Definition: daw_json_link_types.h:1607
static constexpr JsonParseTypes expected_type
Definition: daw_json_link_types.h:1627
static constexpr JsonBaseParseTypes underlying_json_type
Definition: daw_json_link_types.h:1631
void i_am_a_json_type
Definition: daw_json_link_types.h:1606
json_details::unwrap_type< Tuple, nullable > base_type
Definition: daw_json_link_types.h:1616
static constexpr bool must_be_class_member
Definition: daw_json_link_types.h:1610
Definition: daw_json_link_types.h:896
static constexpr JsonNullable nullable
Definition: daw_json_link_types.h:920
json_details::unwrap_type< T, Nullable > base_type
Definition: daw_json_link_types.h:904
static constexpr JsonParseTypes expected_type
Definition: daw_json_link_types.h:911
static constexpr JsonBaseParseTypes underlying_json_type
Definition: daw_json_link_types.h:916
void i_am_a_json_type
Definition: daw_json_link_types.h:897
json_details::json_class_constructor_t< T, Constructor > constructor_t
Definition: daw_json_link_types.h:906
JsonElements json_elements
Definition: daw_json_link_types.h:918
T parse_to_t
Definition: daw_json_link_types.h:909
static constexpr daw::string_view name
Definition: daw_json_link_types.h:910
static constexpr JsonParseTypes base_expected_type
Definition: daw_json_link_types.h:913
T wrapped_type
Definition: daw_json_link_types.h:903
static constexpr bool must_be_class_member
Definition: daw_json_link_types.h:898
Definition: daw_json_link_types.h:518
static constexpr daw::string_view name
Definition: daw_json_link_types.h:520
Definition: daw_json_link_types.h:100
void i_am_a_json_member_list
Definition: daw_json_link_types.h:101
static constexpr DAW_ATTRIB_FLATTEN json_details::json_result< JsonClass > parse_to_class(ParseState &parse_state, template_param< JsonClass >)
Definition: daw_json_link_types.h:128
json_details::json_class_parse_result_t< Constructor, json_member > result_type
Definition: daw_json_link_types.h:122
json_details::json_deduced_type< JsonMember > json_member
Definition: daw_json_link_types.h:103
void i_am_a_json_map_alias
Definition: daw_json_link_types.h:102
static constexpr OutputIterator serialize(OutputIterator it, Member const &m, Value const &)
Definition: daw_json_link_types.h:115
Definition: daw_json_link_types.h:822
static constexpr daw::string_view name
Definition: daw_json_link_types.h:824
Definition: daw_json_link_types.h:1130
static constexpr daw::string_view name
Definition: daw_json_link_types.h:1132
static auto const & to_json_data(tuple_json_mapping< Members... > const &value)
Definition: daw_json_link_types.h:163
Definition: daw_json_traits.h:125
Definition: daw_json_link_types.h:750
static constexpr daw::string_view name
Definition: daw_json_link_types.h:751
Definition: daw_json_link_types.h:1566
static constexpr daw::string_view name
Definition: daw_json_link_types.h:1568
Definition: daw_json_link_types.h:1453
static constexpr daw::string_view name
Definition: daw_json_link_types.h:1455
Definition: daw_json_link_types.h:33
void i_am_a_json_member_list
Definition: daw_json_link_types.h:34
json_details::json_class_parse_result_t< Constructor, JsonMembers... > result_type
Definition: daw_json_link_types.h:74
static constexpr OutputIterator serialize(OutputIterator it, Tuple< Ts... > const &args, Value const &v)
Definition: daw_json_link_types.h:57
static constexpr DAW_ATTRIB_FLATTEN json_details::json_result< JsonClass > parse_to_class(ParseState &parse_state, template_param< JsonClass >)
Definition: daw_json_link_types.h:88
Definition: daw_json_link_types.h:414
static constexpr daw::string_view name
Definition: daw_json_link_types.h:416
Definition: daw_json_link_types.h:206
void i_am_a_json_member_list
Definition: daw_json_link_types.h:207
static constexpr OutputIterator serialize(OutputIterator it, Tuple< Ts... > const &args, Value const &v)
Definition: daw_json_link_types.h:221
void i_am_a_ordered_member_list
Definition: daw_json_link_types.h:208
json_details::json_class_parse_result_t< Constructor, json_details::ordered_member_subtype_t< json_details::json_deduced_type< JsonMembers > >... > result_type
Definition: daw_json_link_types.h:242
static constexpr json_details::json_result< JsonClass > parse_to_class(ParseState &parse_state, template_param< JsonClass >)
Definition: daw_json_link_types.h:255
Definition: daw_json_link_types.h:1742
static constexpr daw::string_view name
Definition: daw_json_link_types.h:1743
Definition: daw_json_link_types.h:1338
static constexpr daw::string_view name
Definition: daw_json_link_types.h:1340
Definition: daw_json_link_types.h:603
static constexpr daw::string_view name
Definition: daw_json_link_types.h:606
Definition: daw_json_link_types.h:685
static constexpr daw::string_view name
Definition: daw_json_link_types.h:686
Definition: daw_json_link_types.h:280
void i_am_a_submember_tagged_variant
Definition: daw_json_link_types.h:282
json_details::json_class_parse_result_t< Constructor, json_details::json_deduced_type< daw::traits::first_type< JsonClasses... > >> result_type
Definition: daw_json_link_types.h:311
static constexpr json_details::from_json_result_t< JsonClass > parse_to_class(ParseState &parse_state, template_param< JsonClass >)
Definition: daw_json_link_types.h:324
void i_am_a_json_member_list
Definition: daw_json_link_types.h:281
static constexpr OutputIterator serialize(OutputIterator it, Value const &v)
Definition: daw_json_link_types.h:292
Definition: daw_json_link_types.h:1035
static constexpr daw::string_view name
Definition: daw_json_link_types.h:1037
Definition: daw_json_link_types.h:1643
static constexpr daw::string_view name
Definition: daw_json_link_types.h:1644
Definition: daw_json_link_types_fwd.h:316
Definition: daw_json_link_types.h:941
static constexpr daw::string_view name
Definition: daw_json_link_types.h:942
Definition: daw_json_traits.h:331
Definition: daw_json_link_types.h:175
void i_am_a_json_type
Definition: daw_json_link_types.h:177
static constexpr std::size_t member_index
Definition: daw_json_link_types.h:178
void i_am_an_ordered_member
Definition: daw_json_link_types.h:176
json_details::json_deduced_type< JsonMember > json_member
Definition: daw_json_link_types.h:183
typename json_member::parse_to_t parse_to_t
Definition: daw_json_link_types.h:184
Definition: daw_json_link_types.h:150
std::tuple< typename Members::parse_to_t... > members
Definition: daw_json_link_types.h:151
constexpr tuple_json_mapping(Ts &&...values)
Definition: daw_json_link_types.h:154
#define DAW_JSON_VER
Definition: version.h:11