DAW JSON Link
daw_json_link.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 
15 #include "impl/daw_json_traits.h"
16 #include "impl/daw_json_value.h"
17 
18 #include <daw/daw_array.h>
19 #include <daw/daw_bounded_string.h>
20 #include <daw/daw_parser_helper_sv.h>
21 #include <daw/daw_traits.h>
22 #include <daw/daw_utility.h>
23 #include <daw/daw_visit.h>
24 #include <daw/iterator/daw_back_inserter.h>
25 
26 #include <array>
27 #include <iterator>
28 #include <memory>
29 #include <string>
30 #include <string_view>
31 #include <tuple>
32 
33 namespace daw::json {
39  template<typename... JsonMembers>
42  static_assert( ( json_details::is_a_json_type_v<JsonMembers> and ... ),
43  "Only JSON Link mapping types can appear in a "
44  "json_member_list(e.g. json_number, json_string...)" );
45  static_assert(
46  not( is_no_name<JsonMembers> or ... ),
47  "All members must have a name and not no_name in a json_member_list" );
58  template<typename OutputIterator, typename Value, typename... Args>
59  [[maybe_unused, nodiscard]] static inline constexpr OutputIterator
60  serialize( OutputIterator it, std::tuple<Args...> const &args,
61  Value const &v ) {
62  static_assert( json_details::CheckMatch<Value, sizeof...( Args ),
63  sizeof...( JsonMembers )>::value,
64  "Argument count is incorrect" );
65 
66  return json_details::serialize_json_class<JsonMembers...>(
67  it, std::index_sequence_for<Args...>{ }, args, v );
68  }
69 
79  template<typename T, typename Range>
80  [[maybe_unused, nodiscard]] static inline constexpr T
81  parse_to_class( Range &rng ) {
82  return json_details::parse_json_class<T, JsonMembers...>(
83  rng, std::index_sequence_for<JsonMembers...>{ } );
84  }
85  };
86 
87  template<typename... Members>
88  struct json_data_contract<tuple_json_mapping<Members...>> {
89  using type = json_member_list<Members...>;
90 
91  [[nodiscard, maybe_unused]] static inline auto const &
93  return value.members;
94  }
95  };
96 
97  /***
98  * In a json_ordered_member_list, this allows specifying the position in the
99  * array to parse this member from
100  * @tparam Index Position in array where member is
101  * @tparam JsonMember type of value( e.g. int, json_string )
102  */
103  template<std::size_t Index, typename JsonMember>
106  using i_am_a_json_type = void;
107  static constexpr std::size_t member_index = Index;
108  using json_member = json_details::unnamed_default_type_mapping<JsonMember>;
109  using parse_to_t = typename json_details::unnamed_default_type_mapping<
110  JsonMember>::parse_to_t;
111  };
112 
113  namespace json_details {
114  template<typename JsonMember>
115  struct ordered_member_wrapper
116  : json_details::unnamed_default_type_mapping<JsonMember> {};
117  } // namespace json_details
118 
119  /***
120  * Allow extracting elements from a JSON array and constructing from it.
121  * Members can be either normal C++ no_name members, or an ordered_member with
122  * a position. All ordered members must have a value greater than the
123  * previous. The first element in the list, unless it is specified as an
124  * ordered_member, is 0. A non-ordered_member item will be 1 more than the
125  * previous item in the list. All items must have an index greater than the
126  * previous.
127  * @tparam JsonMembers A list of json_TYPE mappings or a json_TYPE mapping
128  * wrapped into a ordered_json_member
129  */
130  template<typename... JsonMembers>
134 
143  template<typename OutputIterator, typename Value, typename... Args>
144  [[maybe_unused, nodiscard]] static inline constexpr OutputIterator
145  serialize( OutputIterator it, std::tuple<Args...> const &args,
146  Value const &v ) {
147  static_assert( sizeof...( Args ) == sizeof...( JsonMembers ),
148  "Argument count is incorrect" );
149 
150  static_assert( ( json_details::is_a_json_type_v<
151  json_details::ordered_member_wrapper<JsonMembers>> and
152  ... ),
153  "Only value JSON types can be used" );
154  return json_details::serialize_ordered_json_class<
155  json_details::ordered_member_wrapper<JsonMembers>...>(
156  it, std::index_sequence_for<Args...>{ }, args, v );
157  }
158 
168  template<typename T, typename Range>
169  [[maybe_unused, nodiscard]] static inline constexpr T
170  parse_to_class( Range &rng ) {
171  return json_details::parse_ordered_json_class<
172  T, json_details::ordered_member_wrapper<JsonMembers>...>( rng );
173  }
174  };
175 
176  /***
177  * Parse a tagged variant like class where the tag member is in the same class
178  * that is being discriminated. The container type, that will specialize
179  * json_data_constract on, must support the get_if, get_index
180  * @tparam TagMember JSON element to pass to Switcher. Does not have to be
181  * declared in member list
182  * @tparam Switcher A callable that returns an index into JsonClasses when
183  * passed the TagMember object
184  * @tparam JsonClasses List of alternative classes that are mapped via a
185  * json_data_contract
186  */
187  template<typename TagMember, typename Switcher, typename... JsonClasses>
191 
198  template<typename OutputIterator, typename Value>
199  [[maybe_unused, nodiscard]] static inline constexpr OutputIterator
200  serialize( OutputIterator it, Value const &v ) {
201 
202  return daw::visit_nt( v, [&]( auto const &alternative ) {
203  using Alternative = daw::remove_cvref_t<decltype( alternative )>;
204  static_assert( ( std::is_same_v<Alternative, JsonClasses> or ... ),
205  "Unexpected alternative type" );
206  static_assert( json_details::has_json_to_json_data_v<Alternative>,
207  "Alternative type does not have a to_json_data_member "
208  "in it's json_data_contract specialization" );
209 
210  return json_details::member_to_string<json_class<no_name, Alternative>>(
211  it, alternative );
212  } );
213  }
214 
224  template<typename T, typename Range>
225  [[maybe_unused, nodiscard]] static inline constexpr T
226  parse_to_class( Range &rng ) {
227  using tag_class_t = tuple_json_mapping<TagMember>;
228  std::size_t const idx = [rng]( ) mutable {
229  return Switcher{ }( std::get<0>(
230  json_details::parse_value<json_class<no_name, tag_class_t>>(
232  .members ) );
233  }( );
234  return json_details::parse_nth_class<0, T, false,
236  idx, rng );
237  }
238  };
239 
240  /**************************************************
241  * Member types - These are the mapping classes to
242  * describe the constructor of your classes
243  **************************************************/
244 
254  template<JSONNAMETYPE Name, typename T, LiteralAsStringOpt LiteralAsString,
255  typename Constructor, JsonRangeCheck RangeCheck,
256  JsonNullable Nullable>
257  struct json_number {
258  using i_am_a_json_type = void;
259  using wrapped_type = T;
260  using base_type = json_details::unwrap_type<T, Nullable>;
261  static_assert( not std::is_same_v<void, base_type>,
262  "Failed to detect base type" );
263 
264  static_assert( daw::is_arithmetic_v<base_type>,
265  "json_number requires an arithmetic type" );
266  using parse_to_t = std::invoke_result_t<Constructor, base_type>;
267  static_assert(
268  Nullable == JsonNullable::Never or
269  std::is_same_v<parse_to_t, std::invoke_result_t<Constructor>>,
270  "Default ctor of constructor must match that of base" );
271  using constructor_t = Constructor;
272  static constexpr daw::string_view name = Name;
273 
274  static constexpr JsonParseTypes expected_type =
275  get_parse_type_v<json_details::number_parse_type_v<base_type>, Nullable>;
276 
278  json_details::number_parse_type_v<base_type>;
279 
280  static constexpr LiteralAsStringOpt literal_as_string = LiteralAsString;
281  static constexpr JsonRangeCheck range_check = RangeCheck;
283  JsonBaseParseTypes::Number;
284  static constexpr bool nullable = Nullable == JsonNullable::Nullable;
285  };
286 
294  template<JSONNAMETYPE Name, typename T, LiteralAsStringOpt LiteralAsString,
295  typename Constructor, JsonNullable Nullable>
296  struct json_bool {
297  using i_am_a_json_type = void;
298  using wrapped_type = T;
299  using base_type = json_details::unwrap_type<T, Nullable>;
300  static_assert( not std::is_same_v<void, base_type>,
301  "Failed to detect base type" );
302  using parse_to_t = std::invoke_result_t<Constructor, base_type>;
303  using constructor_t = Constructor;
304 
305  static constexpr JsonParseTypes expected_type =
306  get_parse_type_v<JsonParseTypes::Bool, Nullable>;
307  static constexpr JsonParseTypes base_expected_type = JsonParseTypes::Bool;
308 
309  static constexpr daw::string_view name = Name;
310  static constexpr LiteralAsStringOpt literal_as_string = LiteralAsString;
312  JsonBaseParseTypes::Bool;
313  static constexpr bool nullable = Nullable == JsonNullable::Nullable;
314  };
315 
331  template<JSONNAMETYPE Name, typename String, typename Constructor,
332  JsonNullable EmptyStringNull, EightBitModes EightBitMode,
335  using i_am_a_json_type = void;
336  using constructor_t = Constructor;
337  using wrapped_type = String;
338  using base_type = json_details::unwrap_type<String, Nullable>;
339  static_assert( not std::is_same_v<void, base_type>,
340  "Failed to detect base type" );
341  using parse_to_t = std::invoke_result_t<Constructor, base_type>;
342 
343  static constexpr daw::string_view name = Name;
344  static constexpr JsonParseTypes expected_type =
345  get_parse_type_v<JsonParseTypes::StringRaw, Nullable>;
347  JsonParseTypes::StringRaw;
348  static constexpr JsonNullable empty_is_null = JsonNullable::Never;
349  static constexpr EightBitModes eight_bit_mode = EightBitMode;
351  JsonBaseParseTypes::String;
352  static constexpr bool nullable = Nullable == JsonNullable::Nullable;
353  static constexpr AllowEscapeCharacter allow_escape_character = AllowEscape;
354  };
355 
368  template<JSONNAMETYPE Name, typename String, typename Constructor,
369  JsonNullable EmptyStringNull, EightBitModes EightBitMode,
371  struct json_string {
372  using i_am_a_json_type = void;
373  using constructor_t = Constructor;
374  using wrapped_type = String;
375  using base_type = json_details::unwrap_type<String, Nullable>;
376  static_assert( not std::is_same_v<void, base_type>,
377  "Failed to detect base type" );
378  using parse_to_t = std::invoke_result_t<Constructor, base_type>;
379 
380  static constexpr daw::string_view name = Name;
381  static constexpr JsonParseTypes expected_type =
382  get_parse_type_v<JsonParseTypes::StringEscaped, Nullable>;
384  JsonParseTypes::StringEscaped;
385  static constexpr JsonNullable empty_is_null = EmptyStringNull;
386  static constexpr EightBitModes eight_bit_mode = EightBitMode;
388  JsonBaseParseTypes::String;
389  static constexpr bool nullable = Nullable == JsonNullable::Nullable;
390  };
391 
399  template<JSONNAMETYPE Name, typename T, typename Constructor,
401  struct json_date {
402  using i_am_a_json_type = void;
403  using constructor_t = Constructor;
404  using wrapped_type = T;
405  using base_type = json_details::unwrap_type<T, Nullable>;
406  static_assert( not std::is_same_v<void, base_type>,
407  "Failed to detect base type" );
408  using parse_to_t =
409  std::invoke_result_t<Constructor, char const *, std::size_t>;
410 
411  static constexpr daw::string_view name = Name;
412  static constexpr JsonParseTypes expected_type =
413  get_parse_type_v<JsonParseTypes::Date, Nullable>;
414  static constexpr JsonParseTypes base_expected_type = JsonParseTypes::Date;
416  JsonBaseParseTypes::String;
417  static constexpr bool nullable = Nullable == JsonNullable::Nullable;
418  };
419 
429  template<JSONNAMETYPE Name, typename T, typename Constructor,
431  struct json_class {
432  using i_am_a_json_type = void;
433  using constructor_t = Constructor;
434  using wrapped_type = T;
435  using base_type = json_details::unwrap_type<T, Nullable>;
436  static_assert( not std::is_same_v<void, base_type>,
437  "Failed to detect base type" );
438  using parse_to_t = T;
439  static constexpr daw::string_view name = Name;
440  static constexpr JsonParseTypes expected_type =
441  get_parse_type_v<JsonParseTypes::Class, Nullable>;
442  static constexpr JsonParseTypes base_expected_type = JsonParseTypes::Class;
444  JsonBaseParseTypes::Class;
445  static constexpr bool nullable = Nullable == JsonNullable::Nullable;
446  };
447 
448  /***
449  * A type to hold the types for parsing variants.
450  * @tparam JsonElements Up to one of a JsonElement that is a JSON number,
451  * string, object, or array
452  */
453  template<typename... JsonElements>
456  static_assert(
457  sizeof...( JsonElements ) <= 5U,
458  "There can be at most 5 items, one for each JsonBaseParseTypes" );
460  std::tuple<json_details::unnamed_default_type_mapping<JsonElements>...>;
461  static constexpr std::size_t base_map[5] = {
462  json_details::find_json_element<JsonBaseParseTypes::Number>(
463  { json_details::unnamed_default_type_mapping<
464  JsonElements>::underlying_json_type... } ),
465  json_details::find_json_element<JsonBaseParseTypes::Bool>(
466  { json_details::unnamed_default_type_mapping<
467  JsonElements>::underlying_json_type... } ),
468  json_details::find_json_element<JsonBaseParseTypes::String>(
469  { json_details::unnamed_default_type_mapping<
470  JsonElements>::underlying_json_type... } ),
471  json_details::find_json_element<JsonBaseParseTypes::Class>(
472  { json_details::unnamed_default_type_mapping<
473  JsonElements>::underlying_json_type... } ),
474  json_details::find_json_element<JsonBaseParseTypes::Array>(
475  { json_details::unnamed_default_type_mapping<
476  JsonElements>::underlying_json_type... } ) };
477  };
478 
479  /***
480  * Link to a nullable JSON variant
481  * @tparam Name name of JSON member to link to
482  * @tparam T type that has specialization of
483  * daw::json::json_data_contract
484  * @tparam JsonElements a json_variant_type_list
485  * @tparam Constructor A callable used to construct T. The
486  * default supports normal and aggregate construction
487  */
488  template<JSONNAMETYPE Name, typename T, typename JsonElements,
489  typename Constructor, JsonNullable Nullable>
490  struct json_variant {
491  using i_am_a_json_type = void;
492  static_assert(
493  std::is_same_v<typename JsonElements::i_am_variant_type_list, void>,
494  "Expected a json_variant_type_list" );
495  using constructor_t = Constructor;
496  using wrapped_type = T;
497  using base_type = json_details::unwrap_type<T, Nullable>;
498  static_assert( not std::is_same_v<void, base_type>,
499  "Failed to detect base type" );
500  using parse_to_t = T;
501  static constexpr daw::string_view name = Name;
502  static constexpr JsonParseTypes expected_type =
503  get_parse_type_v<JsonParseTypes::Variant, Nullable>;
505  JsonParseTypes::Variant;
506 
509  using json_elements = JsonElements;
510  static constexpr bool nullable = Nullable == JsonNullable::Nullable;
511  };
512 
513  /***
514  * Link to a nullable variant like data type that is discriminated via another
515  * member.
516  * @tparam Name name of JSON member to link to
517  * @tparam T type of value to construct
518  * @tparam TagMember JSON element to pass to Switcher. Does not have to be
519  * declared in member list
520  * @tparam Switcher A callable that returns an index into JsonElements when
521  * passed the TagMember object in parent member list
522  * @tparam JsonElements a json_tagged_variant_type_list, defaults to type
523  * elements of T when T is a std::variant and they are all auto mappable
524  * @tparam Constructor A callable used to construct T. The
525  * default supports normal and aggregate construction
526  */
527  template<JSONNAMETYPE Name, typename T, typename TagMember, typename Switcher,
528  typename JsonElements, typename Constructor, JsonNullable Nullable>
530  using i_am_a_json_type = void;
531  using i_am_a_tagged_variant = void;
532  static_assert(
533  std::is_same_v<typename JsonElements::i_am_tagged_variant_type_list,
534  void>,
535  "Expected a json_member_list" );
536 
537  static_assert( std::is_same_v<typename TagMember::i_am_a_json_type, void>,
538  "JSON member types must be passed as "
539  "TagMember" );
540  using constructor_t = Constructor;
541  using wrapped_type = T;
542  using tag_member = TagMember;
543  using switcher = Switcher;
544  using base_type = json_details::unwrap_type<T, Nullable>;
545  static_assert( not std::is_same_v<void, base_type>,
546  "Failed to detect base type" );
547  using parse_to_t = T;
548  static constexpr daw::string_view name = Name;
549  static constexpr JsonParseTypes expected_type =
550  get_parse_type_v<JsonParseTypes::VariantTagged, Nullable>;
552  JsonParseTypes::VariantTagged;
555  using json_elements = JsonElements;
556  static constexpr bool nullable = Nullable == JsonNullable::Nullable;
557  };
558 
568  template<JSONNAMETYPE Name, typename T, typename FromJsonConverter,
569  typename ToJsonConverter, CustomJsonTypes CustomJsonType,
571  struct json_custom {
572  using i_am_a_json_type = void;
573  using to_converter_t = ToJsonConverter;
574  using from_converter_t = FromJsonConverter;
575  using constructor_t = FromJsonConverter;
576 
577  using base_type = json_details::unwrap_type<T, Nullable>;
578  static_assert( not std::is_same_v<void, base_type>,
579  "Failed to detect base type" );
580  using parse_to_t =
581  std::invoke_result_t<FromJsonConverter, std::string_view>;
582  static_assert( std::is_invocable_v<FromJsonConverter, std::string_view>,
583  "FromConverter must be callable with a std::string_view" );
584  static_assert(
585  std::is_invocable_v<ToJsonConverter, parse_to_t> or
586  std::is_invocable_r_v<char const *, ToJsonConverter, char const *,
587  parse_to_t>,
588  "ToConverter must be callable with T or T and and OutputIterator" );
589  static constexpr daw::string_view name = Name;
590  static constexpr JsonParseTypes expected_type =
591  get_parse_type_v<JsonParseTypes::Custom, Nullable>;
592  static constexpr JsonParseTypes base_expected_type = JsonParseTypes::Custom;
593  static constexpr CustomJsonTypes custom_json_type = CustomJsonType;
595  JsonBaseParseTypes::String;
596  static constexpr bool nullable = Nullable == JsonNullable::Nullable;
597  };
598 
599  namespace json_details {
600  template<JSONNAMETYPE Name, typename JsonElement, typename Container,
601  typename Constructor, JsonNullable Nullable>
602  struct json_array_detect {
603  using i_am_a_json_type = void;
604  using json_element_t =
605  json_details::unnamed_default_type_mapping<JsonElement>;
606  static_assert( not std::is_same_v<json_element_t, void>,
607  "Unknown JsonElement type." );
608  static_assert( json_details::is_a_json_type_v<json_element_t>,
609  "Error determining element type" );
610  using constructor_t = Constructor;
611 
612  using base_type = json_details::unwrap_type<Container, Nullable>;
613  static_assert( not std::is_same_v<void, base_type>,
614  "Failed to detect base type" );
615  using parse_to_t = std::invoke_result_t<Constructor>;
616  static constexpr daw::string_view name = Name;
617  static constexpr JsonParseTypes expected_type =
618  get_parse_type_v<JsonParseTypes::Array, Nullable>;
619  static constexpr JsonParseTypes base_expected_type =
620  JsonParseTypes::Array;
621 
622  static_assert( json_element_t::name == no_name,
623  "All elements of json_array must be have no_name" );
624  static constexpr JsonBaseParseTypes underlying_json_type =
625  JsonBaseParseTypes::Array;
626  static constexpr bool nullable = Nullable == JsonNullable::Nullable;
627  };
628  } // namespace json_details
629 
641  template<JSONNAMETYPE Name, typename JsonElement, typename Container,
642  typename Constructor, JsonNullable Nullable>
643  struct json_array {
644  using i_am_a_json_type = void;
646  json_details::unnamed_default_type_mapping<JsonElement>;
647  static_assert( not std::is_same_v<json_element_t, void>,
648  "Unknown JsonElement type." );
649  static_assert( json_details::is_a_json_type_v<json_element_t>,
650  "Error determining element type" );
651  using constructor_t = Constructor;
652 
653  using base_type = json_details::unwrap_type<Container, Nullable>;
654  static_assert( not std::is_same_v<void, base_type>,
655  "Failed to detect base type" );
656  using parse_to_t = std::invoke_result_t<Constructor>;
657  static constexpr daw::string_view name = Name;
658  static constexpr JsonParseTypes expected_type =
659  get_parse_type_v<JsonParseTypes::Array, Nullable>;
660  static constexpr JsonParseTypes base_expected_type = JsonParseTypes::Array;
661 
662  static_assert( json_element_t::name == no_name,
663  "All elements of json_array must be have no_name" );
665  JsonBaseParseTypes::Array;
666  static constexpr bool nullable = Nullable == JsonNullable::Nullable;
667  };
668 
683  template<JSONNAMETYPE Name, typename Container, typename JsonValueType,
684  typename JsonKeyType, typename Constructor, JsonNullable Nullable>
685  struct json_key_value {
686  using i_am_a_json_type = void;
687  using constructor_t = Constructor;
688  using base_type = json_details::unwrap_type<Container, Nullable>;
689  static_assert( not std::is_same_v<void, base_type>,
690  "Failed to detect base type" );
691  using parse_to_t = std::invoke_result_t<Constructor>;
693  json_details::unnamed_default_type_mapping<JsonValueType>;
694  static_assert( not std::is_same_v<json_element_t, void>,
695  "Unknown JsonValueType type." );
696  static_assert( json_element_t::name == no_name,
697  "Value member name must be the default no_name" );
698 
699  using json_key_t = json_details::unnamed_default_type_mapping<JsonKeyType>;
700  static_assert( not std::is_same_v<json_key_t, void>,
701  "Unknown JsonKeyType type." );
702  static_assert( json_key_t::name == no_name,
703  "Key member name must be the default no_name" );
704 
705  static constexpr daw::string_view name = Name;
706  static constexpr JsonParseTypes expected_type =
707  get_parse_type_v<JsonParseTypes::KeyValue, Nullable>;
709  JsonParseTypes::KeyValue;
711  JsonBaseParseTypes::Class;
712  static constexpr bool nullable = Nullable == JsonNullable::Nullable;
713  };
714 
730  template<JSONNAMETYPE Name, typename Container, typename JsonValueType,
731  typename JsonKeyType, typename Constructor, JsonNullable Nullable>
733  using i_am_a_json_type = void;
734  using constructor_t = Constructor;
735  using base_type = json_details::unwrap_type<Container, Nullable>;
736  static_assert( not std::is_same_v<void, base_type>,
737  "Failed to detect base type" );
738  using parse_to_t = std::invoke_result_t<Constructor>;
739  using json_key_t = json_details::unnamed_default_type_mapping<
740  JsonKeyType, json_details::default_key_name>;
741  static_assert( not std::is_same_v<json_key_t, void>,
742  "Unknown JsonKeyType type." );
743  static_assert( daw::string_view( json_key_t::name ) !=
744  daw::string_view( no_name ),
745  "Must supply a valid key member name" );
746  using json_value_t = json_details::unnamed_default_type_mapping<
747  JsonValueType, json_details::default_value_name>;
748 
749  using json_class_t =
751  static_assert( not std::is_same_v<json_value_t, void>,
752  "Unknown JsonValueType type." );
753  static_assert( daw::string_view( json_value_t::name ) !=
754  daw::string_view( no_name ),
755  "Must supply a valid value member name" );
756  static_assert( daw::string_view( json_key_t::name ) !=
757  daw::string_view( json_value_t::name ),
758  "Key and Value member names cannot be the same" );
759  static constexpr daw::string_view name = Name;
760  static constexpr JsonParseTypes expected_type =
761  get_parse_type_v<JsonParseTypes::KeyValueArray, Nullable>;
763  JsonParseTypes::KeyValueArray;
765  JsonBaseParseTypes::Array;
766  static constexpr bool nullable = Nullable == JsonNullable::Nullable;
767  };
768 
769  /***
770  * An untyped JSON value
771  */
773 
774  /***
775  * A name/value pair of string_view/json_value
776  */
778 
779  /***
780  * Do not parse this member but return a T that can be used to
781  * parse later. Any whitespace surrounding the value may not be preserved.
782  *
783  * @tparam Name name of JSON member to link to
784  * @tparam T destination type. Must be constructable from a char const * and
785  * a std::size_t
786  * @tparam Constructor A callable used to construct T. The
787  * @tparam Nullable Does the value have to exist in the document or can it
788  * have a null value
789  */
790  template<JSONNAMETYPE Name, typename T = json_value,
791  typename Constructor = daw::construct_a_t<T>,
792  JsonNullable Nullable = JsonNullable::Never>
793  struct json_delayed {
794  using i_am_a_json_type = void;
796  using constructor_t = Constructor;
797  using base_type = json_details::unwrap_type<T, Nullable>;
798  static_assert( not std::is_same_v<void, base_type>,
799  "Failed to detect base type" );
800 
801  using parse_to_t =
802  std::invoke_result_t<Constructor, char const *, char const *>;
803  static constexpr daw::string_view name = Name;
804 
808 
811  static constexpr bool nullable = Nullable == JsonNullable::Nullable;
812  };
813 
823  template<typename JsonMember,
824  typename ParsePolicy = NoCommentSkippingPolicyChecked,
825  bool KnownBounds = false>
826  [[maybe_unused, nodiscard]] constexpr auto
827  from_json( std::string_view json_data ) {
828  daw_json_assert( not json_data.empty( ), ErrorReason::EmptyJSONDocument );
829  using json_member = json_details::unnamed_default_type_mapping<JsonMember>;
830  auto rng = ParsePolicy( json_data.data( ),
831  json_data.data( ) +
832  static_cast<ptrdiff_t>( json_data.size( ) ) );
833 
834  return json_details::parse_value<json_member, KnownBounds>(
836  }
837 
847  template<typename JsonMember,
848  typename ParsePolicy = NoCommentSkippingPolicyChecked,
849  bool KnownBounds = false, typename Allocator>
850  [[maybe_unused, nodiscard]] constexpr auto
851  from_json_alloc( std::string_view json_data, Allocator &alloc ) {
852  daw_json_assert( not json_data.empty( ), ErrorReason::EmptyJSONDocument );
853  using json_member = json_details::unnamed_default_type_mapping<JsonMember>;
854  static_assert( json_details::is_allocator_v<Allocator> );
855  char const *f = json_data.data( );
856  char const *l = f + static_cast<ptrdiff_t>( json_data.size( ) );
857  auto rng = ParsePolicy::with_allocator( f, l, alloc );
858 
859  return json_details::parse_value<json_member, KnownBounds>(
861  }
862 
863  /***
864  * Parse a JSONMember from the json_data starting at member_path.
865  * @tparam JsonMember The type of the item being parsed
866  * @param json_data JSON string data
867  * @param member_path A dot separated path of member names, default is the
868  * root. Array indices are specified with square brackets e.g. [5] is the 6th
869  * item
870  * @tparam KnownBounds The bounds of the json_data are known to contain the
871  * whole value
872  * @return A value reified from the JSON data member
873  */
874  template<typename JsonMember,
875  typename ParsePolicy = NoCommentSkippingPolicyChecked,
876  bool KnownBounds = false>
877  [[maybe_unused, nodiscard]] constexpr auto
878  from_json( std::string_view json_data, std::string_view member_path ) {
879  daw_json_assert( not json_data.empty( ), ErrorReason::EmptyJSONDocument );
880  daw_json_assert( not member_path.empty( ), ErrorReason::EmptyJSONPath );
881  using json_member = json_details::unnamed_default_type_mapping<JsonMember>;
882  auto [is_found, rng] = json_details::find_range<ParsePolicy>(
883  json_data, { std::data( member_path ), std::size( member_path ) } );
884  if constexpr( json_member::expected_type == JsonParseTypes::Null ) {
885  if( not is_found ) {
886  return typename json_member::constructor_t{ }( );
887  }
888  } else {
889  daw_json_assert( is_found, ErrorReason::JSONPathNotFound );
890  }
891  return json_details::parse_value<json_member, KnownBounds>(
893  }
894 
895  /***
896  * Parse a JSONMember from the json_data starting at member_path.
897  * @tparam JsonMember The type of the item being parsed
898  * @param json_data JSON string data
899  * @param member_path A dot separated path of member names, default is the
900  * root. Array indices are specified with square brackets e.g. [5] is the 6th
901  * item
902  * @tparam KnownBounds The bounds of the json_data are known to contain the
903  * whole value
904  * @return A value reified from the JSON data member
905  */
906  template<typename JsonMember,
907  typename ParsePolicy = NoCommentSkippingPolicyChecked,
908  bool KnownBounds = false, typename Allocator>
909  [[maybe_unused, nodiscard]] constexpr auto
910  from_json_alloc( std::string_view json_data, std::string_view member_path,
911  Allocator &alloc ) {
912  static_assert( json_details::is_allocator_v<Allocator> );
913  daw_json_assert( not json_data.empty( ), ErrorReason::EmptyJSONDocument );
914  daw_json_assert( not member_path.empty( ), ErrorReason::EmptyJSONPath );
915  using json_member = json_details::unnamed_default_type_mapping<JsonMember>;
916  auto [is_found, rng] = json_details::find_range<ParsePolicy>(
917  json_data, { std::data( member_path ), std::size( member_path ) },
918  alloc );
919  if constexpr( json_member::expected_type == JsonParseTypes::Null ) {
920  if( not is_found ) {
921  return typename json_member::constructor_t{ }( );
922  }
923  } else {
924  daw_json_assert( is_found, ErrorReason::JSONPathNotFound );
925  }
926  return json_details::parse_value<json_member, KnownBounds>(
928  }
929 
930  template<typename JsonMember,
931  typename ParsePolicy = NoCommentSkippingPolicyChecked,
932  bool KnownBounds = false, typename Range>
933  [[maybe_unused, nodiscard]] inline constexpr auto
935  using json_member = json_details::unnamed_default_type_mapping<JsonMember>;
936  auto const json_data = value.get_string_view( );
937  auto rng = ParsePolicy( json_data.data( ),
938  json_data.data( ) +
939  static_cast<ptrdiff_t>( json_data.size( ) ) );
940 
941  return json_details::parse_value<json_member, KnownBounds>(
943  }
944 
945  template<typename JsonMember,
946  typename ParsePolicy = NoCommentSkippingPolicyChecked,
947  bool KnownBounds = false, typename Range>
948  [[maybe_unused, nodiscard]] constexpr auto
949  from_json( basic_json_value<Range> value, std::string_view member_path ) {
950  using json_member = json_details::unnamed_default_type_mapping<JsonMember>;
951  auto const json_data = value.get_string_view( );
952  auto [is_found, rng] = json_details::find_range<ParsePolicy>(
953  json_data, { std::data( member_path ), std::size( member_path ) } );
954  if constexpr( json_member::expected_type == JsonParseTypes::Null ) {
955  if( not is_found ) {
956  return typename json_member::constructor_t{ }( );
957  }
958  } else {
959  daw_json_assert( is_found, ErrorReason::JSONPathNotFound );
960  }
961  return json_details::parse_value<json_member, KnownBounds>(
963  }
964 
973  template<typename Value,
974  typename JsonClass =
975  typename json_details::unnamed_default_type_mapping<Value>,
976  typename OutputIterator>
977  [[maybe_unused]] constexpr OutputIterator to_json( Value const &value,
978  OutputIterator out_it ) {
979  if constexpr( std::is_pointer_v<OutputIterator> ) {
980  daw_json_assert( out_it, ErrorReason::NullOutputIterator );
981  }
982 
983  out_it = json_details::member_to_string<JsonClass>( out_it, value );
984  return out_it;
985  }
986 
997  template<typename Result = std::string, typename Value,
998  typename JsonClass =
999  typename json_details::unnamed_default_type_mapping<Value>>
1000  [[maybe_unused, nodiscard]] constexpr Result to_json( Value const &value ) {
1001  Result result{ };
1002  to_json<Value, JsonClass>( value, daw::back_inserter( result ) );
1003  return result;
1004  }
1005 
1020  template<typename JsonElement,
1021  typename Container =
1022  std::vector<typename json_details::unnamed_default_type_mapping<
1023  JsonElement>::parse_to_t>,
1024  typename ParsePolicy = NoCommentSkippingPolicyChecked,
1025  typename Constructor = daw::construct_a_t<Container>,
1026  bool KnownBounds = false>
1027  [[maybe_unused, nodiscard]] constexpr Container
1028  from_json_array( std::string_view json_data,
1029  std::string_view member_path = "" ) {
1030  daw_json_assert( not json_data.empty( ), ErrorReason::EmptyJSONDocument );
1031  daw_json_assert( member_path.data( ) != nullptr,
1032  ErrorReason::EmptyJSONPath );
1033  using element_type =
1034  json_details::unnamed_default_type_mapping<JsonElement>;
1035  static_assert( not std::is_same_v<element_type, void>,
1036  "Unknown JsonElement type." );
1037 
1039 
1040  auto [is_found, rng] = json_details::find_range<ParsePolicy>(
1041  json_data, { member_path.data( ), member_path.size( ) } );
1042 
1043  if constexpr( parser_t::expected_type == JsonParseTypes::Null ) {
1044  if( not is_found ) {
1045  return typename parser_t::constructor_t{ }( );
1046  }
1047  } else {
1048  daw_json_assert( is_found, ErrorReason::JSONPathNotFound );
1049  }
1050  rng.trim_left_unchecked( );
1051 #if defined( _MSC_VER ) and not defined( __clang__ )
1052  // Work around MSVC ICE
1053  daw_json_assert( rng.is_opening_bracket_checked( ),
1054  ErrorReason::InvalidArrayStart, rng );
1055 #else
1056  using Range = daw::remove_cvref_t<decltype( rng )>;
1057  daw_json_assert_weak( rng.is_opening_bracket_checked( ),
1058  ErrorReason::InvalidArrayStart, rng );
1059 #endif
1060 
1061  return json_details::parse_value<parser_t, KnownBounds>(
1063  }
1064 
1065  namespace json_details {
1066  /***
1067  * Tag type to indicate that the element of a Container is not being
1068  * specified. This is the default.
1069  */
1070  struct auto_detect_array_element {};
1071  } // namespace json_details
1072 
1082  template<typename JsonElement = json_details::auto_detect_array_element,
1083  typename Container, typename OutputIterator>
1084  [[maybe_unused]] constexpr OutputIterator
1085  to_json_array( Container const &c, OutputIterator out_it ) {
1086  static_assert(
1087  daw::traits::is_container_like_v<daw::remove_cvref_t<Container>>,
1088  "Supplied container must support begin( )/end( )" );
1089 
1090  if constexpr( std::is_pointer_v<OutputIterator> ) {
1091  daw_json_assert( out_it, ErrorReason::NullOutputIterator );
1092  }
1093  *out_it++ = '[';
1094  bool is_first = true;
1095  for( auto const &v : c ) {
1096  using v_type = daw::remove_cvref_t<decltype( v )>;
1097  constexpr bool is_auto_detect_v =
1098  std::is_same_v<JsonElement, json_details::auto_detect_array_element>;
1099  using JsonMember =
1100  std::conditional_t<is_auto_detect_v,
1101  json_details::unnamed_default_type_mapping<v_type>,
1102  JsonElement>;
1103 
1104  static_assert(
1105  not std::is_same_v<
1107  "Unable to detect unnamed mapping" );
1108  static_assert( not std::is_same_v<JsonElement, JsonMember> );
1109  if( is_first ) {
1110  is_first = false;
1111  } else {
1112  *out_it++ = ',';
1113  }
1114  out_it = json_details::member_to_string<JsonMember>( out_it, v );
1115  }
1116  // The last character will be a ',' prior to this
1117  *out_it++ = ']';
1118  return out_it;
1119  }
1120 
1129  template<typename Result = std::string,
1130  typename JsonElement = json_details::auto_detect_array_element,
1131  typename Container>
1132  [[maybe_unused, nodiscard]] constexpr Result to_json_array( Container &&c ) {
1133  static_assert(
1134  daw::traits::is_container_like_v<daw::remove_cvref_t<Container>>,
1135  "Supplied container must support begin( )/end( )" );
1136 
1137  Result result{ };
1138  auto out_it = json_details::basic_appender<Result>( result );
1139  to_json_array<JsonElement>( c, out_it );
1140  return result;
1141  }
1142 
1143 } // namespace daw::json
1144 
1145 #if not defined( DAW_JSON_DISABLE_JSON_STRING_LITERAL )
1146 
1147 /***
1148  * Construct a json_value from a string literal
1149  * @return A json_value representing the json document
1150  */
1151 constexpr daw::json::json_value operator"" _dawjson( char const *ptr,
1152  std::size_t sz ) {
1153  return daw::json::json_value( std::string_view( ptr, sz ) );
1154 }
1155 #endif
daw::json::json_custom::to_converter_t
ToJsonConverter to_converter_t
Definition: daw_json_link.h:573
daw::json::json_array::parse_to_t
std::invoke_result_t< Constructor > parse_to_t
Definition: daw_json_link.h:656
daw::json::JsonParseTypes::Real
@ Real
daw::json::json_variant::json_elements
JsonElements json_elements
Definition: daw_json_link.h:509
daw::json::no_name
constexpr char const no_name[]
Definition: daw_json_parse_common.h:348
daw::json::json_class::nullable
static constexpr bool nullable
Definition: daw_json_link.h:445
daw::json::json_number::base_type
json_details::unwrap_type< T, Nullable > base_type
Definition: daw_json_link.h:260
daw::json::json_key_value_array::json_value_t
json_details::unnamed_default_type_mapping< JsonValueType, json_details::default_value_name > json_value_t
Definition: daw_json_link.h:747
daw::json::from_json_array
constexpr Container from_json_array(std::string_view json_data, std::string_view member_path="")
Definition: daw_json_link.h:1028
daw::json::json_delayed::base_expected_type
static constexpr JsonParseTypes base_expected_type
Definition: daw_json_link.h:806
daw::json::json_date::underlying_json_type
static constexpr JsonBaseParseTypes underlying_json_type
Definition: daw_json_link.h:415
daw::json::json_variant::constructor_t
Constructor constructor_t
Definition: daw_json_link.h:495
daw_json_serialize_impl.h
daw::json::json_string::underlying_json_type
static constexpr JsonBaseParseTypes underlying_json_type
Definition: daw_json_link.h:387
daw::json::json_string::nullable
static constexpr bool nullable
Definition: daw_json_link.h:389
daw_json_value.h
daw::json::json_tagged_variant::tag_member
TagMember tag_member
Definition: daw_json_link.h:542
daw::json::json_string_raw::allow_escape_character
static constexpr AllowEscapeCharacter allow_escape_character
Definition: daw_json_link.h:353
daw::json::json_string_raw::wrapped_type
String wrapped_type
Definition: daw_json_link.h:337
daw::json::json_string_raw::name
static constexpr daw::string_view name
Definition: daw_json_link.h:343
daw::json::basic_json_pair
Definition: daw_json_value.h:34
daw::json::json_string::parse_to_t
std::invoke_result_t< Constructor, base_type > parse_to_t
Definition: daw_json_link.h:378
daw::json::json_number::i_am_a_json_type
void i_am_a_json_type
Definition: daw_json_link.h:258
daw::json::json_key_value::json_element_t
json_details::unnamed_default_type_mapping< JsonValueType > json_element_t
Definition: daw_json_link.h:693
daw::json::json_key_value_array::i_am_a_json_type
void i_am_a_json_type
Definition: daw_json_link.h:733
daw::json::json_number::nullable
static constexpr bool nullable
Definition: daw_json_link.h:284
daw::json::json_variant::underlying_json_type
static constexpr JsonBaseParseTypes underlying_json_type
Definition: daw_json_link.h:507
daw_json_assert
#define daw_json_assert(Bool,...)
Definition: daw_json_assert.h:196
daw::json::json_ordered_member_list::serialize
static constexpr OutputIterator serialize(OutputIterator it, std::tuple< Args... > const &args, Value const &v)
Definition: daw_json_link.h:145
daw::json::json_member_list
Definition: daw_json_link.h:40
daw::json::json_tagged_variant::name
static constexpr daw::string_view name
Definition: daw_json_link.h:548
daw::json::json_string_raw::nullable
static constexpr bool nullable
Definition: daw_json_link.h:352
daw::json::json_tagged_variant
Definition: daw_json_link.h:529
daw::json::json_key_value::name
static constexpr daw::string_view name
Definition: daw_json_link.h:705
daw::json
Definition: daw_json_event_parser.h:17
daw::json::json_array::expected_type
static constexpr JsonParseTypes expected_type
Definition: daw_json_link.h:658
daw::json::json_custom::parse_to_t
std::invoke_result_t< FromJsonConverter, std::string_view > parse_to_t
Definition: daw_json_link.h:581
daw_json_assert_weak
#define daw_json_assert_weak(Bool,...)
Definition: daw_json_assert.h:206
daw::json::json_custom::i_am_a_json_type
void i_am_a_json_type
Definition: daw_json_link.h:572
daw::json::json_string::expected_type
static constexpr JsonParseTypes expected_type
Definition: daw_json_link.h:381
daw::json::json_variant_type_list::base_map
static constexpr std::size_t base_map[5]
Definition: daw_json_link.h:461
daw::json::json_date::nullable
static constexpr bool nullable
Definition: daw_json_link.h:417
daw::json::json_string_raw::parse_to_t
std::invoke_result_t< Constructor, base_type > parse_to_t
Definition: daw_json_link.h:341
daw::json::json_submember_tagged_variant
Definition: daw_json_link.h:188
daw::json::json_custom::constructor_t
FromJsonConverter constructor_t
Definition: daw_json_link.h:575
daw::json::json_tagged_variant::parse_to_t
T parse_to_t
Definition: daw_json_link.h:547
daw::json::json_bool::name
static constexpr daw::string_view name
Definition: daw_json_link.h:309
daw::json::json_key_value::underlying_json_type
static constexpr JsonBaseParseTypes underlying_json_type
Definition: daw_json_link.h:710
daw::json::json_number::range_check
static constexpr JsonRangeCheck range_check
Definition: daw_json_link.h:281
daw::json::json_date
Definition: daw_json_link.h:401
daw::json::json_variant_type_list
Definition: daw_json_link.h:454
daw::json::json_number::underlying_json_type
static constexpr JsonBaseParseTypes underlying_json_type
Definition: daw_json_link.h:282
daw::json::json_date::wrapped_type
T wrapped_type
Definition: daw_json_link.h:404
daw::json::json_string_raw
Definition: daw_json_link.h:334
daw::json::from_json
constexpr auto from_json(std::string_view json_data)
Definition: daw_json_link.h:827
daw::json::json_tagged_variant::base_type
json_details::unwrap_type< T, Nullable > base_type
Definition: daw_json_link.h:544
daw::json::json_bool::parse_to_t
std::invoke_result_t< Constructor, base_type > parse_to_t
Definition: daw_json_link.h:302
daw::json::json_bool::expected_type
static constexpr JsonParseTypes expected_type
Definition: daw_json_link.h:305
daw::json::ordered_json_member::json_member
json_details::unnamed_default_type_mapping< JsonMember > json_member
Definition: daw_json_link.h:108
daw::json::json_key_value::json_key_t
json_details::unnamed_default_type_mapping< JsonKeyType > json_key_t
Definition: daw_json_link.h:699
daw::json::json_class::expected_type
static constexpr JsonParseTypes expected_type
Definition: daw_json_link.h:440
daw::json::EightBitModes
EightBitModes
Definition: daw_json_parse_common.h:411
daw::json::json_custom::underlying_json_type
static constexpr JsonBaseParseTypes underlying_json_type
Definition: daw_json_link.h:594
daw::json::json_ordered_member_list::parse_to_class
static constexpr T parse_to_class(Range &rng)
Definition: daw_json_link.h:170
daw::json::json_bool::constructor_t
Constructor constructor_t
Definition: daw_json_link.h:303
daw::json::json_tagged_variant::constructor_t
Constructor constructor_t
Definition: daw_json_link.h:540
daw::json::json_date::i_am_a_json_type
void i_am_a_json_type
Definition: daw_json_link.h:402
daw::json::json_date::parse_to_t
std::invoke_result_t< Constructor, char const *, std::size_t > parse_to_t
Definition: daw_json_link.h:409
daw::json::json_submember_tagged_variant::parse_to_class
static constexpr T parse_to_class(Range &rng)
Definition: daw_json_link.h:226
daw::json::json_date::constructor_t
Constructor constructor_t
Definition: daw_json_link.h:403
daw::json::json_delayed::expected_type
static constexpr JsonParseTypes expected_type
Definition: daw_json_link.h:805
daw::json::json_array::constructor_t
Constructor constructor_t
Definition: daw_json_link.h:651
daw::json::json_custom::base_type
json_details::unwrap_type< T, Nullable > base_type
Definition: daw_json_link.h:577
daw::json::json_array::base_type
json_details::unwrap_type< Container, Nullable > base_type
Definition: daw_json_link.h:653
daw::json::json_delayed::i_am_a_json_type
void i_am_a_json_type
Definition: daw_json_link.h:794
daw::json::JsonBaseParseTypes
JsonBaseParseTypes
Definition: daw_json_parse_common.h:379
daw::json::json_class::base_expected_type
static constexpr JsonParseTypes base_expected_type
Definition: daw_json_link.h:442
daw::json::json_submember_tagged_variant::serialize
static constexpr OutputIterator serialize(OutputIterator it, Value const &v)
Definition: daw_json_link.h:200
daw::json::json_key_value::base_type
json_details::unwrap_type< Container, Nullable > base_type
Definition: daw_json_link.h:688
daw::json::json_variant::expected_type
static constexpr JsonParseTypes expected_type
Definition: daw_json_link.h:502
daw::json::tuple_json_mapping::members
std::tuple< typename Members::parse_to_t... > members
Definition: daw_json_parse_common.h:42
daw::json::json_bool::base_expected_type
static constexpr JsonParseTypes base_expected_type
Definition: daw_json_link.h:307
daw::json::json_key_value_array::expected_type
static constexpr JsonParseTypes expected_type
Definition: daw_json_link.h:760
daw::json::json_string::empty_is_null
static constexpr JsonNullable empty_is_null
Definition: daw_json_link.h:385
daw::json::json_tagged_variant::expected_type
static constexpr JsonParseTypes expected_type
Definition: daw_json_link.h:549
daw::json::json_array::base_expected_type
static constexpr JsonParseTypes base_expected_type
Definition: daw_json_link.h:660
daw::json::json_string::base_expected_type
static constexpr JsonParseTypes base_expected_type
Definition: daw_json_link.h:383
daw_json_traits.h
daw::json::json_tagged_variant::i_am_a_json_type
void i_am_a_json_type
Definition: daw_json_link.h:530
daw::json::json_number::name
static constexpr daw::string_view name
Definition: daw_json_link.h:272
daw::json::json_class::name
static constexpr daw::string_view name
Definition: daw_json_link.h:439
daw::json::json_string_raw::eight_bit_mode
static constexpr EightBitModes eight_bit_mode
Definition: daw_json_link.h:349
daw::json::json_variant::wrapped_type
T wrapped_type
Definition: daw_json_link.h:496
daw::json::json_class::constructor_t
Constructor constructor_t
Definition: daw_json_link.h:433
daw::json::json_value
basic_json_value< NoCommentSkippingPolicyChecked > json_value
Definition: daw_json_link.h:772
daw::json::ordered_json_member::i_am_an_ordered_member
void i_am_an_ordered_member
Definition: daw_json_link.h:105
daw::json::json_bool::underlying_json_type
static constexpr JsonBaseParseTypes underlying_json_type
Definition: daw_json_link.h:311
daw::json::json_custom::expected_type
static constexpr JsonParseTypes expected_type
Definition: daw_json_link.h:590
daw::json::json_string
Definition: daw_json_link.h:371
daw::json::AllowEscapeCharacter
AllowEscapeCharacter
Definition: daw_json_parse_common.h:418
daw::json::missing_json_data_contract_for
Definition: daw_json_traits.h:31
daw::json::json_tagged_variant::switcher
Switcher switcher
Definition: daw_json_link.h:543
daw::json::json_key_value_array::base_type
json_details::unwrap_type< Container, Nullable > base_type
Definition: daw_json_link.h:735
daw::json::json_custom
Definition: daw_json_link.h:571
daw::json::json_tagged_variant::json_elements
JsonElements json_elements
Definition: daw_json_link.h:555
daw::json::json_date::base_type
json_details::unwrap_type< T, Nullable > base_type
Definition: daw_json_link.h:405
daw::json::json_variant::parse_to_t
T parse_to_t
Definition: daw_json_link.h:500
daw::json::json_string_raw::base_expected_type
static constexpr JsonParseTypes base_expected_type
Definition: daw_json_link.h:346
daw::json::to_json
constexpr OutputIterator to_json(Value const &value, OutputIterator out_it)
Definition: daw_json_link.h:977
daw::json::json_ordered_member_list::i_am_a_json_member_list
void i_am_a_json_member_list
Definition: daw_json_link.h:132
daw::json::basic_json_value::get_string_view
constexpr std::string_view get_string_view() const
Definition: daw_json_value.h:421
daw::json::json_key_value
Definition: daw_json_link.h:685
daw::json::from_json_alloc
constexpr auto from_json_alloc(std::string_view json_data, Allocator &alloc)
Definition: daw_json_link.h:851
daw::json::LiteralAsStringOpt
LiteralAsStringOpt
Definition: daw_json_parse_common.h:503
JSONNAMETYPE
#define JSONNAMETYPE
Definition: daw_json_parse_common.h:346
daw::json::json_bool::wrapped_type
T wrapped_type
Definition: daw_json_link.h:298
daw::json::JsonBaseParseTypes::Number
@ Number
daw::json::json_date::base_expected_type
static constexpr JsonParseTypes base_expected_type
Definition: daw_json_link.h:414
daw::json::json_string::wrapped_type
String wrapped_type
Definition: daw_json_link.h:374
daw::json::json_member_list::i_am_a_json_member_list
void i_am_a_json_member_list
Definition: daw_json_link.h:41
daw::json::to_json_array
constexpr OutputIterator to_json_array(Container const &c, OutputIterator out_it)
Definition: daw_json_link.h:1085
daw::json::basic_json_value
Definition: daw_json_value.h:300
daw_json_parse_policy.h
daw::json::json_key_value::i_am_a_json_type
void i_am_a_json_type
Definition: daw_json_link.h:686
daw::json::json_key_value_array::parse_to_t
std::invoke_result_t< Constructor > parse_to_t
Definition: daw_json_link.h:738
daw::json::json_delayed::underlying_json_type
static constexpr JsonBaseParseTypes underlying_json_type
Definition: daw_json_link.h:809
daw::json::JsonParseTypes
JsonParseTypes
Definition: daw_json_parse_common.h:360
daw::json::json_custom::custom_json_type
static constexpr CustomJsonTypes custom_json_type
Definition: daw_json_link.h:593
daw::json::json_data_contract< tuple_json_mapping< Members... > >::to_json_data
static auto const & to_json_data(tuple_json_mapping< Members... > const &value)
Definition: daw_json_link.h:92
daw::json::json_string::eight_bit_mode
static constexpr EightBitModes eight_bit_mode
Definition: daw_json_link.h:386
daw::json::json_string_raw::i_am_a_json_type
void i_am_a_json_type
Definition: daw_json_link.h:335
daw::json::json_delayed::constructor_t
Constructor constructor_t
Definition: daw_json_link.h:796
daw::json::json_variant::base_type
json_details::unwrap_type< T, Nullable > base_type
Definition: daw_json_link.h:497
daw::json::json_key_value::parse_to_t
std::invoke_result_t< Constructor > parse_to_t
Definition: daw_json_link.h:691
daw::json::json_delayed::name
static constexpr daw::string_view name
Definition: daw_json_link.h:803
daw::json::json_bool::i_am_a_json_type
void i_am_a_json_type
Definition: daw_json_link.h:297
daw::json::json_key_value::expected_type
static constexpr JsonParseTypes expected_type
Definition: daw_json_link.h:706
daw::json::json_number
Definition: daw_json_link.h:257
daw::json::json_bool::base_type
json_details::unwrap_type< T, Nullable > base_type
Definition: daw_json_link.h:299
daw::json::ordered_json_member::member_index
static constexpr std::size_t member_index
Definition: daw_json_link.h:107
daw::json::json_key_value_array::constructor_t
Constructor constructor_t
Definition: daw_json_link.h:734
daw::json::json_tagged_variant::underlying_json_type
static constexpr JsonBaseParseTypes underlying_json_type
Definition: daw_json_link.h:553
daw::json::ordered_json_member::parse_to_t
typename json_details::unnamed_default_type_mapping< JsonMember >::parse_to_t parse_to_t
Definition: daw_json_link.h:110
daw::json::JsonNullable::Never
@ Never
daw::json::json_tagged_variant::base_expected_type
static constexpr JsonParseTypes base_expected_type
Definition: daw_json_link.h:551
daw::json::json_class::i_am_a_json_type
void i_am_a_json_type
Definition: daw_json_link.h:432
daw::json::json_key_value::base_expected_type
static constexpr JsonParseTypes base_expected_type
Definition: daw_json_link.h:708
daw::json::json_array::json_element_t
json_details::unnamed_default_type_mapping< JsonElement > json_element_t
Definition: daw_json_link.h:646
daw::json::NoCommentSkippingPolicyChecked
BasicParsePolicy< false, NoCommentSkippingPolicy, default_exec_tag, false > NoCommentSkippingPolicyChecked
Definition: daw_json_parse_policy.h:511
daw::json::json_class::wrapped_type
T wrapped_type
Definition: daw_json_link.h:434
daw::json::json_string_raw::empty_is_null
static constexpr JsonNullable empty_is_null
Definition: daw_json_link.h:348
daw::json::json_string::i_am_a_json_type
void i_am_a_json_type
Definition: daw_json_link.h:372
daw::json::JsonNullable
JsonNullable
Definition: daw_json_parse_common.h:409
daw::json::json_key_value_array::json_key_t
json_details::unnamed_default_type_mapping< JsonKeyType, json_details::default_key_name > json_key_t
Definition: daw_json_link.h:740
daw::json::json_array::name
static constexpr daw::string_view name
Definition: daw_json_link.h:657
daw::json::ordered_json_member::i_am_a_json_type
void i_am_a_json_type
Definition: daw_json_link.h:106
daw::json::json_variant_type_list::element_map_t
std::tuple< json_details::unnamed_default_type_mapping< JsonElements >... > element_map_t
Definition: daw_json_link.h:460
daw::json::JsonRangeCheck
JsonRangeCheck
Definition: daw_json_parse_common.h:410
daw::json::json_key_value_array
Definition: daw_json_link.h:732
daw::json::json_string::constructor_t
Constructor constructor_t
Definition: daw_json_link.h:373
daw::json::json_key_value_array::nullable
static constexpr bool nullable
Definition: daw_json_link.h:766
daw::json::json_array::underlying_json_type
static constexpr JsonBaseParseTypes underlying_json_type
Definition: daw_json_link.h:664
daw::json::json_tagged_variant::wrapped_type
T wrapped_type
Definition: daw_json_link.h:541
daw::json::json_tagged_variant::i_am_a_tagged_variant
void i_am_a_tagged_variant
Definition: daw_json_link.h:531
daw::json::json_key_value::constructor_t
Constructor constructor_t
Definition: daw_json_link.h:687
daw::json::json_bool
Definition: daw_json_link.h:296
daw::json::json_variant::i_am_a_json_type
void i_am_a_json_type
Definition: daw_json_link.h:491
daw::json::json_variant::nullable
static constexpr bool nullable
Definition: daw_json_link.h:510
daw::json::json_number::constructor_t
Constructor constructor_t
Definition: daw_json_link.h:271
daw::json::json_string_raw::expected_type
static constexpr JsonParseTypes expected_type
Definition: daw_json_link.h:344
daw::json::json_string::base_type
json_details::unwrap_type< String, Nullable > base_type
Definition: daw_json_link.h:375
daw::json::json_array
Definition: daw_json_link.h:643
daw::json::CustomJsonTypes
CustomJsonTypes
Definition: daw_json_parse_common.h:412
daw::json::json_member_list::serialize
static constexpr OutputIterator serialize(OutputIterator it, std::tuple< Args... > const &args, Value const &v)
Definition: daw_json_link.h:60
daw::json::json_variant::name
static constexpr daw::string_view name
Definition: daw_json_link.h:501
daw::json::json_submember_tagged_variant::i_am_a_json_member_list
void i_am_a_json_member_list
Definition: daw_json_link.h:189
daw::json::json_class::base_type
json_details::unwrap_type< T, Nullable > base_type
Definition: daw_json_link.h:435
daw::json::json_ordered_member_list
Definition: daw_json_link.h:131
daw::json::json_delayed::parse_to_t
std::invoke_result_t< Constructor, char const *, char const * > parse_to_t
Definition: daw_json_link.h:802
daw::json::json_tagged_variant::nullable
static constexpr bool nullable
Definition: daw_json_link.h:556
daw::json::json_key_value::nullable
static constexpr bool nullable
Definition: daw_json_link.h:712
daw::json::json_custom::name
static constexpr daw::string_view name
Definition: daw_json_link.h:589
daw::json::json_custom::base_expected_type
static constexpr JsonParseTypes base_expected_type
Definition: daw_json_link.h:592
daw::json::json_string_raw::constructor_t
Constructor constructor_t
Definition: daw_json_link.h:336
daw::json::json_class::parse_to_t
T parse_to_t
Definition: daw_json_link.h:438
daw::json::json_variant
Definition: daw_json_link.h:490
daw::json::json_string_raw::underlying_json_type
static constexpr JsonBaseParseTypes underlying_json_type
Definition: daw_json_link.h:350
daw::json::json_number::literal_as_string
static constexpr LiteralAsStringOpt literal_as_string
Definition: daw_json_link.h:280
daw::json::json_string::name
static constexpr daw::string_view name
Definition: daw_json_link.h:380
daw::json::json_data_contract
Definition: daw_json_traits.h:39
daw::json::json_date::expected_type
static constexpr JsonParseTypes expected_type
Definition: daw_json_link.h:412
daw::json::tuple_json_mapping
Definition: daw_json_parse_common.h:41
daw::json::json_number::wrapped_type
T wrapped_type
Definition: daw_json_link.h:259
daw::json::json_string_raw::base_type
json_details::unwrap_type< String, Nullable > base_type
Definition: daw_json_link.h:338
daw::json::ordered_json_member
Definition: daw_json_link.h:104
daw::json::json_date::name
static constexpr daw::string_view name
Definition: daw_json_link.h:411
daw::json::json_delayed::nullable
static constexpr bool nullable
Definition: daw_json_link.h:811
daw::json::json_key_value_array::name
static constexpr daw::string_view name
Definition: daw_json_link.h:759
daw::json::json_number::base_expected_type
static constexpr JsonParseTypes base_expected_type
Definition: daw_json_link.h:277
daw::json::json_variant_type_list::i_am_variant_type_list
void i_am_variant_type_list
Definition: daw_json_link.h:455
daw::json::ParseTag
std::integral_constant< JsonParseTypes, v > ParseTag
Definition: daw_json_parse_common.h:495
daw::json::json_array::i_am_a_json_type
void i_am_a_json_type
Definition: daw_json_link.h:644
daw::json::json_variant::base_expected_type
static constexpr JsonParseTypes base_expected_type
Definition: daw_json_link.h:504
daw::json::json_delayed::base_type
json_details::unwrap_type< T, Nullable > base_type
Definition: daw_json_link.h:797
daw::json::json_member_list::parse_to_class
static constexpr T parse_to_class(Range &rng)
Definition: daw_json_link.h:81
daw::json::json_array::nullable
static constexpr bool nullable
Definition: daw_json_link.h:666
daw::json::json_key_value_array::base_expected_type
static constexpr JsonParseTypes base_expected_type
Definition: daw_json_link.h:762
daw::json::json_key_value_array::underlying_json_type
static constexpr JsonBaseParseTypes underlying_json_type
Definition: daw_json_link.h:764
daw::json::json_class
Definition: daw_json_link.h:431
daw::json::json_number::expected_type
static constexpr JsonParseTypes expected_type
Definition: daw_json_link.h:274
daw::json::json_custom::nullable
static constexpr bool nullable
Definition: daw_json_link.h:596
daw::json::json_class::underlying_json_type
static constexpr JsonBaseParseTypes underlying_json_type
Definition: daw_json_link.h:443
daw::json::json_bool::nullable
static constexpr bool nullable
Definition: daw_json_link.h:313
daw::json::json_number::parse_to_t
std::invoke_result_t< Constructor, base_type > parse_to_t
Definition: daw_json_link.h:266
daw::json::json_custom::from_converter_t
FromJsonConverter from_converter_t
Definition: daw_json_link.h:574
daw::json::json_bool::literal_as_string
static constexpr LiteralAsStringOpt literal_as_string
Definition: daw_json_link.h:310
daw::json::json_submember_tagged_variant::i_am_a_submember_tagged_variant
void i_am_a_submember_tagged_variant
Definition: daw_json_link.h:190
daw::json::json_ordered_member_list::i_am_a_ordered_member_list
void i_am_a_ordered_member_list
Definition: daw_json_link.h:133
daw::json::json_delayed
Definition: daw_json_link.h:793