DAW JSON Link
daw_json_serialize_impl.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#pragma once
9
10#include "version.h"
11
12#include "to_daw_json_string.h"
13
14#include <daw/daw_utility.h>
15
16#include <array>
17#include <ciso646>
18#include <cstddef>
19#include <utility>
20
21namespace daw::json {
22 inline namespace DAW_JSON_VER {
23 namespace json_details {
24
25 template<typename T, std::size_t Capacity>
27 static constexpr std::size_t capacity = Capacity;
28
29 private:
30 std::size_t position{ };
31 std::string_view array[capacity]{ };
32
33 public:
34 constexpr basic_array_t( ) = default;
35
36 constexpr T const *data( ) const {
37 return array;
38 }
39
40 constexpr T *data( ) {
41 return array;
42 }
43
44 constexpr std::size_t size( ) const {
45 return position;
46 }
47
48 constexpr void push_back( T const &v ) {
49 assert( position < capacity );
50 array[position] = v;
51 ++position;
52 }
53 };
54 template<typename T>
55 struct basic_array_t<T, 0> {
56 static constexpr std::size_t capacity = 0;
57
58 constexpr basic_array_t( ) = default;
59
60 constexpr T const *data( ) const {
61 return nullptr;
62 }
63
64 constexpr T *data( ) {
65 return nullptr;
66 }
67
68 constexpr std::size_t size( ) const {
69 return 0;
70 }
71 };
72
73 /***
74 * Serialize items to an output iterator as members of a class
75 * @tparam JsonMembers member items in json_class
76 * @tparam OutputIterator An Output Iterator that allows writing
77 * character data
78 * @tparam Is index_sequence index into JsonMembers
79 * @tparam Tuple tuple type holding class members
80 * @tparam Value mapped class type to serialize
81 * @param it an Output Iterator to write char data to
82 * @param args A tuple of the member values
83 * @param value class to serialize
84 * @return The OutputIterator it at the final position
85 */
86 template<typename... JsonMembers, typename OutputIterator,
87 json_options_t SerializationOptions, std::size_t... Is,
88 typename Tuple, typename Value>
89 [[nodiscard]] inline constexpr serialization_policy<OutputIterator,
90 SerializationOptions>
93 Tuple const &args, Value const &value, std::index_sequence<Is...> ) {
94
95 *it++ = '{';
96 it.add_indent( );
97
98 using visit_size = daw::constant<(
99 sizeof...( JsonMembers ) +
100 ( static_cast<std::size_t>( has_dependent_member_v<JsonMembers> ) +
101 ... + 0 ) )>;
102 auto visited_members =
104
105 // Tag Members, if any. Putting them ahead means we can parse this
106 // faster in the future
107
108 // Using list init to ensure serialization happens in order
109 bool is_first = true;
110
111 // gcc complains when JsonMembers is empty
112 (void)visited_members;
113 (void)is_first;
114 {
115 using Names = fwd_pack<JsonMembers...>;
116 daw::Empty const expander[]{
118 Is, traits::nth_element<Is, JsonMembers...>, Names>(
119 is_first, it, args, value, visited_members ),
120 daw::Empty{ } )...,
121 daw::Empty{} };
122 (void)expander;
123 }
124
125 // Regular Members
126 {
127 daw::Empty const expander[]{
128 ( to_json_str<Is, traits::nth_element<Is, JsonMembers...>>(
129 is_first, it, args, value, visited_members ),
130 daw::Empty{ } )...,
131 daw::Empty{} };
132 (void)expander;
133 }
134 it.del_indent( );
135 if constexpr( sizeof...( Is ) > 0 ) {
136 if constexpr( it.output_trailing_comma == OutputTrailingComma::Yes ) {
137 *it++ = ',';
138 }
139 it.next_member( );
140 }
141 *it++ = '}';
142 return it;
143 }
144
145 template<typename... JsonMembers, typename OutputIterator,
146 json_options_t SerializerOptions, typename Tuple, typename Value,
147 std::size_t... Is>
148 [[nodiscard]] inline constexpr serialization_policy<OutputIterator,
149 SerializerOptions>
152 Tuple const &args, Value const &value, std::index_sequence<Is...> ) {
153
154 *it++ = '[';
155 it.add_indent( );
156 it.next_member( );
157 size_t array_idx = 0;
158 (void)array_idx; // gcc was complaining on empty pack
159 Unused( value );
160 {
161 daw::Empty const expander[]{
162 ( to_json_ordered_str<Is, traits::nth_element<Is, JsonMembers...>>(
163 array_idx, sizeof...( Is ), it, args ),
164 daw::Empty{ } )...,
165 daw::Empty{} };
166 (void)expander;
167 }
168 it.del_indent( );
169 if constexpr( sizeof...( Is ) != 0 ) {
170 if constexpr( it.output_trailing_comma == OutputTrailingComma::Yes ) {
171 *it++ = ',';
172 }
173 it.next_member( );
174 }
175 *it++ = ']';
176 return it;
177 }
178 } // namespace json_details
179 } // namespace DAW_JSON_VER
180} // namespace daw::json
Iterator & it
Definition: daw_json_traits.h:251
constexpr DAW_ATTRIB_INLINE void dependent_member_to_json_str(bool &, OutputIterator const &, TpArgs const &, Value const &, VisitedMembers const &)
Definition: to_daw_json_string.h:1395
constexpr void to_json_ordered_str(std::size_t &array_idx, std::size_t array_size, serialization_policy< OutputIterator, SerializerOptions > &it, Tuple< Args... > const &tp)
Definition: to_daw_json_string.h:1493
std::uint32_t json_options_t
Definition: daw_json_option_bits.h:23
constexpr serialization_policy< OutputIterator, SerializationOptions > serialize_json_class(serialization_policy< OutputIterator, SerializationOptions > it, Tuple const &args, Value const &value, std::index_sequence< Is... >)
Definition: daw_json_serialize_impl.h:91
constexpr serialization_policy< OutputIterator, SerializerOptions > serialize_ordered_json_class(serialization_policy< OutputIterator, SerializerOptions > it, Tuple const &args, Value const &value, std::index_sequence< Is... >)
Definition: daw_json_serialize_impl.h:150
constexpr void to_json_str(bool &is_first, serialization_policy< OutputIterator, SerializationOptions > &it, Tuple const &tp, Value const &, Visited &visited_members)
Definition: to_daw_json_string.h:1455
@ Tuple
A variant type where the Switcher is based on a submember of the class being parsed.
Definition: daw_from_json.h:22
constexpr std::size_t size() const
Definition: daw_json_serialize_impl.h:68
constexpr T const * data() const
Definition: daw_json_serialize_impl.h:60
constexpr T * data()
Definition: daw_json_serialize_impl.h:64
Definition: daw_json_serialize_impl.h:26
constexpr void push_back(T const &v)
Definition: daw_json_serialize_impl.h:48
constexpr T const * data() const
Definition: daw_json_serialize_impl.h:36
static constexpr std::size_t capacity
Definition: daw_json_serialize_impl.h:27
constexpr T * data()
Definition: daw_json_serialize_impl.h:40
constexpr std::size_t size() const
Definition: daw_json_serialize_impl.h:44
Definition: daw_json_serialize_policy.h:47
#define DAW_JSON_VER
The version string used in namespace definitions. Must be a valid namespace name.
Definition: version.h:16