3rdparty/boost/boost/optional/detail/optional_trivially_copyable_base.hpp

   1 // trivilally-copyable version of the storage
   2
   3 template<class T>
   4 class tc_optional_base : public optional_tag
   5 {
   6   private :
   7
   8     typedef tc_optional_base<T> this_type ;
   9
  10   protected :
  11
  12     typedef T value_type ;
  13
  14   protected:
  15     typedef T &       reference_type ;
  16     typedef T const&  reference_const_type ;
  17 #ifndef  BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES
  18     typedef T &&  rval_reference_type ;
  19     typedef T &&  reference_type_of_temporary_wrapper ;
  20 #endif
  21     typedef T *         pointer_type ;
  22     typedef T const*    pointer_const_type ;
  23     typedef T const&    argument_type ;
  24
  25     tc_optional_base()
  26       :
  27       m_initialized(false) {}
  28
  29     tc_optional_base ( none_t )
  30       :
  31       m_initialized(false) {}
  32
  33     tc_optional_base ( init_value_tag, argument_type val )
  34       :
  35       m_initialized(true), m_storage(val) {}
  36
  37     tc_optional_base ( bool cond, argument_type val )
  38       :
  39       m_initialized(cond), m_storage(val) {}
  40
  41     // tc_optional_base ( tc_optional_base const& ) = default;
  42
  43
  44 #ifndef  BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES
  45
  46     template<class Expr, class PtrExpr>
  47     explicit tc_optional_base ( Expr&& expr, PtrExpr const* tag )
  48       :
  49       m_initialized(false)
  50     {
  51       construct(boost::forward<Expr>(expr),tag);
  52     }
  53
  54 #else
  55     // This is used for both converting and in-place constructions.
  56     // Derived classes use the 'tag' to select the appropriate
  57     // implementation (the correct 'construct()' overload)
  58     template<class Expr>
  59     explicit tc_optional_base ( Expr const& expr, Expr const* tag )
  60       :
  61       m_initialized(false)
  62     {
  63       construct(expr,tag);
  64     }
  65
  66 #endif
  67
  68     // tc_optional_base& operator= ( tc_optional_base const& ) = default;
  69     // ~tc_optional_base() = default;
  70
  71     // Assigns from another optional<T> (deep-copies the rhs value)
  72     void assign ( tc_optional_base const& rhs )
  73     {
  74       *this = rhs;
  75     }
  76
  77     // Assigns from another _convertible_ optional<U> (deep-copies the rhs value)
  78     template<class U>
  79     void assign ( optional<U> const& rhs )
  80     {
  81       if ( rhs.is_initialized() )
  82 #ifndef BOOST_OPTIONAL_CONFIG_RESTORE_ASSIGNMENT_OF_NONCONVERTIBLE_TYPES
  83         m_storage = rhs.get();
  84 #else
  85         m_storage = static_cast<value_type>(rhs.get());
  86 #endif
  87
  88       m_initialized = rhs.is_initialized();
  89     }
  90
  91 #ifndef BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES
  92     // move-assigns from another _convertible_ optional<U> (deep-moves from the rhs value)
  93     template<class U>
  94     void assign ( optional<U>&& rhs )
  95     {
  96       typedef BOOST_DEDUCED_TYPENAME optional<U>::rval_reference_type ref_type;
  97       if ( rhs.is_initialized() )
  98         m_storage = static_cast<ref_type>(rhs.get());
  99       m_initialized = rhs.is_initialized();
 100     }
 101 #endif
 102
 103     void assign ( argument_type val )
 104     {
 105       construct(val);
 106     }
 107
 108     void assign ( none_t ) { destroy(); }
 109
 110 #ifndef BOOST_OPTIONAL_NO_INPLACE_FACTORY_SUPPORT
 111
 112 #ifndef BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES
 113     template<class Expr, class ExprPtr>
 114     void assign_expr ( Expr&& expr, ExprPtr const* tag )
 115     {
 116        construct(boost::forward<Expr>(expr),tag);
 117     }
 118 #else
 119     template<class Expr>
 120     void assign_expr ( Expr const& expr, Expr const* tag )
 121     {
 122       construct(expr,tag);
 123     }
 124 #endif
 125
 126 #endif
 127
 128   public :
 129
 130     // Destroys the current value, if any, leaving this UNINITIALIZED
 131     // No-throw (assuming T::~T() doesn't)
 132     void reset() BOOST_NOEXCEPT { destroy(); }
 133
 134     // **DEPPRECATED** Replaces the current value -if any- with 'val'
 135     void reset ( argument_type val ) BOOST_NOEXCEPT { assign(val); }
 136
 137     // Returns a pointer to the value if this is initialized, otherwise,
 138     // returns NULL.
 139     // No-throw
 140     pointer_const_type get_ptr() const { return m_initialized ? get_ptr_impl() : 0 ; }
 141     pointer_type       get_ptr()       { return m_initialized ? get_ptr_impl() : 0 ; }
 142
 143     bool is_initialized() const { return m_initialized ; }
 144
 145   protected :
 146
 147     void construct ( argument_type val )
 148      {
 149        m_storage = val ;
 150        m_initialized = true ;
 151      }
 152
 153
 154 #if (!defined BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES) && (!defined BOOST_NO_CXX11_VARIADIC_TEMPLATES)
 155     // Constructs in-place
 156     // upon exception *this is always uninitialized
 157     template<class... Args>
 158     void construct ( in_place_init_t, Args&&... args )
 159     {
 160       m_storage = value_type( boost::forward<Args>(args)... ) ;
 161       m_initialized = true ;
 162     }
 163
 164     template<class... Args>
 165     void emplace_assign ( Args&&... args )
 166     {
 167       construct(in_place_init, boost::forward<Args>(args)...);
 168     }
 169
 170     template<class... Args>
 171     explicit tc_optional_base ( in_place_init_t, Args&&... args )
 172       :
 173       m_initialized(false)
 174     {
 175       construct(in_place_init, boost::forward<Args>(args)...);
 176     }
 177
 178     template<class... Args>
 179     explicit tc_optional_base ( in_place_init_if_t, bool cond, Args&&... args )
 180       :
 181       m_initialized(false)
 182     {
 183       if ( cond )
 184         construct(in_place_init, boost::forward<Args>(args)...);
 185     }
 186 #elif (!defined BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES)
 187     template<class Arg>
 188     void construct ( in_place_init_t, Arg&& arg )
 189      {
 190        m_storage = value_type( boost::forward<Arg>(arg) );
 191        m_initialized = true ;
 192      }
 193
 194     void construct ( in_place_init_t )
 195      {
 196        m_storage = value_type();
 197        m_initialized = true ;
 198      }
 199
 200     template<class Arg>
 201     void emplace_assign ( Arg&& arg )
 202      {
 203        construct(in_place_init, boost::forward<Arg>(arg)) ;
 204      }
 205
 206     void emplace_assign ()
 207      {
 208        construct(in_place_init) ;
 209      }
 210
 211     template<class Arg>
 212     explicit tc_optional_base ( in_place_init_t, Arg&& arg )
 213       :
 214       m_initialized(false)
 215     {
 216       construct(in_place_init, boost::forward<Arg>(arg));
 217     }
 218
 219     explicit tc_optional_base ( in_place_init_t )
 220       :
 221       m_initialized(false), m_storage() {}
 222
 223     template<class Arg>
 224     explicit tc_optional_base ( in_place_init_if_t, bool cond, Arg&& arg )
 225       :
 226       m_initialized(false)
 227     {
 228       if ( cond )
 229         construct(in_place_init, boost::forward<Arg>(arg));
 230     }
 231
 232     explicit tc_optional_base ( in_place_init_if_t, bool cond )
 233       :
 234       m_initialized(false)
 235     {
 236       if ( cond )
 237         construct(in_place_init);
 238     }
 239
 240 #else
 241
 242     template<class Arg>
 243     void construct ( in_place_init_t, const Arg& arg )
 244      {
 245        m_storage = value_type( arg );
 246        m_initialized = true ;
 247      }
 248
 249     template<class Arg>
 250     void construct ( in_place_init_t, Arg& arg )
 251      {
 252        m_storage = value_type( arg );
 253        m_initialized = true ;
 254      }
 255
 256     void construct ( in_place_init_t )
 257      {
 258        m_storage = value_type();
 259        m_initialized = true ;
 260      }
 261
 262     template<class Arg>
 263     void emplace_assign ( const Arg& arg )
 264     {
 265       construct(in_place_init, arg);
 266     }
 267
 268     template<class Arg>
 269     void emplace_assign ( Arg& arg )
 270     {
 271       construct(in_place_init, arg);
 272     }
 273
 274     void emplace_assign ()
 275     {
 276       construct(in_place_init);
 277     }
 278
 279     template<class Arg>
 280     explicit tc_optional_base ( in_place_init_t, const Arg& arg )
 281       : m_initialized(false)
 282     {
 283       construct(in_place_init, arg);
 284     }
 285
 286     template<class Arg>
 287     explicit tc_optional_base ( in_place_init_t, Arg& arg )
 288       : m_initialized(false)
 289     {
 290       construct(in_place_init, arg);
 291     }
 292
 293     explicit tc_optional_base ( in_place_init_t )
 294       : m_initialized(false)
 295     {
 296       construct(in_place_init);
 297     }
 298
 299     template<class Arg>
 300     explicit tc_optional_base ( in_place_init_if_t, bool cond, const Arg& arg )
 301       : m_initialized(false)
 302     {
 303       if ( cond )
 304         construct(in_place_init, arg);
 305     }
 306
 307     template<class Arg>
 308     explicit tc_optional_base ( in_place_init_if_t, bool cond, Arg& arg )
 309       : m_initialized(false)
 310     {
 311       if ( cond )
 312         construct(in_place_init, arg);
 313     }
 314
 315     explicit tc_optional_base ( in_place_init_if_t, bool cond )
 316       : m_initialized(false)
 317     {
 318       if ( cond )
 319         construct(in_place_init);
 320     }
 321 #endif
 322
 323 #ifndef BOOST_OPTIONAL_NO_INPLACE_FACTORY_SUPPORT
 324
 325 #ifndef BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES
 326     // Constructs in-place using the given factory
 327     template<class Expr>
 328     void construct ( Expr&& factory, in_place_factory_base const* )
 329      {
 330        boost_optional_detail::construct<value_type>(factory, boost::addressof(m_storage));
 331        m_initialized = true ;
 332      }
 333
 334     // Constructs in-place using the given typed factory
 335     template<class Expr>
 336     void construct ( Expr&& factory, typed_in_place_factory_base const* )
 337      {
 338        factory.apply(boost::addressof(m_storage)) ;
 339        m_initialized = true ;
 340      }
 341
 342     template<class Expr>
 343     void assign_expr_to_initialized ( Expr&& factory, in_place_factory_base const* tag )
 344      {
 345        destroy();
 346        construct(factory,tag);
 347      }
 348
 349     // Constructs in-place using the given typed factory
 350     template<class Expr>
 351     void assign_expr_to_initialized ( Expr&& factory, typed_in_place_factory_base const* tag )
 352      {
 353        destroy();
 354        construct(factory,tag);
 355      }
 356
 357 #else
 358     // Constructs in-place using the given factory
 359     template<class Expr>
 360     void construct ( Expr const& factory, in_place_factory_base const* )
 361      {
 362        boost_optional_detail::construct<value_type>(factory, m_storage.address());
 363        m_initialized = true ;
 364      }
 365
 366     // Constructs in-place using the given typed factory
 367     template<class Expr>
 368     void construct ( Expr const& factory, typed_in_place_factory_base const* )
 369      {
 370        factory.apply(boost::addressof(m_storage)) ;
 371        m_initialized = true ;
 372      }
 373
 374     template<class Expr>
 375     void assign_expr_to_initialized ( Expr const& factory, in_place_factory_base const* tag )
 376      {
 377        destroy();
 378        construct(factory,tag);
 379      }
 380
 381     // Constructs in-place using the given typed factory
 382     template<class Expr>
 383     void assign_expr_to_initialized ( Expr const& factory, typed_in_place_factory_base const* tag )
 384      {
 385        destroy();
 386        construct(factory,tag);
 387      }
 388 #endif
 389
 390 #endif
 391
 392 #ifndef BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES
 393     // Constructs using any expression implicitly convertible to the single argument
 394     // of a one-argument T constructor.
 395     // Converting constructions of optional<T> from optional<U> uses this function with
 396     // 'Expr' being of type 'U' and relying on a converting constructor of T from U.
 397     template<class Expr>
 398     void construct ( Expr&& expr, void const* )
 399     {
 400       m_storage = value_type(boost::forward<Expr>(expr)) ;
 401       m_initialized = true ;
 402     }
 403
 404     // Assigns using a form any expression implicitly convertible to the single argument
 405     // of a T's assignment operator.
 406     // Converting assignments of optional<T> from optional<U> uses this function with
 407     // 'Expr' being of type 'U' and relying on a converting assignment of T from U.
 408     template<class Expr>
 409     void assign_expr_to_initialized ( Expr&& expr, void const* )
 410     {
 411       assign_value( boost::forward<Expr>(expr) );
 412     }
 413 #else
 414     // Constructs using any expression implicitly convertible to the single argument
 415     // of a one-argument T constructor.
 416     // Converting constructions of optional<T> from optional<U> uses this function with
 417     // 'Expr' being of type 'U' and relying on a converting constructor of T from U.
 418     template<class Expr>
 419     void construct ( Expr const& expr, void const* )
 420      {
 421        m_storage = value_type(expr) ;
 422        m_initialized = true ;
 423      }
 424
 425     // Assigns using a form any expression implicitly convertible to the single argument
 426     // of a T's assignment operator.
 427     // Converting assignments of optional<T> from optional<U> uses this function with
 428     // 'Expr' being of type 'U' and relying on a converting assignment of T from U.
 429     template<class Expr>
 430     void assign_expr_to_initialized ( Expr const& expr, void const* )
 431      {
 432        assign_value(expr);
 433      }
 434
 435 #endif
 436
 437 #ifdef BOOST_OPTIONAL_WEAK_OVERLOAD_RESOLUTION
 438     // BCB5.64 (and probably lower versions) workaround.
 439     //   The in-place factories are supported by means of catch-all constructors
 440     //   and assignment operators (the functions are parameterized in terms of
 441     //   an arbitrary 'Expr' type)
 442     //   This compiler incorrectly resolves the overload set and sinks optional<T> and optional<U>
 443     //   to the 'Expr'-taking functions even though explicit overloads are present for them.
 444     //   Thus, the following overload is needed to properly handle the case when the 'lhs'
 445     //   is another optional.
 446     //
 447     // For VC<=70 compilers this workaround dosen't work becasue the comnpiler issues and error
 448     // instead of choosing the wrong overload
 449     //
 450 #ifndef  BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES
 451     // Notice that 'Expr' will be optional<T> or optional<U> (but not tc_optional_base<..>)
 452     template<class Expr>
 453     void construct ( Expr&& expr, optional_tag const* )
 454      {
 455        if ( expr.is_initialized() )
 456        {
 457          // An exception can be thrown here.
 458          // It it happens, THIS will be left uninitialized.
 459          m_storage = value_type(boost::move(expr.get())) ;
 460          m_initialized = true ;
 461        }
 462      }
 463 #else
 464     // Notice that 'Expr' will be optional<T> or optional<U> (but not tc_optional_base<..>)
 465     template<class Expr>
 466     void construct ( Expr const& expr, optional_tag const* )
 467      {
 468        if ( expr.is_initialized() )
 469        {
 470          // An exception can be thrown here.
 471          // It it happens, THIS will be left uninitialized.
 472          m_storage = value_type(expr.get()) ;
 473          m_initialized = true ;
 474        }
 475      }
 476 #endif
 477 #endif // defined BOOST_OPTIONAL_WEAK_OVERLOAD_RESOLUTION
 478
 479     void assign_value ( argument_type val ) { m_storage = val; }
 480 #ifndef  BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES
 481     void assign_value ( rval_reference_type val ) { m_storage = static_cast<rval_reference_type>(val); }
 482 #endif
 483
 484     void destroy()
 485     {
 486       m_initialized = false;
 487     }
 488
 489     reference_const_type get_impl() const { return m_storage ; }
 490     reference_type       get_impl()       { return m_storage ; }
 491
 492     pointer_const_type get_ptr_impl() const { return boost::addressof(m_storage); }
 493     pointer_type       get_ptr_impl()       { return boost::addressof(m_storage); }
 494
 495   private :
 496
 497     bool m_initialized ;
 498     T    m_storage ;
 499 } ;