TLA Line data Source code
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_FROM_HPP
13 : #define BOOST_JSON_VALUE_FROM_HPP
14 :
15 : #include <boost/core/detail/static_assert.hpp>
16 : #include <boost/json/detail/value_from.hpp>
17 :
18 : namespace boost {
19 : namespace json {
20 :
21 : /** Convert an object of type `T` to @ref value.
22 :
23 : This function attempts to convert an object
24 : of type `T` to @ref value using
25 :
26 : @li one of @ref value's constructors,
27 :
28 : @li a library-provided generic conversion, or
29 :
30 : @li a user-provided overload of `tag_invoke`.
31 :
32 : Out of the function supports default constructible types satisfying
33 : {req_SequenceContainer}, arrays, arithmetic types, `bool`, `std::tuple`,
34 : `std::pair`, `std::optional`, `std::variant`, `std::nullptr_t`, and structs
35 : and enums described using Boost.Describe.
36 :
37 : Conversion of other types is done by calling an overload of `tag_invoke`
38 : found by argument-dependent lookup. Its signature should be similar to:
39 :
40 : @code
41 : template< class FullContext >
42 : void tag_invoke( value_from_tag, value&, T, const Context&, const FullContext& );
43 : @endcode
44 :
45 : or
46 :
47 : @code
48 : void tag_invoke( value_from_tag, value&, T, const Context& );
49 : @endcode
50 :
51 : or
52 :
53 : @code
54 : void tag_invoke( value_from_tag, value&, T );
55 : @endcode
56 :
57 : The overloads are checked for existence in that order and the first that
58 : matches will be selected. <br>
59 :
60 : The `ctx` argument can be used either as a tag type to provide conversions
61 : for third-party types, or to pass extra data to the conversion function.
62 :
63 : Overloads **(2)** and **(4)** construct their return value using the
64 : @ref storage_ptr `sp`, which ensures that the memory resource is correctly
65 : propagated.
66 :
67 : @par Exception Safety
68 : Strong guarantee.
69 :
70 : @tparam T The type of the object to convert.
71 :
72 : @tparam Context The type of context passed to the conversion function.
73 :
74 : @param t The object to convert.
75 :
76 : @param ctx Context passed to the conversion function.
77 :
78 : @param jv @ref value out parameter.
79 :
80 : @see @ref value_from_tag, @ref value_to,
81 : <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2019/p1895r0.pdf">
82 : tag_invoke: A general pattern for supporting customisable functions</a>
83 : */
84 : /// @{
85 : template< class T, class Context >
86 : void
87 HIT 7056 : value_from(
88 : T&& t,
89 : Context const& ctx,
90 : value& jv)
91 : {
92 : using bare_T = detail::remove_cvref<T>;
93 : BOOST_CORE_STATIC_ASSERT((
94 : detail::conversion_round_trips<
95 : Context, bare_T, detail::value_from_conversion>::value));
96 : using cat = detail::value_from_category<Context, bare_T>;
97 7056 : detail::value_from_impl( cat(), jv, std::forward<T>(t), ctx );
98 7056 : }
99 :
100 : /** Overload
101 : @param t
102 : @param ctx
103 : @param sp A storage pointer referring to the memory resource to use for the
104 : returned @ref value.
105 :
106 : @return Overloads **(2)** and **(4)** return `t` converted to @ref value.
107 : Overloads **(1)** and **3** return `void` instead and pass their result via
108 : the out parameter `jv`.
109 : */
110 : template< class T, class Context >
111 : #ifndef BOOST_JSON_DOCS
112 : typename std::enable_if<
113 : !std::is_same< detail::remove_cvref<Context>, storage_ptr >::value &&
114 : !std::is_same< detail::remove_cvref<Context>, value >::value,
115 : value >::type
116 : #else
117 : value
118 : #endif
119 7037 : value_from(
120 : T&& t,
121 : Context const& ctx,
122 : storage_ptr sp = {})
123 : {
124 7037 : value jv(std::move(sp));
125 7037 : value_from( static_cast<T&&>(t), ctx, jv );
126 7037 : return jv;
127 MIS 0 : }
128 :
129 : /// Overload
130 : template<class T>
131 : void
132 HIT 19 : value_from(
133 : T&& t,
134 : value& jv)
135 : {
136 19 : value_from( static_cast<T&&>(t), detail::no_context(), jv );
137 19 : }
138 :
139 : /// Overload
140 : template<class T>
141 : value
142 297 : value_from(
143 : T&& t,
144 : storage_ptr sp = {})
145 : {
146 : return value_from(
147 297 : static_cast<T&&>(t), detail::no_context(), std::move(sp) );
148 : }
149 : /// @}
150 :
151 : /** Determine if `T` can be converted to @ref value.
152 :
153 : If `T` can be converted to @ref value via a call to @ref value_from, the
154 : static data member `value` is defined as `true`. Otherwise, `value` is
155 : defined as `false`.
156 :
157 : @see @ref value_from.
158 : */
159 : #ifdef BOOST_JSON_DOCS
160 : template<class T>
161 : using has_value_from = __see_below__;
162 : #else
163 : template<class T>
164 : using has_value_from = detail::can_convert<
165 : detail::remove_cvref<T>, detail::value_from_conversion>;
166 : #endif
167 :
168 : } // namespace json
169 : } // namespace boost
170 :
171 : #endif
|
