GCC Code Coverage Report

Line	Branch	Exec	Source
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		4348062	pilfered(T&& t) noexcept
68		4348062	: t_(t)
69			{
70		4348062	}
71
72			/** Return a reference to the pilferable object.
73
74			This returns a reference to the wrapped object.
75			*/
76			constexpr T&
77		8633105	get() const noexcept
78			{
79		8633105	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