1 | // See http://www.boost.org/libs/any for Documentation. |
2 | |
3 | #ifndef BOOST_ANY_INCLUDED |
4 | #define BOOST_ANY_INCLUDED |
5 | |
6 | #if defined(_MSC_VER) |
7 | # pragma once |
8 | #endif |
9 | |
10 | // what: variant type boost::any |
11 | // who: contributed by Kevlin Henney, |
12 | // with features contributed and bugs found by |
13 | // Antony Polukhin, Ed Brey, Mark Rodgers, |
14 | // Peter Dimov, and James Curran |
15 | // when: July 2001, April 2013 - May 2013 |
16 | |
17 | #include <algorithm> |
18 | |
19 | #include <boost/config.hpp> |
20 | #include <boost/type_index.hpp> |
21 | #include <boost/type_traits/remove_reference.hpp> |
22 | #include <boost/type_traits/decay.hpp> |
23 | #include <boost/type_traits/remove_cv.hpp> |
24 | #include <boost/type_traits/add_reference.hpp> |
25 | #include <boost/type_traits/is_reference.hpp> |
26 | #include <boost/type_traits/is_const.hpp> |
27 | #include <boost/throw_exception.hpp> |
28 | #include <boost/static_assert.hpp> |
29 | #include <boost/utility/enable_if.hpp> |
30 | #include <boost/core/addressof.hpp> |
31 | #include <boost/type_traits/is_same.hpp> |
32 | #include <boost/type_traits/is_const.hpp> |
33 | #include <boost/mpl/if.hpp> |
34 | |
35 | namespace boost |
36 | { |
37 | class any |
38 | { |
39 | public: // structors |
40 | |
41 | any() BOOST_NOEXCEPT |
42 | : content(0) |
43 | { |
44 | } |
45 | |
46 | template<typename ValueType> |
47 | any(const ValueType & value) |
48 | : content(new holder< |
49 | BOOST_DEDUCED_TYPENAME remove_cv<BOOST_DEDUCED_TYPENAME decay<const ValueType>::type>::type |
50 | >(value)) |
51 | { |
52 | } |
53 | |
54 | any(const any & other) |
55 | : content(other.content ? other.content->clone() : 0) |
56 | { |
57 | } |
58 | |
59 | #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES |
60 | // Move constructor |
61 | any(any&& other) BOOST_NOEXCEPT |
62 | : content(other.content) |
63 | { |
64 | other.content = 0; |
65 | } |
66 | |
67 | // Perfect forwarding of ValueType |
68 | template<typename ValueType> |
69 | any(ValueType&& value |
70 | , typename boost::disable_if<boost::is_same<any&, ValueType> >::type* = 0 // disable if value has type `any&` |
71 | , typename boost::disable_if<boost::is_const<ValueType> >::type* = 0) // disable if value has type `const ValueType&&` |
72 | : content(new holder< typename decay<ValueType>::type >(static_cast<ValueType&&>(value))) |
73 | { |
74 | } |
75 | #endif |
76 | |
77 | ~any() BOOST_NOEXCEPT |
78 | { |
79 | delete content; |
80 | } |
81 | |
82 | public: // modifiers |
83 | |
84 | any & swap(any & rhs) BOOST_NOEXCEPT |
85 | { |
86 | std::swap(content, rhs.content); |
87 | return *this; |
88 | } |
89 | |
90 | |
91 | #ifdef BOOST_NO_CXX11_RVALUE_REFERENCES |
92 | template<typename ValueType> |
93 | any & operator=(const ValueType & rhs) |
94 | { |
95 | any(rhs).swap(*this); |
96 | return *this; |
97 | } |
98 | |
99 | any & operator=(any rhs) |
100 | { |
101 | any(rhs).swap(*this); |
102 | return *this; |
103 | } |
104 | |
105 | #else |
106 | any & operator=(const any& rhs) |
107 | { |
108 | any(rhs).swap(*this); |
109 | return *this; |
110 | } |
111 | |
112 | // move assignement |
113 | any & operator=(any&& rhs) BOOST_NOEXCEPT |
114 | { |
115 | rhs.swap(*this); |
116 | any().swap(rhs); |
117 | return *this; |
118 | } |
119 | |
120 | // Perfect forwarding of ValueType |
121 | template <class ValueType> |
122 | any & operator=(ValueType&& rhs) |
123 | { |
124 | any(static_cast<ValueType&&>(rhs)).swap(*this); |
125 | return *this; |
126 | } |
127 | #endif |
128 | |
129 | public: // queries |
130 | |
131 | bool empty() const BOOST_NOEXCEPT |
132 | { |
133 | return !content; |
134 | } |
135 | |
136 | void clear() BOOST_NOEXCEPT |
137 | { |
138 | any().swap(*this); |
139 | } |
140 | |
141 | const boost::typeindex::type_info& type() const BOOST_NOEXCEPT |
142 | { |
143 | return content ? content->type() : boost::typeindex::type_id<void>().type_info(); |
144 | } |
145 | |
146 | #ifndef BOOST_NO_MEMBER_TEMPLATE_FRIENDS |
147 | private: // types |
148 | #else |
149 | public: // types (public so any_cast can be non-friend) |
150 | #endif |
151 | |
152 | class placeholder |
153 | { |
154 | public: // structors |
155 | |
156 | virtual ~placeholder() |
157 | { |
158 | } |
159 | |
160 | public: // queries |
161 | |
162 | virtual const boost::typeindex::type_info& type() const BOOST_NOEXCEPT = 0; |
163 | |
164 | virtual placeholder * clone() const = 0; |
165 | |
166 | }; |
167 | |
168 | template<typename ValueType> |
169 | class holder : public placeholder |
170 | { |
171 | public: // structors |
172 | |
173 | holder(const ValueType & value) |
174 | : held(value) |
175 | { |
176 | } |
177 | |
178 | #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES |
179 | holder(ValueType&& value) |
180 | : held(static_cast< ValueType&& >(value)) |
181 | { |
182 | } |
183 | #endif |
184 | public: // queries |
185 | |
186 | virtual const boost::typeindex::type_info& type() const BOOST_NOEXCEPT |
187 | { |
188 | return boost::typeindex::type_id<ValueType>().type_info(); |
189 | } |
190 | |
191 | virtual placeholder * clone() const |
192 | { |
193 | return new holder(held); |
194 | } |
195 | |
196 | public: // representation |
197 | |
198 | ValueType held; |
199 | |
200 | private: // intentionally left unimplemented |
201 | holder & operator=(const holder &); |
202 | }; |
203 | |
204 | #ifndef BOOST_NO_MEMBER_TEMPLATE_FRIENDS |
205 | |
206 | private: // representation |
207 | |
208 | template<typename ValueType> |
209 | friend ValueType * any_cast(any *) BOOST_NOEXCEPT; |
210 | |
211 | template<typename ValueType> |
212 | friend ValueType * unsafe_any_cast(any *) BOOST_NOEXCEPT; |
213 | |
214 | #else |
215 | |
216 | public: // representation (public so any_cast can be non-friend) |
217 | |
218 | #endif |
219 | |
220 | placeholder * content; |
221 | |
222 | }; |
223 | |
224 | inline void swap(any & lhs, any & rhs) BOOST_NOEXCEPT |
225 | { |
226 | lhs.swap(rhs); |
227 | } |
228 | |
229 | class BOOST_SYMBOL_VISIBLE bad_any_cast : |
230 | #ifndef BOOST_NO_RTTI |
231 | public std::bad_cast |
232 | #else |
233 | public std::exception |
234 | #endif |
235 | { |
236 | public: |
237 | virtual const char * what() const BOOST_NOEXCEPT_OR_NOTHROW |
238 | { |
239 | return "boost::bad_any_cast: " |
240 | "failed conversion using boost::any_cast" ; |
241 | } |
242 | }; |
243 | |
244 | template<typename ValueType> |
245 | ValueType * any_cast(any * operand) BOOST_NOEXCEPT |
246 | { |
247 | return operand && operand->type() == boost::typeindex::type_id<ValueType>() |
248 | ? boost::addressof( |
249 | static_cast<any::holder<BOOST_DEDUCED_TYPENAME remove_cv<ValueType>::type> *>(operand->content)->held |
250 | ) |
251 | : 0; |
252 | } |
253 | |
254 | template<typename ValueType> |
255 | inline const ValueType * any_cast(const any * operand) BOOST_NOEXCEPT |
256 | { |
257 | return any_cast<ValueType>(const_cast<any *>(operand)); |
258 | } |
259 | |
260 | template<typename ValueType> |
261 | ValueType any_cast(any & operand) |
262 | { |
263 | typedef BOOST_DEDUCED_TYPENAME remove_reference<ValueType>::type nonref; |
264 | |
265 | |
266 | nonref * result = any_cast<nonref>(boost::addressof(operand)); |
267 | if(!result) |
268 | boost::throw_exception(bad_any_cast()); |
269 | |
270 | // Attempt to avoid construction of a temporary object in cases when |
271 | // `ValueType` is not a reference. Example: |
272 | // `static_cast<std::string>(*result);` |
273 | // which is equal to `std::string(*result);` |
274 | typedef BOOST_DEDUCED_TYPENAME boost::mpl::if_< |
275 | boost::is_reference<ValueType>, |
276 | ValueType, |
277 | BOOST_DEDUCED_TYPENAME boost::add_reference<ValueType>::type |
278 | >::type ref_type; |
279 | |
280 | #ifdef BOOST_MSVC |
281 | # pragma warning(push) |
282 | # pragma warning(disable: 4172) // "returning address of local variable or temporary" but *result is not local! |
283 | #endif |
284 | return static_cast<ref_type>(*result); |
285 | #ifdef BOOST_MSVC |
286 | # pragma warning(pop) |
287 | #endif |
288 | } |
289 | |
290 | template<typename ValueType> |
291 | inline ValueType any_cast(const any & operand) |
292 | { |
293 | typedef BOOST_DEDUCED_TYPENAME remove_reference<ValueType>::type nonref; |
294 | return any_cast<const nonref &>(const_cast<any &>(operand)); |
295 | } |
296 | |
297 | #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES |
298 | template<typename ValueType> |
299 | inline ValueType any_cast(any&& operand) |
300 | { |
301 | BOOST_STATIC_ASSERT_MSG( |
302 | boost::is_rvalue_reference<ValueType&&>::value /*true if ValueType is rvalue or just a value*/ |
303 | || boost::is_const< typename boost::remove_reference<ValueType>::type >::value, |
304 | "boost::any_cast shall not be used for getting nonconst references to temporary objects" |
305 | ); |
306 | return any_cast<ValueType>(operand); |
307 | } |
308 | #endif |
309 | |
310 | |
311 | // Note: The "unsafe" versions of any_cast are not part of the |
312 | // public interface and may be removed at any time. They are |
313 | // required where we know what type is stored in the any and can't |
314 | // use typeid() comparison, e.g., when our types may travel across |
315 | // different shared libraries. |
316 | template<typename ValueType> |
317 | inline ValueType * unsafe_any_cast(any * operand) BOOST_NOEXCEPT |
318 | { |
319 | return boost::addressof( |
320 | static_cast<any::holder<ValueType> *>(operand->content)->held |
321 | ); |
322 | } |
323 | |
324 | template<typename ValueType> |
325 | inline const ValueType * unsafe_any_cast(const any * operand) BOOST_NOEXCEPT |
326 | { |
327 | return unsafe_any_cast<ValueType>(const_cast<any *>(operand)); |
328 | } |
329 | } |
330 | |
331 | // Copyright Kevlin Henney, 2000, 2001, 2002. All rights reserved. |
332 | // |
333 | // Distributed under the Boost Software License, Version 1.0. (See |
334 | // accompanying file LICENSE_1_0.txt or copy at |
335 | // http://www.boost.org/LICENSE_1_0.txt) |
336 | |
337 | #endif |
338 | |