boost/boost/optional/optional.hpp

   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