1 | // Copyright (C) 2003, Fernando Luis Cacciola Carballal. |
---|
2 | // |
---|
3 | // Use, modification, and distribution is subject to the Boost Software |
---|
4 | // License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at |
---|
5 | // http://www.boost.org/LICENSE_1_0.txt) |
---|
6 | // |
---|
7 | // See http://www.boost.org/lib/optional for documentation. |
---|
8 | // |
---|
9 | // You are welcome to contact the author at: |
---|
10 | // fernando_cacciola@hotmail.com |
---|
11 | // |
---|
12 | #ifndef BOOST_OPTIONAL_OPTIONAL_FLC_19NOV2002_HPP |
---|
13 | #define BOOST_OPTIONAL_OPTIONAL_FLC_19NOV2002_HPP |
---|
14 | |
---|
15 | #include<new> |
---|
16 | #include<algorithm> |
---|
17 | |
---|
18 | #include "boost/config.hpp" |
---|
19 | #include "boost/assert.hpp" |
---|
20 | #include "boost/type.hpp" |
---|
21 | #include "boost/type_traits/alignment_of.hpp" |
---|
22 | #include "boost/type_traits/type_with_alignment.hpp" |
---|
23 | #include "boost/type_traits/remove_reference.hpp" |
---|
24 | #include "boost/type_traits/is_reference.hpp" |
---|
25 | #include "boost/mpl/if.hpp" |
---|
26 | #include "boost/mpl/bool.hpp" |
---|
27 | #include "boost/mpl/not.hpp" |
---|
28 | #include "boost/detail/reference_content.hpp" |
---|
29 | #include "boost/none.hpp" |
---|
30 | #include "boost/utility/compare_pointees.hpp" |
---|
31 | |
---|
32 | #include "boost/optional/optional_fwd.hpp" |
---|
33 | |
---|
34 | #if BOOST_WORKAROUND(BOOST_MSVC, == 1200) |
---|
35 | // VC6.0 has the following bug: |
---|
36 | // When a templated assignment operator exist, an implicit conversion |
---|
37 | // constructing an optional<T> is used when assigment of the form: |
---|
38 | // optional<T> opt ; opt = T(...); |
---|
39 | // is compiled. |
---|
40 | // However, optional's ctor is _explicit_ and the assignemt shouldn't compile. |
---|
41 | // Therefore, for VC6.0 templated assignment is disabled. |
---|
42 | // |
---|
43 | #define BOOST_OPTIONAL_NO_CONVERTING_ASSIGNMENT |
---|
44 | #endif |
---|
45 | |
---|
46 | #if BOOST_WORKAROUND(BOOST_MSVC, == 1300) |
---|
47 | // VC7.0 has the following bug: |
---|
48 | // When both a non-template and a template copy-ctor exist |
---|
49 | // and the templated version is made 'explicit', the explicit is also |
---|
50 | // given to the non-templated version, making the class non-implicitely-copyable. |
---|
51 | // |
---|
52 | #define BOOST_OPTIONAL_NO_CONVERTING_COPY_CTOR |
---|
53 | #endif |
---|
54 | |
---|
55 | #if BOOST_WORKAROUND(BOOST_MSVC, <= 1300) || BOOST_WORKAROUND(BOOST_INTEL_CXX_VERSION,<=700) |
---|
56 | // AFAICT only VC7.1 correctly resolves the overload set |
---|
57 | // that includes the in-place factory taking functions, |
---|
58 | // so for the other VC versions, in-place factory support |
---|
59 | // is disabled |
---|
60 | #define BOOST_OPTIONAL_NO_INPLACE_FACTORY_SUPPORT |
---|
61 | #endif |
---|
62 | |
---|
63 | #if BOOST_WORKAROUND(__BORLANDC__, <= 0x551) |
---|
64 | // BCB (5.5.1) cannot parse the nested template struct in an inplace factory. |
---|
65 | #define BOOST_OPTIONAL_NO_INPLACE_FACTORY_SUPPORT |
---|
66 | #endif |
---|
67 | |
---|
68 | #if !defined(BOOST_OPTIONAL_NO_INPLACE_FACTORY_SUPPORT) \ |
---|
69 | && BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x581) ) |
---|
70 | // BCB (up to 5.64) has the following bug: |
---|
71 | // If there is a member function/operator template of the form |
---|
72 | // template<class Expr> mfunc( Expr expr ) ; |
---|
73 | // some calls are resolved to this even if there are other better matches. |
---|
74 | // The effect of this bug is that calls to converting ctors and assignments |
---|
75 | // are incrorrectly sink to this general catch-all member function template as shown above. |
---|
76 | #define BOOST_OPTIONAL_WEAK_OVERLOAD_RESOLUTION |
---|
77 | #endif |
---|
78 | |
---|
79 | // Daniel Wallin discovered that bind/apply.hpp badly interacts with the apply<> |
---|
80 | // member template of a factory as used in the optional<> implementation. |
---|
81 | // He proposed this simple fix which is to move the call to apply<> outside |
---|
82 | // namespace boost. |
---|
83 | namespace boost_optional_detail |
---|
84 | { |
---|
85 | template <class T, class Factory> |
---|
86 | void construct(Factory const& factory, void* address) |
---|
87 | { |
---|
88 | factory.BOOST_NESTED_TEMPLATE apply<T>(address); |
---|
89 | } |
---|
90 | } |
---|
91 | |
---|
92 | |
---|
93 | namespace boost { |
---|
94 | |
---|
95 | class in_place_factory_base ; |
---|
96 | class typed_in_place_factory_base ; |
---|
97 | |
---|
98 | namespace optional_detail { |
---|
99 | |
---|
100 | // This local class is used instead of that in "aligned_storage.hpp" |
---|
101 | // because I've found the 'official' class to ICE BCB5.5 |
---|
102 | // when some types are used with optional<> |
---|
103 | // (due to sizeof() passed down as a non-type template parameter) |
---|
104 | template <class T> |
---|
105 | class aligned_storage |
---|
106 | { |
---|
107 | // Borland ICEs if unnamed unions are used for this! |
---|
108 | union dummy_u |
---|
109 | { |
---|
110 | char data[ sizeof(T) ]; |
---|
111 | BOOST_DEDUCED_TYPENAME type_with_alignment< |
---|
112 | ::boost::alignment_of<T>::value >::type aligner_; |
---|
113 | } dummy_ ; |
---|
114 | |
---|
115 | public: |
---|
116 | |
---|
117 | void const* address() const { return &dummy_.data[0]; } |
---|
118 | void * address() { return &dummy_.data[0]; } |
---|
119 | } ; |
---|
120 | |
---|
121 | template<class T> |
---|
122 | struct types_when_isnt_ref |
---|
123 | { |
---|
124 | typedef T const& reference_const_type ; |
---|
125 | typedef T & reference_type ; |
---|
126 | typedef T const* pointer_const_type ; |
---|
127 | typedef T * pointer_type ; |
---|
128 | typedef T const& argument_type ; |
---|
129 | } ; |
---|
130 | template<class T> |
---|
131 | struct types_when_is_ref |
---|
132 | { |
---|
133 | typedef BOOST_DEDUCED_TYPENAME remove_reference<T>::type raw_type ; |
---|
134 | |
---|
135 | typedef raw_type& reference_const_type ; |
---|
136 | typedef raw_type& reference_type ; |
---|
137 | typedef raw_type* pointer_const_type ; |
---|
138 | typedef raw_type* pointer_type ; |
---|
139 | typedef raw_type& argument_type ; |
---|
140 | } ; |
---|
141 | |
---|
142 | struct optional_tag {} ; |
---|
143 | |
---|
144 | template<class T> |
---|
145 | class optional_base : public optional_tag |
---|
146 | { |
---|
147 | private : |
---|
148 | |
---|
149 | typedef |
---|
150 | #if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) |
---|
151 | BOOST_DEDUCED_TYPENAME |
---|
152 | #endif |
---|
153 | ::boost::detail::make_reference_content<T>::type internal_type ; |
---|
154 | |
---|
155 | typedef aligned_storage<internal_type> storage_type ; |
---|
156 | |
---|
157 | typedef types_when_isnt_ref<T> types_when_not_ref ; |
---|
158 | typedef types_when_is_ref<T> types_when_ref ; |
---|
159 | |
---|
160 | typedef optional_base<T> this_type ; |
---|
161 | |
---|
162 | protected : |
---|
163 | |
---|
164 | typedef T value_type ; |
---|
165 | |
---|
166 | typedef mpl::true_ is_reference_tag ; |
---|
167 | typedef mpl::false_ is_not_reference_tag ; |
---|
168 | |
---|
169 | typedef BOOST_DEDUCED_TYPENAME is_reference<T>::type is_reference_predicate ; |
---|
170 | |
---|
171 | typedef BOOST_DEDUCED_TYPENAME mpl::if_<is_reference_predicate,types_when_ref,types_when_not_ref>::type types ; |
---|
172 | |
---|
173 | typedef bool (this_type::*unspecified_bool_type)() const; |
---|
174 | |
---|
175 | typedef BOOST_DEDUCED_TYPENAME types::reference_type reference_type ; |
---|
176 | typedef BOOST_DEDUCED_TYPENAME types::reference_const_type reference_const_type ; |
---|
177 | typedef BOOST_DEDUCED_TYPENAME types::pointer_type pointer_type ; |
---|
178 | typedef BOOST_DEDUCED_TYPENAME types::pointer_const_type pointer_const_type ; |
---|
179 | typedef BOOST_DEDUCED_TYPENAME types::argument_type argument_type ; |
---|
180 | |
---|
181 | // Creates an optional<T> uninitialized. |
---|
182 | // No-throw |
---|
183 | optional_base() |
---|
184 | : |
---|
185 | m_initialized(false) {} |
---|
186 | |
---|
187 | // Creates an optional<T> uninitialized. |
---|
188 | // No-throw |
---|
189 | optional_base ( none_t ) |
---|
190 | : |
---|
191 | m_initialized(false) {} |
---|
192 | |
---|
193 | // Creates an optional<T> initialized with 'val'. |
---|
194 | // Can throw if T::T(T const&) does |
---|
195 | optional_base ( argument_type val ) |
---|
196 | : |
---|
197 | m_initialized(false) |
---|
198 | { |
---|
199 | construct(val); |
---|
200 | } |
---|
201 | |
---|
202 | // Creates an optional<T> initialized with 'val' IFF cond is true, otherwise creates an uninitialzed optional<T>. |
---|
203 | // Can throw if T::T(T const&) does |
---|
204 | optional_base ( bool cond, argument_type val ) |
---|
205 | : |
---|
206 | m_initialized(false) |
---|
207 | { |
---|
208 | if ( cond ) |
---|
209 | construct(val); |
---|
210 | } |
---|
211 | |
---|
212 | // Creates a deep copy of another optional<T> |
---|
213 | // Can throw if T::T(T const&) does |
---|
214 | optional_base ( optional_base const& rhs ) |
---|
215 | : |
---|
216 | m_initialized(false) |
---|
217 | { |
---|
218 | if ( rhs.is_initialized() ) |
---|
219 | construct(rhs.get_impl()); |
---|
220 | } |
---|
221 | |
---|
222 | |
---|
223 | // This is used for both converting and in-place constructions. |
---|
224 | // Derived classes use the 'tag' to select the appropriate |
---|
225 | // implementation (the correct 'construct()' overload) |
---|
226 | template<class Expr> |
---|
227 | explicit optional_base ( Expr const& expr, Expr const* tag ) |
---|
228 | : |
---|
229 | m_initialized(false) |
---|
230 | { |
---|
231 | construct(expr,tag); |
---|
232 | } |
---|
233 | |
---|
234 | |
---|
235 | |
---|
236 | // No-throw (assuming T::~T() doesn't) |
---|
237 | ~optional_base() { destroy() ; } |
---|
238 | |
---|
239 | // Assigns from another optional<T> (deep-copies the rhs value) |
---|
240 | void assign ( optional_base const& rhs ) |
---|
241 | { |
---|
242 | if (is_initialized()) |
---|
243 | { |
---|
244 | if ( rhs.is_initialized() ) |
---|
245 | assign_value(rhs.get_impl(), is_reference_predicate() ); |
---|
246 | else destroy(); |
---|
247 | } |
---|
248 | else |
---|
249 | { |
---|
250 | if ( rhs.is_initialized() ) |
---|
251 | construct(rhs.get_impl()); |
---|
252 | } |
---|
253 | } |
---|
254 | |
---|
255 | // Assigns from another _convertible_ optional<U> (deep-copies the rhs value) |
---|
256 | template<class U> |
---|
257 | void assign ( optional<U> const& rhs ) |
---|
258 | { |
---|
259 | if (is_initialized()) |
---|
260 | { |
---|
261 | if ( rhs.is_initialized() ) |
---|
262 | assign_value(static_cast<value_type>(rhs.get()), is_reference_predicate() ); |
---|
263 | else destroy(); |
---|
264 | } |
---|
265 | else |
---|
266 | { |
---|
267 | if ( rhs.is_initialized() ) |
---|
268 | construct(static_cast<value_type>(rhs.get())); |
---|
269 | } |
---|
270 | } |
---|
271 | |
---|
272 | // Assigns from a T (deep-copies the rhs value) |
---|
273 | void assign ( argument_type val ) |
---|
274 | { |
---|
275 | if (is_initialized()) |
---|
276 | assign_value(val, is_reference_predicate() ); |
---|
277 | else construct(val); |
---|
278 | } |
---|
279 | |
---|
280 | // Assigns from "none", destroying the current value, if any, leaving this UNINITIALIZED |
---|
281 | // No-throw (assuming T::~T() doesn't) |
---|
282 | void assign ( none_t ) { destroy(); } |
---|
283 | |
---|
284 | #ifndef BOOST_OPTIONAL_NO_INPLACE_FACTORY_SUPPORT |
---|
285 | template<class Expr> |
---|
286 | void assign_expr ( Expr const& expr, Expr const* tag ) |
---|
287 | { |
---|
288 | if (is_initialized()) |
---|
289 | assign_expr_to_initialized(expr,tag); |
---|
290 | else construct(expr,tag); |
---|
291 | } |
---|
292 | #endif |
---|
293 | |
---|
294 | public : |
---|
295 | |
---|
296 | // Destroys the current value, if any, leaving this UNINITIALIZED |
---|
297 | // No-throw (assuming T::~T() doesn't) |
---|
298 | void reset() { destroy(); } |
---|
299 | |
---|
300 | // Replaces the current value -if any- with 'val' |
---|
301 | void reset ( argument_type val ) { assign(val); } |
---|
302 | |
---|
303 | // Returns a pointer to the value if this is initialized, otherwise, |
---|
304 | // returns NULL. |
---|
305 | // No-throw |
---|
306 | pointer_const_type get_ptr() const { return m_initialized ? get_ptr_impl() : 0 ; } |
---|
307 | pointer_type get_ptr() { return m_initialized ? get_ptr_impl() : 0 ; } |
---|
308 | |
---|
309 | bool is_initialized() const { return m_initialized ; } |
---|
310 | |
---|
311 | protected : |
---|
312 | |
---|
313 | void construct ( argument_type val ) |
---|
314 | { |
---|
315 | new (m_storage.address()) internal_type(val) ; |
---|
316 | m_initialized = true ; |
---|
317 | } |
---|
318 | |
---|
319 | #ifndef BOOST_OPTIONAL_NO_INPLACE_FACTORY_SUPPORT |
---|
320 | // Constructs in-place using the given factory |
---|
321 | template<class Expr> |
---|
322 | void construct ( Expr const& factory, in_place_factory_base const* ) |
---|
323 | { |
---|
324 | BOOST_STATIC_ASSERT ( ::boost::mpl::not_<is_reference_predicate>::value ) ; |
---|
325 | boost_optional_detail::construct<value_type>(factory, m_storage.address()); |
---|
326 | m_initialized = true ; |
---|
327 | } |
---|
328 | |
---|
329 | // Constructs in-place using the given typed factory |
---|
330 | template<class Expr> |
---|
331 | void construct ( Expr const& factory, typed_in_place_factory_base const* ) |
---|
332 | { |
---|
333 | BOOST_STATIC_ASSERT ( ::boost::mpl::not_<is_reference_predicate>::value ) ; |
---|
334 | factory.apply(m_storage.address()) ; |
---|
335 | m_initialized = true ; |
---|
336 | } |
---|
337 | |
---|
338 | template<class Expr> |
---|
339 | void assign_expr_to_initialized ( Expr const& factory, in_place_factory_base const* tag ) |
---|
340 | { |
---|
341 | destroy(); |
---|
342 | construct(factory,tag); |
---|
343 | } |
---|
344 | |
---|
345 | // Constructs in-place using the given typed factory |
---|
346 | template<class Expr> |
---|
347 | void assign_expr_to_initialized ( Expr const& factory, typed_in_place_factory_base const* tag ) |
---|
348 | { |
---|
349 | destroy(); |
---|
350 | construct(factory,tag); |
---|
351 | } |
---|
352 | #endif |
---|
353 | |
---|
354 | // Constructs using any expression implicitely convertible to the single argument |
---|
355 | // of a one-argument T constructor. |
---|
356 | // Converting constructions of optional<T> from optional<U> uses this function with |
---|
357 | // 'Expr' being of type 'U' and relying on a converting constructor of T from U. |
---|
358 | template<class Expr> |
---|
359 | void construct ( Expr const& expr, void const* ) |
---|
360 | { |
---|
361 | new (m_storage.address()) internal_type(expr) ; |
---|
362 | m_initialized = true ; |
---|
363 | } |
---|
364 | |
---|
365 | // Assigns using a form any expression implicitely convertible to the single argument |
---|
366 | // of a T's assignment operator. |
---|
367 | // Converting assignments of optional<T> from optional<U> uses this function with |
---|
368 | // 'Expr' being of type 'U' and relying on a converting assignment of T from U. |
---|
369 | template<class Expr> |
---|
370 | void assign_expr_to_initialized ( Expr const& expr, void const* ) |
---|
371 | { |
---|
372 | assign_value(expr, is_reference_predicate()); |
---|
373 | } |
---|
374 | |
---|
375 | #ifdef BOOST_OPTIONAL_WEAK_OVERLOAD_RESOLUTION |
---|
376 | // BCB5.64 (and probably lower versions) workaround. |
---|
377 | // The in-place factories are supported by means of catch-all constructors |
---|
378 | // and assignment operators (the functions are parameterized in terms of |
---|
379 | // an arbitrary 'Expr' type) |
---|
380 | // This compiler incorrectly resolves the overload set and sinks optional<T> and optional<U> |
---|
381 | // to the 'Expr'-taking functions even though explicit overloads are present for them. |
---|
382 | // Thus, the following overload is needed to properly handle the case when the 'lhs' |
---|
383 | // is another optional. |
---|
384 | // |
---|
385 | // For VC<=70 compilers this workaround dosen't work becasue the comnpiler issues and error |
---|
386 | // instead of choosing the wrong overload |
---|
387 | // |
---|
388 | // Notice that 'Expr' will be optional<T> or optional<U> (but not optional_base<..>) |
---|
389 | template<class Expr> |
---|
390 | void construct ( Expr const& expr, optional_tag const* ) |
---|
391 | { |
---|
392 | if ( expr.is_initialized() ) |
---|
393 | { |
---|
394 | // An exception can be thrown here. |
---|
395 | // It it happens, THIS will be left uninitialized. |
---|
396 | new (m_storage.address()) internal_type(expr.get()) ; |
---|
397 | m_initialized = true ; |
---|
398 | } |
---|
399 | } |
---|
400 | #endif |
---|
401 | |
---|
402 | void assign_value ( argument_type val, is_not_reference_tag ) { get_impl() = val; } |
---|
403 | void assign_value ( argument_type val, is_reference_tag ) { construct(val); } |
---|
404 | |
---|
405 | void destroy() |
---|
406 | { |
---|
407 | if ( m_initialized ) |
---|
408 | destroy_impl(is_reference_predicate()) ; |
---|
409 | } |
---|
410 | |
---|
411 | unspecified_bool_type safe_bool() const { return m_initialized ? &this_type::is_initialized : 0 ; } |
---|
412 | |
---|
413 | reference_const_type get_impl() const { return dereference(get_object(), is_reference_predicate() ) ; } |
---|
414 | reference_type get_impl() { return dereference(get_object(), is_reference_predicate() ) ; } |
---|
415 | |
---|
416 | pointer_const_type get_ptr_impl() const { return cast_ptr(get_object(), is_reference_predicate() ) ; } |
---|
417 | pointer_type get_ptr_impl() { return cast_ptr(get_object(), is_reference_predicate() ) ; } |
---|
418 | |
---|
419 | private : |
---|
420 | |
---|
421 | // internal_type can be either T or reference_content<T> |
---|
422 | internal_type const* get_object() const { return static_cast<internal_type const*>(m_storage.address()); } |
---|
423 | internal_type * get_object() { return static_cast<internal_type *> (m_storage.address()); } |
---|
424 | |
---|
425 | // reference_content<T> lacks an implicit conversion to T&, so the following is needed to obtain a proper reference. |
---|
426 | reference_const_type dereference( internal_type const* p, is_not_reference_tag ) const { return *p ; } |
---|
427 | reference_type dereference( internal_type* p, is_not_reference_tag ) { return *p ; } |
---|
428 | reference_const_type dereference( internal_type const* p, is_reference_tag ) const { return p->get() ; } |
---|
429 | reference_type dereference( internal_type* p, is_reference_tag ) { return p->get() ; } |
---|
430 | |
---|
431 | #if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x581)) |
---|
432 | void destroy_impl ( is_not_reference_tag ) { get_ptr_impl()->internal_type::~internal_type() ; m_initialized = false ; } |
---|
433 | #else |
---|
434 | void destroy_impl ( is_not_reference_tag ) { get_ptr_impl()->T::~T() ; m_initialized = false ; } |
---|
435 | #endif |
---|
436 | |
---|
437 | void destroy_impl ( is_reference_tag ) { m_initialized = false ; } |
---|
438 | |
---|
439 | // If T is of reference type, trying to get a pointer to the held value must result in a compile-time error. |
---|
440 | // Decent compilers should disallow conversions from reference_content<T>* to T*, but just in case, |
---|
441 | // the following olverloads are used to filter out the case and guarantee an error in case of T being a reference. |
---|
442 | pointer_const_type cast_ptr( internal_type const* p, is_not_reference_tag ) const { return p ; } |
---|
443 | pointer_type cast_ptr( internal_type * p, is_not_reference_tag ) { return p ; } |
---|
444 | pointer_const_type cast_ptr( internal_type const* p, is_reference_tag ) const { return &p->get() ; } |
---|
445 | pointer_type cast_ptr( internal_type * p, is_reference_tag ) { return &p->get() ; } |
---|
446 | |
---|
447 | bool m_initialized ; |
---|
448 | storage_type m_storage ; |
---|
449 | } ; |
---|
450 | |
---|
451 | } // namespace optional_detail |
---|
452 | |
---|
453 | template<class T> |
---|
454 | class optional : public optional_detail::optional_base<T> |
---|
455 | { |
---|
456 | typedef optional_detail::optional_base<T> base ; |
---|
457 | |
---|
458 | typedef BOOST_DEDUCED_TYPENAME base::unspecified_bool_type unspecified_bool_type ; |
---|
459 | |
---|
460 | public : |
---|
461 | |
---|
462 | typedef optional<T> this_type ; |
---|
463 | |
---|
464 | typedef BOOST_DEDUCED_TYPENAME base::value_type value_type ; |
---|
465 | typedef BOOST_DEDUCED_TYPENAME base::reference_type reference_type ; |
---|
466 | typedef BOOST_DEDUCED_TYPENAME base::reference_const_type reference_const_type ; |
---|
467 | typedef BOOST_DEDUCED_TYPENAME base::pointer_type pointer_type ; |
---|
468 | typedef BOOST_DEDUCED_TYPENAME base::pointer_const_type pointer_const_type ; |
---|
469 | typedef BOOST_DEDUCED_TYPENAME base::argument_type argument_type ; |
---|
470 | |
---|
471 | // Creates an optional<T> uninitialized. |
---|
472 | // No-throw |
---|
473 | optional() : base() {} |
---|
474 | |
---|
475 | // Creates an optional<T> uninitialized. |
---|
476 | // No-throw |
---|
477 | optional( none_t none_ ) : base(none_) {} |
---|
478 | |
---|
479 | // Creates an optional<T> initialized with 'val'. |
---|
480 | // Can throw if T::T(T const&) does |
---|
481 | optional ( argument_type val ) : base(val) {} |
---|
482 | |
---|
483 | // Creates an optional<T> initialized with 'val' IFF cond is true, otherwise creates an uninitialized optional. |
---|
484 | // Can throw if T::T(T const&) does |
---|
485 | optional ( bool cond, argument_type val ) : base(cond,val) {} |
---|
486 | |
---|
487 | #ifndef BOOST_OPTIONAL_NO_CONVERTING_COPY_CTOR |
---|
488 | // NOTE: MSVC needs templated versions first |
---|
489 | |
---|
490 | // Creates a deep copy of another convertible optional<U> |
---|
491 | // Requires a valid conversion from U to T. |
---|
492 | // Can throw if T::T(U const&) does |
---|
493 | template<class U> |
---|
494 | explicit optional ( optional<U> const& rhs ) |
---|
495 | : |
---|
496 | base() |
---|
497 | { |
---|
498 | if ( rhs.is_initialized() ) |
---|
499 | this->construct(rhs.get()); |
---|
500 | } |
---|
501 | #endif |
---|
502 | |
---|
503 | #ifndef BOOST_OPTIONAL_NO_INPLACE_FACTORY_SUPPORT |
---|
504 | // Creates an optional<T> with an expression which can be either |
---|
505 | // (a) An instance of InPlaceFactory (i.e. in_place(a,b,...,n); |
---|
506 | // (b) An instance of TypedInPlaceFactory ( i.e. in_place<T>(a,b,...,n); |
---|
507 | // (c) Any expression implicitely convertible to the single type |
---|
508 | // of a one-argument T's constructor. |
---|
509 | // (d*) Weak compilers (BCB) might also resolved Expr as optional<T> and optional<U> |
---|
510 | // even though explicit overloads are present for these. |
---|
511 | // Depending on the above some T ctor is called. |
---|
512 | // Can throw is the resolved T ctor throws. |
---|
513 | template<class Expr> |
---|
514 | explicit optional ( Expr const& expr ) : base(expr,&expr) {} |
---|
515 | #endif |
---|
516 | |
---|
517 | // Creates a deep copy of another optional<T> |
---|
518 | // Can throw if T::T(T const&) does |
---|
519 | optional ( optional const& rhs ) : base(rhs) {} |
---|
520 | |
---|
521 | // No-throw (assuming T::~T() doesn't) |
---|
522 | ~optional() {} |
---|
523 | |
---|
524 | #if !defined(BOOST_OPTIONAL_NO_INPLACE_FACTORY_SUPPORT) && !defined(BOOST_OPTIONAL_WEAK_OVERLOAD_RESOLUTION) |
---|
525 | // Assigns from an expression. See corresponding constructor. |
---|
526 | // Basic Guarantee: If the resolved T ctor throws, this is left UNINITIALIZED |
---|
527 | template<class Expr> |
---|
528 | optional& operator= ( Expr expr ) |
---|
529 | { |
---|
530 | this->assign_expr(expr,&expr); |
---|
531 | return *this ; |
---|
532 | } |
---|
533 | #endif |
---|
534 | |
---|
535 | |
---|
536 | #ifndef BOOST_OPTIONAL_NO_CONVERTING_ASSIGNMENT |
---|
537 | // Assigns from another convertible optional<U> (converts && deep-copies the rhs value) |
---|
538 | // Requires a valid conversion from U to T. |
---|
539 | // Basic Guarantee: If T::T( U const& ) throws, this is left UNINITIALIZED |
---|
540 | template<class U> |
---|
541 | optional& operator= ( optional<U> const& rhs ) |
---|
542 | { |
---|
543 | this->assign(rhs); |
---|
544 | return *this ; |
---|
545 | } |
---|
546 | #endif |
---|
547 | |
---|
548 | // Assigns from another optional<T> (deep-copies the rhs value) |
---|
549 | // Basic Guarantee: If T::T( T const& ) throws, this is left UNINITIALIZED |
---|
550 | // (NOTE: On BCB, this operator is not actually called and left is left UNMODIFIED in case of a throw) |
---|
551 | optional& operator= ( optional const& rhs ) |
---|
552 | { |
---|
553 | this->assign( rhs ) ; |
---|
554 | return *this ; |
---|
555 | } |
---|
556 | |
---|
557 | // Assigns from a T (deep-copies the rhs value) |
---|
558 | // Basic Guarantee: If T::( T const& ) throws, this is left UNINITIALIZED |
---|
559 | optional& operator= ( argument_type val ) |
---|
560 | { |
---|
561 | this->assign( val ) ; |
---|
562 | return *this ; |
---|
563 | } |
---|
564 | |
---|
565 | // Assigns from a "none" |
---|
566 | // Which destroys the current value, if any, leaving this UNINITIALIZED |
---|
567 | // No-throw (assuming T::~T() doesn't) |
---|
568 | optional& operator= ( none_t none_ ) |
---|
569 | { |
---|
570 | this->assign( none_ ) ; |
---|
571 | return *this ; |
---|
572 | } |
---|
573 | |
---|
574 | // Returns a reference to the value if this is initialized, otherwise, |
---|
575 | // the behaviour is UNDEFINED |
---|
576 | // No-throw |
---|
577 | reference_const_type get() const { BOOST_ASSERT(this->is_initialized()) ; return this->get_impl(); } |
---|
578 | reference_type get() { BOOST_ASSERT(this->is_initialized()) ; return this->get_impl(); } |
---|
579 | |
---|
580 | // Returns a copy of the value if this is initialized, 'v' otherwise |
---|
581 | reference_const_type get_value_or ( reference_const_type v ) const { return this->is_initialized() ? get() : v ; } |
---|
582 | reference_type get_value_or ( reference_type v ) { return this->is_initialized() ? get() : v ; } |
---|
583 | |
---|
584 | // Returns a pointer to the value if this is initialized, otherwise, |
---|
585 | // the behaviour is UNDEFINED |
---|
586 | // No-throw |
---|
587 | pointer_const_type operator->() const { BOOST_ASSERT(this->is_initialized()) ; return this->get_ptr_impl() ; } |
---|
588 | pointer_type operator->() { BOOST_ASSERT(this->is_initialized()) ; return this->get_ptr_impl() ; } |
---|
589 | |
---|
590 | // Returns a reference to the value if this is initialized, otherwise, |
---|
591 | // the behaviour is UNDEFINED |
---|
592 | // No-throw |
---|
593 | reference_const_type operator *() const { return this->get() ; } |
---|
594 | reference_type operator *() { return this->get() ; } |
---|
595 | |
---|
596 | // implicit conversion to "bool" |
---|
597 | // No-throw |
---|
598 | operator unspecified_bool_type() const { return this->safe_bool() ; } |
---|
599 | |
---|
600 | // This is provided for those compilers which don't like the conversion to bool |
---|
601 | // on some contexts. |
---|
602 | bool operator!() const { return !this->is_initialized() ; } |
---|
603 | } ; |
---|
604 | |
---|
605 | // Returns optional<T>(v) |
---|
606 | template<class T> |
---|
607 | inline |
---|
608 | optional<T> make_optional ( T const& v ) |
---|
609 | { |
---|
610 | return optional<T>(v); |
---|
611 | } |
---|
612 | |
---|
613 | // Returns optional<T>(cond,v) |
---|
614 | template<class T> |
---|
615 | inline |
---|
616 | optional<T> make_optional ( bool cond, T const& v ) |
---|
617 | { |
---|
618 | return optional<T>(cond,v); |
---|
619 | } |
---|
620 | |
---|
621 | // Returns a reference to the value if this is initialized, otherwise, the behaviour is UNDEFINED. |
---|
622 | // No-throw |
---|
623 | template<class T> |
---|
624 | inline |
---|
625 | BOOST_DEDUCED_TYPENAME optional<T>::reference_const_type |
---|
626 | get ( optional<T> const& opt ) |
---|
627 | { |
---|
628 | return opt.get() ; |
---|
629 | } |
---|
630 | |
---|
631 | template<class T> |
---|
632 | inline |
---|
633 | BOOST_DEDUCED_TYPENAME optional<T>::reference_type |
---|
634 | get ( optional<T>& opt ) |
---|
635 | { |
---|
636 | return opt.get() ; |
---|
637 | } |
---|
638 | |
---|
639 | // Returns a pointer to the value if this is initialized, otherwise, returns NULL. |
---|
640 | // No-throw |
---|
641 | template<class T> |
---|
642 | inline |
---|
643 | BOOST_DEDUCED_TYPENAME optional<T>::pointer_const_type |
---|
644 | get ( optional<T> const* opt ) |
---|
645 | { |
---|
646 | return opt->get_ptr() ; |
---|
647 | } |
---|
648 | |
---|
649 | template<class T> |
---|
650 | inline |
---|
651 | BOOST_DEDUCED_TYPENAME optional<T>::pointer_type |
---|
652 | get ( optional<T>* opt ) |
---|
653 | { |
---|
654 | return opt->get_ptr() ; |
---|
655 | } |
---|
656 | |
---|
657 | // Returns a reference to the value if this is initialized, otherwise, the behaviour is UNDEFINED. |
---|
658 | // No-throw |
---|
659 | template<class T> |
---|
660 | inline |
---|
661 | BOOST_DEDUCED_TYPENAME optional<T>::reference_const_type |
---|
662 | get_optional_value_or ( optional<T> const& opt, BOOST_DEDUCED_TYPENAME optional<T>::reference_const_type v ) |
---|
663 | { |
---|
664 | return opt.get_value_or(v) ; |
---|
665 | } |
---|
666 | |
---|
667 | template<class T> |
---|
668 | inline |
---|
669 | BOOST_DEDUCED_TYPENAME optional<T>::reference_type |
---|
670 | get_optional_value_or ( optional<T>& opt, BOOST_DEDUCED_TYPENAME optional<T>::reference_type v ) |
---|
671 | { |
---|
672 | return opt.get_value_or(v) ; |
---|
673 | } |
---|
674 | |
---|
675 | // Returns a pointer to the value if this is initialized, otherwise, returns NULL. |
---|
676 | // No-throw |
---|
677 | template<class T> |
---|
678 | inline |
---|
679 | BOOST_DEDUCED_TYPENAME optional<T>::pointer_const_type |
---|
680 | get_pointer ( optional<T> const& opt ) |
---|
681 | { |
---|
682 | return opt.get_ptr() ; |
---|
683 | } |
---|
684 | |
---|
685 | template<class T> |
---|
686 | inline |
---|
687 | BOOST_DEDUCED_TYPENAME optional<T>::pointer_type |
---|
688 | get_pointer ( optional<T>& opt ) |
---|
689 | { |
---|
690 | return opt.get_ptr() ; |
---|
691 | } |
---|
692 | |
---|
693 | // optional's relational operators ( ==, !=, <, >, <=, >= ) have deep-semantics (compare values). |
---|
694 | // WARNING: This is UNLIKE pointers. Use equal_pointees()/less_pointess() in generic code instead. |
---|
695 | |
---|
696 | |
---|
697 | // |
---|
698 | // optional<T> vs optional<T> cases |
---|
699 | // |
---|
700 | |
---|
701 | template<class T> |
---|
702 | inline |
---|
703 | bool operator == ( optional<T> const& x, optional<T> const& y ) |
---|
704 | { return equal_pointees(x,y); } |
---|
705 | |
---|
706 | template<class T> |
---|
707 | inline |
---|
708 | bool operator < ( optional<T> const& x, optional<T> const& y ) |
---|
709 | { return less_pointees(x,y); } |
---|
710 | |
---|
711 | template<class T> |
---|
712 | inline |
---|
713 | bool operator != ( optional<T> const& x, optional<T> const& y ) |
---|
714 | { return !( x == y ) ; } |
---|
715 | |
---|
716 | template<class T> |
---|
717 | inline |
---|
718 | bool operator > ( optional<T> const& x, optional<T> const& y ) |
---|
719 | { return y < x ; } |
---|
720 | |
---|
721 | template<class T> |
---|
722 | inline |
---|
723 | bool operator <= ( optional<T> const& x, optional<T> const& y ) |
---|
724 | { return !( y < x ) ; } |
---|
725 | |
---|
726 | template<class T> |
---|
727 | inline |
---|
728 | bool operator >= ( optional<T> const& x, optional<T> const& y ) |
---|
729 | { return !( x < y ) ; } |
---|
730 | |
---|
731 | |
---|
732 | // |
---|
733 | // optional<T> vs T cases |
---|
734 | // |
---|
735 | template<class T> |
---|
736 | inline |
---|
737 | bool operator == ( optional<T> const& x, T const& y ) |
---|
738 | { return equal_pointees(x, optional<T>(y)); } |
---|
739 | |
---|
740 | template<class T> |
---|
741 | inline |
---|
742 | bool operator < ( optional<T> const& x, T const& y ) |
---|
743 | { return less_pointees(x, optional<T>(y)); } |
---|
744 | |
---|
745 | template<class T> |
---|
746 | inline |
---|
747 | bool operator != ( optional<T> const& x, T const& y ) |
---|
748 | { return !( x == y ) ; } |
---|
749 | |
---|
750 | template<class T> |
---|
751 | inline |
---|
752 | bool operator > ( optional<T> const& x, T const& y ) |
---|
753 | { return y < x ; } |
---|
754 | |
---|
755 | template<class T> |
---|
756 | inline |
---|
757 | bool operator <= ( optional<T> const& x, T const& y ) |
---|
758 | { return !( y < x ) ; } |
---|
759 | |
---|
760 | template<class T> |
---|
761 | inline |
---|
762 | bool operator >= ( optional<T> const& x, T const& y ) |
---|
763 | { return !( x < y ) ; } |
---|
764 | |
---|
765 | // |
---|
766 | // T vs optional<T> cases |
---|
767 | // |
---|
768 | |
---|
769 | template<class T> |
---|
770 | inline |
---|
771 | bool operator == ( T const& x, optional<T> const& y ) |
---|
772 | { return equal_pointees( optional<T>(x), y ); } |
---|
773 | |
---|
774 | template<class T> |
---|
775 | inline |
---|
776 | bool operator < ( T const& x, optional<T> const& y ) |
---|
777 | { return less_pointees( optional<T>(x), y ); } |
---|
778 | |
---|
779 | template<class T> |
---|
780 | inline |
---|
781 | bool operator != ( T const& x, optional<T> const& y ) |
---|
782 | { return !( x == y ) ; } |
---|
783 | |
---|
784 | template<class T> |
---|
785 | inline |
---|
786 | bool operator > ( T const& x, optional<T> const& y ) |
---|
787 | { return y < x ; } |
---|
788 | |
---|
789 | template<class T> |
---|
790 | inline |
---|
791 | bool operator <= ( T const& x, optional<T> const& y ) |
---|
792 | { return !( y < x ) ; } |
---|
793 | |
---|
794 | template<class T> |
---|
795 | inline |
---|
796 | bool operator >= ( T const& x, optional<T> const& y ) |
---|
797 | { return !( x < y ) ; } |
---|
798 | |
---|
799 | |
---|
800 | // |
---|
801 | // optional<T> vs none cases |
---|
802 | // |
---|
803 | |
---|
804 | template<class T> |
---|
805 | inline |
---|
806 | bool operator == ( optional<T> const& x, none_t ) |
---|
807 | { return equal_pointees(x, optional<T>() ); } |
---|
808 | |
---|
809 | template<class T> |
---|
810 | inline |
---|
811 | bool operator < ( optional<T> const& x, none_t ) |
---|
812 | { return less_pointees(x,optional<T>() ); } |
---|
813 | |
---|
814 | template<class T> |
---|
815 | inline |
---|
816 | bool operator != ( optional<T> const& x, none_t y ) |
---|
817 | { return !( x == y ) ; } |
---|
818 | |
---|
819 | template<class T> |
---|
820 | inline |
---|
821 | bool operator > ( optional<T> const& x, none_t y ) |
---|
822 | { return y < x ; } |
---|
823 | |
---|
824 | template<class T> |
---|
825 | inline |
---|
826 | bool operator <= ( optional<T> const& x, none_t y ) |
---|
827 | { return !( y < x ) ; } |
---|
828 | |
---|
829 | template<class T> |
---|
830 | inline |
---|
831 | bool operator >= ( optional<T> const& x, none_t y ) |
---|
832 | { return !( x < y ) ; } |
---|
833 | |
---|
834 | // |
---|
835 | // none vs optional<T> cases |
---|
836 | // |
---|
837 | |
---|
838 | template<class T> |
---|
839 | inline |
---|
840 | bool operator == ( none_t x, optional<T> const& y ) |
---|
841 | { return equal_pointees(optional<T>() ,y); } |
---|
842 | |
---|
843 | template<class T> |
---|
844 | inline |
---|
845 | bool operator < ( none_t x, optional<T> const& y ) |
---|
846 | { return less_pointees(optional<T>() ,y); } |
---|
847 | |
---|
848 | template<class T> |
---|
849 | inline |
---|
850 | bool operator != ( none_t x, optional<T> const& y ) |
---|
851 | { return !( x == y ) ; } |
---|
852 | |
---|
853 | template<class T> |
---|
854 | inline |
---|
855 | bool operator > ( none_t x, optional<T> const& y ) |
---|
856 | { return y < x ; } |
---|
857 | |
---|
858 | template<class T> |
---|
859 | inline |
---|
860 | bool operator <= ( none_t x, optional<T> const& y ) |
---|
861 | { return !( y < x ) ; } |
---|
862 | |
---|
863 | template<class T> |
---|
864 | inline |
---|
865 | bool operator >= ( none_t x, optional<T> const& y ) |
---|
866 | { return !( x < y ) ; } |
---|
867 | |
---|
868 | // |
---|
869 | // The following swap implementation follows the GCC workaround as found in |
---|
870 | // "boost/detail/compressed_pair.hpp" |
---|
871 | // |
---|
872 | namespace optional_detail { |
---|
873 | |
---|
874 | // GCC < 3.2 gets the using declaration at namespace scope (FLC, DWA) |
---|
875 | #if BOOST_WORKAROUND(__GNUC__, < 3) \ |
---|
876 | || BOOST_WORKAROUND(__GNUC__, == 3) && __GNUC_MINOR__ <= 2 |
---|
877 | using std::swap; |
---|
878 | #define BOOST_OPTIONAL_STD_SWAP_INTRODUCED_AT_NS_SCOPE |
---|
879 | #endif |
---|
880 | |
---|
881 | // optional's swap: |
---|
882 | // If both are initialized, calls swap(T&, T&). If this swap throws, both will remain initialized but their values are now unspecified. |
---|
883 | // If only one is initialized, calls U.reset(*I), THEN I.reset(). |
---|
884 | // If U.reset(*I) throws, both are left UNCHANGED (U is kept uinitialized and I is never reset) |
---|
885 | // If both are uninitialized, do nothing (no-throw) |
---|
886 | template<class T> |
---|
887 | inline |
---|
888 | void optional_swap ( optional<T>& x, optional<T>& y ) |
---|
889 | { |
---|
890 | if ( !x && !!y ) |
---|
891 | { |
---|
892 | x.reset(*y); |
---|
893 | y.reset(); |
---|
894 | } |
---|
895 | else if ( !!x && !y ) |
---|
896 | { |
---|
897 | y.reset(*x); |
---|
898 | x.reset(); |
---|
899 | } |
---|
900 | else if ( !!x && !!y ) |
---|
901 | { |
---|
902 | // GCC > 3.2 and all other compilers have the using declaration at function scope (FLC) |
---|
903 | #ifndef BOOST_OPTIONAL_STD_SWAP_INTRODUCED_AT_NS_SCOPE |
---|
904 | // allow for Koenig lookup |
---|
905 | using std::swap ; |
---|
906 | #endif |
---|
907 | swap(*x,*y); |
---|
908 | } |
---|
909 | } |
---|
910 | |
---|
911 | } // namespace optional_detail |
---|
912 | |
---|
913 | template<class T> inline void swap ( optional<T>& x, optional<T>& y ) |
---|
914 | { |
---|
915 | optional_detail::optional_swap(x,y); |
---|
916 | } |
---|
917 | |
---|
918 | |
---|
919 | } // namespace boost |
---|
920 | |
---|
921 | #endif |
---|
922 | |
---|