GCC Code Coverage Report

Directory: libs/json/include/boost/json/
File: value_to.hpp
Date: 2025-12-23 17:20:53
Exec Total Coverage
Lines: 11 11 100.0%
Functions: 382 388 98.5%
Branches: 7 7 100.0%
Line Branch Exec Source
1 //
2 // Copyright (c) 2019 Vinnie Falco (vinnie.falco@gmail.com)
3 // Copyright (c) 2020 Krystian Stasiowski (sdkrystian@gmail.com)
4 // Copyright (c) 2022 Dmitry Arkhipov (grisumbras@gmail.com)
5 //
6 // Distributed under the Boost Software License, Version 1.0. (See accompanying
7 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
8 //
9 // Official repository: https://github.com/boostorg/json
10 //
11
12 #ifndef BOOST_JSON_VALUE_TO_HPP
13 #define BOOST_JSON_VALUE_TO_HPP
14
15 #include <boost/json/detail/value_to.hpp>
16
17 namespace boost {
18 namespace json {
19
20 /** Convert a @ref value to an object of type `T`.
21
22 This function attempts to convert a @ref value
23 to `T` using
24
25 @li one of @ref value's accessors, or
26
27 @li a library-provided generic conversion, or
28
29 @li a user-provided overload of `tag_invoke`.
30
31 Out of the box the function supports types satisfying
32 <a href="https://en.cppreference.com/w/cpp/named_req/SequenceContainer"><em>SequenceContainer</em></a>,
33 arrays, arithmetic types, `bool`, `std::tuple`, `std::pair`,
34 `std::variant`, `std::optional`, `std::monostate`, and `std::nullopt_t`.
35
36 Conversion of other types is done by calling an overload of `tag_invoke`
37 found by argument-dependent lookup. Its signature should be similar to:
38
39 @code
40 template< class FullContext >
41 T tag_invoke( value_to_tag<T>, const value&, const Context& , const FullContext& );
42 @endcode
43
44 or
45
46 @code
47 T tag_invoke( value_to_tag<T>, const value&, const Context& );
48 @endcode
49
50 or
51
52 @code
53 result<T> tag_invoke( value_to_tag<T>, const value& );
54 @endcode
55
56 The overloads are checked for existence in that order and the first that
57 matches will be selected. <br>
58
59 The object returned by the function call is returned by @ref value_to as
60 the result of the conversion. <br>
61
62 The `ctx` argument can be used either as a tag type to provide conversions
63 for third-party types, or to pass extra data to the conversion function.
64
65 @par Constraints
66 @code
67 ! std::is_reference< T >::value
68 @endcode
69
70 @par Exception Safety
71 Strong guarantee.
72
73 @tparam T The type to convert to.
74
75 @tparam Context The type of context passed to the conversion function.
76
77 @returns `jv` converted to `result<T>`.
78
79 @param jv The @ref value to convert.
80
81 @param ctx Context passed to the conversion function.
82
83 @see @ref value_to_tag, @ref value_from,
84 <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2019/p1895r0.pdf">
85 tag_invoke: A general pattern for supporting customisable functions</a>
86 */
87 template< class T, class Context >
88 T
89 894 value_to( value const& jv, Context const& ctx )
90 {
91 BOOST_STATIC_ASSERT(! std::is_reference<T>::value);
92
93 using Attrs = detail::value_to_attrs<Context, T>;
94 using Rep = typename Attrs::representation;
95 BOOST_STATIC_ASSERT(detail::conversion_round_trips<
96 Context, Rep, detail::value_to_conversion>::value);
97
98 using bare_T = detail::remove_cvref<T>;
99
2/2
✓ Branch 1 taken 13 times.
✓ Branch 4 taken 1 times.
 444 return static_cast<bare_T>(detail::value_to_impl(
100 810 typename Attrs::category(), value_to_tag<Rep>(), jv, ctx ));
101 }
102
103 /** Convert a @ref value to an object of type `T`.
104
105 This function attempts to convert a @ref value
106 to `T` using
107
108 @li one of @ref value's accessors, or
109
110 @li a library-provided generic conversion, or
111
112 @li a user-provided overload of `tag_invoke`.
113
114 Out of the box the function supports types satisfying
115 <a href="https://en.cppreference.com/w/cpp/named_req/SequenceContainer"><em>SequenceContainer</em></a>,
116 arrays, arithmetic types, `bool`, `std::tuple`, `std::pair`,
117 `std::variant`, `std::optional`, `std::monostate`, and `std::nullopt_t`.
118
119 Conversion of other types is done by calling an overload of `tag_invoke`
120 found by argument-dependent lookup. Its signature should be similar to:
121
122 @code
123 T tag_invoke( value_to_tag<T>, const value& );
124 @endcode
125
126 The object returned by the function call is
127 returned by @ref value_to as the result of the
128 conversion.
129
130 @par Constraints
131 @code
132 ! std::is_reference< T >::value
133 @endcode
134
135 @par Exception Safety
136 Strong guarantee.
137
138 @tparam T The type to convert to.
139
140 @returns `jv` converted to `T`.
141
142 @param jv The @ref value to convert.
143
144 @see @ref value_to_tag, @ref value_from,
145 <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2019/p1895r0.pdf">
146 tag_invoke: A general pattern for supporting customisable functions</a>
147 */
148 template<class T>
149 T
150 129 value_to(const value& jv)
151 {
152
1/1
✓ Branch 1 taken 43 times.
 167 return value_to<T>( jv, detail::no_context() );
153 }
154
155 /** Convert a @ref value to a `boost::system::result<T>`.
156
157 This function attempts to convert a @ref value
158 to `result<T>` using
159
160 @li one of @ref value's accessors, or
161
162 @li a library-provided generic conversion, or
163
164 @li a user-provided overload of `tag_invoke`.
165
166 Out of the box the function supports types satisfying
167 <a href="https://en.cppreference.com/w/cpp/named_req/SequenceContainer"><em>SequenceContainer</em></a>,
168 arrays, arithmetic types, `bool`, `std::tuple`, `std::pair`,
169 `std::variant`, `std::optional`, `std::monostate`, and `std::nullopt_t`.
170
171 Conversion of other types is done by calling an overload of `tag_invoke`
172 found by argument-dependent lookup. Its signature should be similar to:
173
174 @code
175 template< class FullContext >
176 result<T> tag_invoke( try_value_to_tag<T>, const value&, const Context& , const FullContext& );
177 @endcode
178
179 or
180
181 @code
182 result<T> tag_invoke( try_value_to_tag<T>, const value&, const Context& );
183 @endcode
184
185 or
186
187 @code
188 result<T> tag_invoke( try_value_to_tag<T>, const value& );
189 @endcode
190
191 The overloads are checked for existence in that order and the first that
192 matches will be selected. <br>
193
194 If an error occurs during conversion, the result will store the error code
195 associated with the error. If an exception is thrown, the function will
196 attempt to retrieve the associated error code and return it, otherwise it
197 will return `error::exception`, unless the exception type is
198 `std::bad_alloc`, which will be allowed to propagate. <br>
199
200 The `ctx` argument can be used either as a tag type to provide conversions
201 for third-party types, or to pass extra data to the conversion function.
202
203 @par Constraints
204 @code
205 ! std::is_reference< T >::value
206 @endcode
207
208 @par Exception Safety
209 Strong guarantee.
210
211 @tparam T The type to convert to.
212
213 @tparam Context The type of context passed to the conversion function.
214
215 @param jv The @ref value to convert.
216
217 @param ctx Context passed to the conversion function.
218
219 @returns `jv` converted to `result<T>`.
220
221 @see @ref value_to_tag, @ref value_to, @ref value_from,
222 <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2019/p1895r0.pdf">
223 tag_invoke: A general pattern for supporting customisable functions</a>
224 */
225 template< class T, class Context >
226 typename result_for<T, value>::type
227 7630 try_value_to( value const& jv, Context const& ctx )
228 {
229 BOOST_STATIC_ASSERT(! std::is_reference<T>::value);
230
231 using Attrs = detail::value_to_attrs<Context, T>;
232 using Rep = typename Attrs::representation;
233 BOOST_STATIC_ASSERT(detail::conversion_round_trips<
234 Context, Rep, detail::value_to_conversion>::value);
235
236 using bare_T = detail::remove_cvref<T>;
237
1/1
✓ Branch 1 taken 106 times.
 560 return detail::value_to_impl(
238 6656 typename Attrs::category(), try_value_to_tag<Rep>(), jv, ctx )
239
2/2
✓ Branch 1 taken 3800 times.
✓ Branch 4 taken 196 times.
 11264 & [](Rep&& rep) { return static_cast<bare_T>(rep); };
240 }
241
242 /** Convert a @ref value to a `boost::system::result<T>`.
243
244 This function attempts to convert a @ref value
245 to `result<T>` using
246
247 @li one of @ref value's accessors, or
248
249 @li a library-provided generic conversion, or
250
251 @li a user-provided overload of `tag_invoke`.
252
253 Out of the box the function supports types satisfying
254 <a href="https://en.cppreference.com/w/cpp/named_req/SequenceContainer"><em>SequenceContainer</em></a>,
255 arrays, arithmetic types, `bool`, `std::tuple`, `std::pair`,
256 `std::variant`, `std::optional`, `std::monostate`, and `std::nullopt_t`.
257
258 Conversion of other types is done by calling an overload of `tag_invoke`
259 found by argument-dependent lookup. Its signature should be similar to:
260
261 @code
262 result<T> tag_invoke( try_value_to_tag<T>, const value& );
263 @endcode
264
265 If an error occurs during conversion, the result will store the error code
266 associated with the error. If an exception is thrown, the function will
267 attempt to retrieve the associated error code and return it, otherwise it
268 will return `error::exception`, unless the exception type is
269 `std::bad_alloc`, which will be allowed to propagate.
270
271 @par Constraints
272 @code
273 ! std::is_reference< T >::value
274 @endcode
275
276 @par Exception Safety
277 Strong guarantee.
278
279 @tparam T The type to convert to.
280
281 @param jv The @ref value to convert.
282
283 @returns `jv` converted to `result<T>`.
284
285 @see @ref value_to_tag, @ref value_to, @ref value_from,
286 <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2019/p1895r0.pdf">
287 tag_invoke: A general pattern for supporting customisable functions</a>
288 */
289 template<class T>
290 typename result_for<T, value>::type
291 136 try_value_to(const value& jv)
292 {
293
1/1
✓ Branch 1 taken 4 times.
 169 return try_value_to<T>( jv, detail::no_context() );
294 }
295
296 /** Convert a @ref value to an object of type `T`.
297
298 This overload is **deleted** and participates in overload resolution only
299 when `U` is not @ref value. The overload exists to prevent unintented
300 creation of temporary @ref value instances, e.g.
301
302 @code
303 auto flag = value_to<bool>(true);
304 @endcode
305 */
306 template<class T, class U
307 #ifndef BOOST_JSON_DOCS
308 , class = typename std::enable_if<!std::is_same<U, value>::value>::type
309 #endif
310 >
311 T
312 value_to(U const& jv) = delete;
313
314 /** Determine a @ref value can be converted to `T`.
315
316 If @ref value can be converted to `T` via a
317 call to @ref value_to, the static data member `value`
318 is defined as `true`. Otherwise, `value` is
319 defined as `false`.
320
321 @see @ref value_to
322 */
323 #ifdef BOOST_JSON_DOCS
324 template<class T>
325 using has_value_to = __see_below__;
326 #else
327 template<class T>
328 using has_value_to = detail::can_convert<
329 detail::remove_cvref<T>, detail::value_to_conversion>;
330 #endif
331
332 } // namespace json
333 } // namespace boost
334
335 #endif
336