DAW JSON Link
Loading...
Searching...
No Matches
daw_json_parse_options_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
9#pragma once
10
11#include "daw/json/impl/version.h"
12
13#include "daw/json/daw_json_parse_options.h"
14#include "daw/json/impl/daw_json_option_bits.h"
15
16#include <daw/cpp_17.h>
17#include <daw/daw_attributes.h>
18#include <daw/daw_enable_requires.h>
19#include <daw/daw_string_view.h>
20#include <daw/daw_traits.h>
21#include <daw/daw_unreachable.h>
22
23#include <climits>
24#include <cstddef>
25#include <cstdint>
26#include <utility>
27
28namespace daw::json {
29 inline namespace DAW_JSON_VER {
30 namespace options {
31 constexpr daw::string_view to_string( ExecModeTypes mode ) {
32 switch( mode ) {
33 case ExecModeTypes::default_mode:
34 return "default_mode";
35 case ExecModeTypes::compile_time:
36 return "compile_time";
37 case ExecModeTypes::runtime:
38 return "runtime";
39 case ExecModeTypes::simd:
40 return "simd";
41 }
42 DAW_UNREACHABLE( );
43 }
44 } // namespace options
45
46 namespace json_details {
47 template<>
48 inline constexpr unsigned json_option_bits_width<options::ExecModeTypes> =
49 2;
50
51 template<>
52 inline constexpr auto default_json_option_value<options::ExecModeTypes> =
53 options::ExecModeTypes::default_mode;
54
55 template<>
56 inline constexpr unsigned
57 json_option_bits_width<options::ZeroTerminatedString> = 1;
58
59 template<>
60 inline constexpr auto
61 default_json_option_value<options::ZeroTerminatedString> =
62 options::ZeroTerminatedString::no;
63
64 template<>
65 inline constexpr unsigned
66 json_option_bits_width<options::AllowStringMutation> = 1;
67
68 template<>
69 inline constexpr auto
70 default_json_option_value<options::AllowStringMutation> =
71 options::AllowStringMutation::no;
72
73 template<>
74 inline constexpr unsigned
75 json_option_bits_width<options::PolicyCommentTypes> = 2;
76
77 template<>
78 inline constexpr auto
79 default_json_option_value<options::PolicyCommentTypes> =
80 options::PolicyCommentTypes::none;
81
82 template<>
83 inline constexpr unsigned
84 json_option_bits_width<options::CheckedParseMode> = 1;
85
86 template<>
87 inline constexpr auto
88 default_json_option_value<options::CheckedParseMode> =
89 options::CheckedParseMode::yes;
90
91 template<>
92 inline constexpr unsigned
93 json_option_bits_width<options::MinifiedDocument> = 1;
94
95 template<>
96 inline constexpr auto
97 default_json_option_value<options::MinifiedDocument> =
98 options::MinifiedDocument::no;
99
100 template<>
101 inline constexpr unsigned
102 json_option_bits_width<options::AllowEscapedNames> = 1;
103
104 template<>
105 inline constexpr auto
106 default_json_option_value<options::AllowEscapedNames> =
107 options::AllowEscapedNames::no;
108
109 template<>
110 inline constexpr unsigned
111 json_option_bits_width<options::IEEE754Precise> = 1;
112
113 template<>
114 inline constexpr auto default_json_option_value<options::IEEE754Precise> =
115 options::IEEE754Precise::yes;
116
117 template<>
118 inline constexpr unsigned
119 json_option_bits_width<options::ForceFullNameCheck> = 1;
120
121 template<>
122 inline constexpr auto
123 default_json_option_value<options::ForceFullNameCheck> =
124 options::ForceFullNameCheck::no;
125
126 template<>
127 inline constexpr unsigned
128 json_option_bits_width<options::UseExactMappingsByDefault> = 1;
129
130 template<>
131 inline constexpr auto
132 default_json_option_value<options::UseExactMappingsByDefault> =
133 options::UseExactMappingsByDefault::no;
134
135 template<>
136 inline constexpr unsigned
137 json_option_bits_width<options::MustVerifyEndOfDataIsValid> = 1;
138
139 template<>
140 inline constexpr auto
141 default_json_option_value<options::MustVerifyEndOfDataIsValid> =
142 options::MustVerifyEndOfDataIsValid::no;
143
144 template<>
145 inline constexpr unsigned
146 json_option_bits_width<options::ExpectLongNames> = 1;
147
148 template<>
149 inline constexpr auto
150 default_json_option_value<options::ExpectLongNames> =
151 options::ExpectLongNames::no;
152
153 /*
154 template<>
155 inline constexpr unsigned
156 json_option_bits_width<options::TemporarilyMutateBuffer> = 1;
157
158 template<>
159 inline constexpr auto
160 default_json_option_value<options::TemporarilyMutateBuffer> =
161 options::TemporarilyMutateBuffer::no;
162 */
163
164 template<>
165 inline constexpr unsigned
166 json_option_bits_width<options::ExcludeSpecialEscapes> = 1;
167
168 template<>
169 inline constexpr auto
170 default_json_option_value<options::ExcludeSpecialEscapes> =
171 options::ExcludeSpecialEscapes::no;
172
173 using policy_list = typename option_list_impl<
174 options::ExecModeTypes, options::ZeroTerminatedString,
175 options::AllowStringMutation, options::PolicyCommentTypes,
176 options::CheckedParseMode, options::AllowEscapedNames,
177 options::IEEE754Precise, options::ForceFullNameCheck,
178 options::MinifiedDocument, options::UseExactMappingsByDefault,
179 options::MustVerifyEndOfDataIsValid, options::ExcludeSpecialEscapes,
180 options::ExpectLongNames>::type;
181
182 template<typename Policy, typename Policies>
183 inline constexpr unsigned basic_policy_bits_start =
184 option_bits_start_impl<Policy, Policies>::template calc<>(
185 std::make_index_sequence<pack_size_v<Policies>>{ } );
186
187 template<typename Policy>
188 inline constexpr unsigned policy_bits_start =
189 basic_policy_bits_start<Policy, policy_list>;
190
191 DAW_CONSTEVAL json_options_t set_bits( json_options_t value ) {
192 return value;
193 }
194
195 template<typename PolicyFlag,
196 typename... PolicyFlags DAW_ENABLEIF(
197 are_option_flags<PolicyFlag, PolicyFlags...> )>
198 DAW_REQUIRES( are_option_flags<PolicyFlag, PolicyFlags...> )
199 DAW_CONSTEVAL json_options_t
200 set_bits( json_options_t value, PolicyFlag pol, PolicyFlags... pols ) {
201 static_assert( are_option_flags<PolicyFlags...>,
202 "Only registered policy types are allowed" );
203
204 auto new_bits = static_cast<unsigned>( pol );
205 using mask =
206 daw::constant<( (1U << json_option_bits_width<PolicyFlag>)-1U )>;
207 new_bits &= mask::value;
208 new_bits <<= policy_bits_start<PolicyFlag>;
209 value &= ~( mask::value << policy_bits_start<PolicyFlag> );
210 value |= new_bits;
211 if constexpr( sizeof...( PolicyFlags ) > 0 ) {
212 if constexpr( sizeof...( pols ) > 0 ) {
213 return set_bits( value, pols... );
214 } else {
215 return value;
216 }
217 } else {
218 return value;
219 }
220 }
221
222 template<typename Policy>
223 DAW_CONSTEVAL json_options_t set_bits_for( Policy e ) {
224 static_assert( is_option_flag<Policy>,
225 "Only registered policy types are allowed" );
226 auto new_bits = static_cast<json_options_t>( e );
227 new_bits <<= policy_bits_start<Policy>;
228 return new_bits;
229 }
230
231 template<typename>
232 struct default_policy_flag_t;
233
234 template<typename... Policies>
235 struct default_policy_flag_t<pack_list<Policies...>> {
236 static constexpr json_options_t value =
237 ( set_bits_for<Policies>( default_json_option_value<Policies> ) |
238 ... );
239 };
240
241 /***
242 * The defaults for all known policies encoded as a json_options_t
243 */
244 inline constexpr json_options_t default_policy_flag =
245 default_policy_flag_t<policy_list>::value;
246
247 template<typename Policy, typename Result = Policy>
248 DAW_CONSTEVAL Result get_bits_for( json_options_t value ) {
249 static_assert( is_option_flag<Policy>,
250 "Only registered policy types are allowed" );
251 using mask = daw::constant<( 1U << (policy_bits_start<Policy> +
252 json_option_bits_width<Policy>)) -
253 1U>;
254 value &= mask::value;
255 value >>= policy_bits_start<Policy>;
256 return static_cast<Result>( Policy{ value } );
257 }
258 } // namespace json_details
259 // ***********************************************
260
261 /***
262 * Create the parser options flag for BasicParsePolicy
263 * @tparam Policies Policy types that satisfy the `is_policy_flag` trait.
264 * @param policies A list of parser options to change from the defaults.
265 * @return A json_options_t that encodes the options for the parser
266 */
267 template<typename... Policies>
268 DAW_CONSTEVAL json_options_t parse_options( Policies... policies ) {
269 static_assert( json_details::are_option_flags<Policies...>,
270 "Only registered policy types are allowed" );
271 return json_details::set_bits( json_details::default_policy_flag,
272 policies... );
273 }
274 } // namespace DAW_JSON_VER
275} // namespace daw::json
DAW_REQUIRES
DAW_REQUIRES(daw::json::json_details::is_container_opted_into_json_iostreams_v< Container >) std
An opt in ostream interface for containers of types that have JSON mappings.
Definition daw_json_iostream.h:61
daw_json_option_bits.h
daw_json_parse_options.h
daw::json::anonymous_namespace{daw_json_enums.h}::to_string
constexpr std::string_view to_string(JsonBaseParseTypes pt)
Definition daw_json_enums.h:68
daw::json::anonymous_namespace{daw_json_option_bits.h}::json_options_t
std::uint32_t json_options_t
Definition daw_json_option_bits.h:28
daw::json
Customization point traits.
Definition daw_container_traits.h:24
DAW_JSON_VER
#define DAW_JSON_VER
The version string used in namespace definitions. Must be a valid namespace name.
Definition version.h:20
Generated by doxygen 1.9.8