Root/pilfer.hpp
Prev Index Next

pilfer.hpp

100.0% Lines (7/7) 100.0% Functions (12/12) -% Branches (0/0)
pilfer.hpp
Line Hits Source Code
1 //
2 // Copyright (c) 2019 Vinnie Falco (vinnie.falco@gmail.com)
3 //
4 // Distributed under the Boost Software License, Version 1.0. (See accompanying
5 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
6 //
7 // Official repository: https://github.com/boostorg/json
8 //
9
10 #ifndef BOOST_JSON_PILFER_HPP
11 #define BOOST_JSON_PILFER_HPP
12
13 #include <boost/json/detail/config.hpp>
14 #include <type_traits>
15 #include <utility>
16
17 /*
18 Implements "pilfering" from P0308R0
19
20 @see
21 http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0308r0.html
22 */
23
24 namespace boost {
25 namespace json {
26
27 /** Tag wrapper to specify pilfer-construction.
28
29 This wrapper is used to specify a pilfer constructor
30 overload.
31
32 @par Example
33
34 A pilfer constructor accepts a single argument
35 of type @ref pilfered and throws nothing:
36
37 @code
38 struct T
39 {
40 T( pilfered<T> ) noexcept;
41 };
42 @endcode
43
44 @note
45
46 The constructor should not be marked explicit.
47
48 @see @ref pilfer, @ref is_pilfer_constructible,
49 <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0308r0.html">
50 Valueless Variants Considered Harmful</a>
51 */
52 template<class T>
53 class pilfered
54 {
55 T& t_;
56
57 public:
58 /** Constructor
59
60 Construct the wrapper from `t`.
61
62 @param t The pilferable object. Ownership
63 is not transferred.
64 */
65 explicit
66 constexpr
67 2174037 pilfered(T&& t) noexcept
68 2174037 : t_(t)
69 {
70 2174037 }
71
72 /** Return a reference to the pilferable object.
73
74 This returns a reference to the wrapped object.
75 */
76 constexpr T&
77 4316568 get() const noexcept
78 {
79 4316568 return t_;
80 }
81
82 /** Return a pointer to the pilferable object.
83
84 This returns a pointer to the wrapped object.
85 */
86 constexpr T*
87 operator->() const noexcept
88 {
89 //return std::addressof(t_);
90 return reinterpret_cast<T*>(
91 const_cast<char *>(
92 &reinterpret_cast<
93 const volatile char &>(t_)));
94 }
95 };
96
97 #ifndef BOOST_JSON_DOCS
98 // VFALCO Renamed this to work around an msvc bug
99 namespace detail_pilfer {
100 template<class>
101 struct not_pilfered
102 {
103 };
104 } // detail_pilfer
105 #endif
106
107 /** Metafunction returning `true` if `T` is <em>PilferConstructible</em>
108
109 If `T` can be pilfer constructed, this metafunction is
110 equal to `std::true_type`. Otherwise it is equal to
111 `std::false_type`.
112
113 @see @ref pilfer, @ref pilfered,
114 <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0308r0.html">
115 Valueless Variants Considered Harmful</a>
116 */
117 template<class T>
118 struct is_pilfer_constructible
119 #ifndef BOOST_JSON_DOCS
120 : std::integral_constant<bool,
121 std::is_nothrow_move_constructible<T>::value ||
122 (
123 std::is_nothrow_constructible<
124 T, pilfered<T> >::value &&
125 ! std::is_nothrow_constructible<
126 T, detail_pilfer::not_pilfered<T> >::value
127 )>
128 #endif
129 {
130 };
131
132 /** Indicate that an object `t` may be pilfered from.
133
134 A <em>pilfer</em> operation is the construction
135 of a new object of type `T` from an existing
136 object `t`. After the construction, the only
137 valid operation on the pilfered-from object is
138 destruction. This permits optimizations beyond
139 those available for a move-construction, as the
140 pilfered-from object is not required to be in
141 a "usable" state.
142 \n
143 This is used similarly to `std::move`.
144
145 @par Example
146
147 A pilfer constructor accepts a single argument
148 of type @ref pilfered and throws nothing:
149
150 @code
151 struct T
152 {
153 T( pilfered<T> ) noexcept;
154 };
155 @endcode
156
157 Pilfer construction is performed using @ref pilfer :
158
159 @code
160 {
161 T t1; // default construction
162 T t2( pilfer( t1 ) ); // pilfer-construct from t1
163
164 // At this point, t1 may only be destroyed
165 }
166 @endcode
167
168 @see @ref pilfered, @ref is_pilfer_constructible,
169 <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0308r0.html">
170 Valueless Variants Considered Harmful</a>
171 */
172 template<class T>
173 auto
174 6327165 pilfer(T&& t) noexcept ->
175 typename std::conditional<
176 std::is_nothrow_constructible<
177 typename std::remove_reference<T>::type,
178 pilfered<typename
179 std::remove_reference<T>::type> >::value &&
180 ! std::is_nothrow_constructible<
181 typename std::remove_reference<T>::type,
182 detail_pilfer::not_pilfered<typename
183 std::remove_reference<T>::type> >::value,
184 pilfered<typename std::remove_reference<T>::type>,
185 typename std::remove_reference<T>::type&&
186 >::type
187 {
188 using U =
189 typename std::remove_reference<T>::type;
190 static_assert(
191 is_pilfer_constructible<U>::value, "");
192 return typename std::conditional<
193 std::is_nothrow_constructible<
194 U, pilfered<U> >::value &&
195 ! std::is_nothrow_constructible<
196 U, detail_pilfer::not_pilfered<U> >::value,
197 pilfered<U>, U&&
198 6327165 >::type(std::move(t));
199 }
200
201 /*
202 template<class T>
203 void
204 relocate(T* dest, T& src) noexcept
205 {
206 static_assert(
207 is_pilfer_constructible<T>::value, "");
208 ::new(dest) T(pilfer(src));
209 src.~T();
210 }
211 */
212
213 } // json
214 } // boost
215
216
217 #endif
218