libstdc++-v3/include/std/any

   1 // <any> -*- C++ -*-
   2
   3 // Copyright (C) 2014-2017 Free Software Foundation, Inc.
   4 //
   5 // This file is part of the GNU ISO C++ Library.  This library is free
   6 // software; you can redistribute it and/or modify it under the
   7 // terms of the GNU General Public License as published by the
   8 // Free Software Foundation; either version 3, or (at your option)
   9 // any later version.
  10
  11 // This library is distributed in the hope that it will be useful,
  12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 // GNU General Public License for more details.
  15
  16 // Under Section 7 of GPL version 3, you are granted additional
  17 // permissions described in the GCC Runtime Library Exception, version
  18 // 3.1, as published by the Free Software Foundation.
  19
  20 // You should have received a copy of the GNU General Public License and
  21 // a copy of the GCC Runtime Library Exception along with this program;
  22 // see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
  23 // <http://www.gnu.org/licenses/>.
  24
  25 /** @file include/any
  26  *  This is a Standard C++ Library header.
  27  */
  28
  29 #ifndef _GLIBCXX_ANY
  30 #define _GLIBCXX_ANY 1
  31
  32 #pragma GCC system_header
  33
  34 #if __cplusplus >= 201703L
  35
  36 #include <typeinfo>
  37 #include <new>
  38 #include <utility>
  39 #include <type_traits>
  40
  41 namespace std _GLIBCXX_VISIBILITY(default)
  42 {
  43 _GLIBCXX_BEGIN_NAMESPACE_VERSION
  44
  45   /**
  46    *  @addtogroup utilities
  47    *  @{
  48    */
  49
  50   /**
  51    *  @brief Exception class thrown by a failed @c any_cast
  52    *  @ingroup exceptions
  53    */
  54   class bad_any_cast : public bad_cast
  55   {
  56   public:
  57     virtual const char* what() const noexcept { return "bad any_cast"; }
  58   };
  59
  60   [[gnu::noreturn]] inline void __throw_bad_any_cast()
  61   {
  62 #if __cpp_exceptions
  63     throw bad_any_cast{};
  64 #else
  65     __builtin_abort();
  66 #endif
  67   }
  68
  69 #define __cpp_lib_any 201603
  70
  71   /**
  72    *  @brief A type-safe container of any type.
  73    *
  74    *  An @c any object's state is either empty or it stores a contained object
  75    *  of CopyConstructible type.
  76    */
  77   class any
  78   {
  79     // Holds either pointer to a heap object or the contained object itself.
  80     union _Storage
  81     {
  82       constexpr _Storage() : _M_ptr{nullptr} {}
  83
  84       // Prevent trivial copies of this type, buffer might hold a non-POD.
  85       _Storage(const _Storage&) = delete;
  86       _Storage& operator=(const _Storage&) = delete;
  87
  88       void* _M_ptr;
  89       aligned_storage<sizeof(_M_ptr), alignof(void*)>::type _M_buffer;
  90     };
  91
  92     template<typename _Tp, typename _Safe = is_nothrow_move_constructible<_Tp>,
  93              bool _Fits = (sizeof(_Tp) <= sizeof(_Storage))
  94                           && (alignof(_Tp) <= alignof(_Storage))>
  95       using _Internal = std::integral_constant<bool, _Safe::value && _Fits>;
  96
  97     template<typename _Tp>
  98       struct _Manager_internal; // uses small-object optimization
  99
 100     template<typename _Tp>
 101       struct _Manager_external; // creates contained object on the heap
 102
 103     template<typename _Tp>
 104       using _Manager = conditional_t<_Internal<_Tp>::value,
 105                                      _Manager_internal<_Tp>,
 106                                      _Manager_external<_Tp>>;
 107
 108     template<typename _Tp, typename _Decayed = decay_t<_Tp>>
 109       using _Decay = enable_if_t<!is_same<_Decayed, any>::value, _Decayed>;
 110
 111     /// Emplace with an object created from @p __args as the contained object.
 112     template <typename _Tp, typename... _Args,
 113               typename _Mgr = _Manager<_Tp>>
 114       void __do_emplace(_Args&&... __args)
 115       {
 116         reset();
 117         _M_manager = &_Mgr::_S_manage;
 118         _Mgr::_S_create(_M_storage, std::forward<_Args>(__args)...);
 119       }
 120
 121     /// Emplace with an object created from @p __il and @p __args as
 122     /// the contained object.
 123     template <typename _Tp, typename _Up, typename... _Args,
 124               typename _Mgr = _Manager<_Tp>>
 125       void __do_emplace(initializer_list<_Up> __il, _Args&&... __args)
 126       {
 127         reset();
 128         _M_manager = &_Mgr::_S_manage;
 129         _Mgr::_S_create(_M_storage, __il, std::forward<_Args>(__args)...);
 130       }
 131
 132   public:
 133     // construct/destruct
 134
 135     /// Default constructor, creates an empty object.
 136     constexpr any() noexcept : _M_manager(nullptr) { }
 137
 138     /// Copy constructor, copies the state of @p __other
 139     any(const any& __other)
 140     {
 141       if (!__other.has_value())
 142         _M_manager = nullptr;
 143       else
 144         {
 145           _Arg __arg;
 146           __arg._M_any = this;
 147           __other._M_manager(_Op_clone, &__other, &__arg);
 148         }
 149     }
 150
 151     /**
 152      * @brief Move constructor, transfer the state from @p __other
 153      *
 154      * @post @c !__other.has_value() (this postcondition is a GNU extension)
 155      */
 156     any(any&& __other) noexcept
 157     {
 158       if (!__other.has_value())
 159         _M_manager = nullptr;
 160       else
 161         {
 162           _Arg __arg;
 163           __arg._M_any = this;
 164           __other._M_manager(_Op_xfer, &__other, &__arg);
 165         }
 166     }
 167
 168     template <typename _Res, typename _Tp, typename... _Args>
 169     using __any_constructible =
 170       enable_if<__and_<is_copy_constructible<_Tp>,
 171                          is_constructible<_Tp, _Args...>>::value,
 172                   _Res>;
 173
 174     template <typename _Tp, typename... _Args>
 175     using __any_constructible_t =
 176       typename __any_constructible<bool, _Tp, _Args...>::type;
 177
 178     /// Construct with a copy of @p __value as the contained object.
 179     template <typename _ValueType, typename _Tp = _Decay<_ValueType>,
 180               typename _Mgr = _Manager<_Tp>,
 181               __any_constructible_t<_Tp, _ValueType&&> = true,
 182               enable_if_t<!__is_in_place_type<_Tp>::value, bool> = true>
 183       any(_ValueType&& __value)
 184       : _M_manager(&_Mgr::_S_manage)
 185       {
 186         _Mgr::_S_create(_M_storage, std::forward<_ValueType>(__value));
 187       }
 188
 189     /// Construct with a copy of @p __value as the contained object.
 190     template <typename _ValueType, typename _Tp = _Decay<_ValueType>,
 191               typename _Mgr = _Manager<_Tp>,
 192               enable_if_t<__and_<is_copy_constructible<_Tp>,
 193                                  __not_<is_constructible<_Tp, _ValueType&&>>,
 194                                  __not_<__is_in_place_type<_Tp>>>::value,
 195                           bool> = false>
 196       any(_ValueType&& __value)
 197       : _M_manager(&_Mgr::_S_manage)
 198       {
 199         _Mgr::_S_create(_M_storage, __value);
 200       }
 201
 202     /// Construct with an object created from @p __args as the contained object.
 203     template <typename _ValueType, typename... _Args,
 204               typename _Tp = _Decay<_ValueType>,
 205               typename _Mgr = _Manager<_Tp>,
 206               __any_constructible_t<_Tp, _Args&&...> = false>
 207       explicit
 208       any(in_place_type_t<_ValueType>, _Args&&... __args)
 209       : _M_manager(&_Mgr::_S_manage)
 210       {
 211         _Mgr::_S_create(_M_storage, std::forward<_Args>(__args)...);
 212       }
 213
 214     /// Construct with an object created from @p __il and @p __args as
 215     /// the contained object.
 216     template <typename _ValueType, typename _Up, typename... _Args,
 217               typename _Tp = _Decay<_ValueType>,
 218               typename _Mgr = _Manager<_Tp>,
 219               __any_constructible_t<_Tp, initializer_list<_Up>,
 220                                     _Args&&...> = false>
 221       explicit
 222       any(in_place_type_t<_ValueType>,
 223           initializer_list<_Up> __il, _Args&&... __args)
 224       : _M_manager(&_Mgr::_S_manage)
 225       {
 226         _Mgr::_S_create(_M_storage, __il, std::forward<_Args>(__args)...);
 227       }
 228
 229     /// Destructor, calls @c reset()
 230     ~any() { reset(); }
 231
 232     // assignments
 233
 234     /// Copy the state of another object.
 235     any& operator=(const any& __rhs)
 236     {
 237       *this = any(__rhs);
 238       return *this;
 239     }
 240
 241     /**
 242      * @brief Move assignment operator
 243      *
 244      * @post @c !__rhs.has_value() (not guaranteed for other implementations)
 245      */
 246     any& operator=(any&& __rhs) noexcept
 247     {
 248       if (!__rhs.has_value())
 249         reset();
 250       else if (this != &__rhs)
 251         {
 252           reset();
 253           _Arg __arg;
 254           __arg._M_any = this;
 255           __rhs._M_manager(_Op_xfer, &__rhs, &__arg);
 256         }
 257       return *this;
 258     }
 259
 260     /// Store a copy of @p __rhs as the contained object.
 261     template<typename _ValueType>
 262       enable_if_t<is_copy_constructible<_Decay<_ValueType>>::value, any&>
 263       operator=(_ValueType&& __rhs)
 264       {
 265         *this = any(std::forward<_ValueType>(__rhs));
 266         return *this;
 267       }
 268
 269     /// Emplace with an object created from @p __args as the contained object.
 270     template <typename _ValueType, typename... _Args>
 271       typename __any_constructible<_Decay<_ValueType>&,
 272                                    _Decay<_ValueType>, _Args&&...>::type
 273       emplace(_Args&&... __args)
 274       {
 275         __do_emplace<_Decay<_ValueType>>
 276           (std::forward<_Args>(__args)...);
 277         any::_Arg __arg;
 278         this->_M_manager(any::_Op_access, this, &__arg);
 279         return *static_cast<_Decay<_ValueType>*>(__arg._M_obj);
 280       }
 281
 282     /// Emplace with an object created from @p __il and @p __args as
 283     /// the contained object.
 284     template <typename _ValueType, typename _Up, typename... _Args>
 285       typename __any_constructible<_Decay<_ValueType>&,
 286                                    _Decay<_ValueType>,
 287                                    initializer_list<_Up>,
 288                                    _Args&&...>::type
 289       emplace(initializer_list<_Up> __il, _Args&&... __args)
 290       {
 291         __do_emplace<_Decay<_ValueType>, _Up>
 292           (__il, std::forward<_Args>(__args)...);
 293         any::_Arg __arg;
 294         this->_M_manager(any::_Op_access, this, &__arg);
 295         return *static_cast<_Decay<_ValueType>*>(__arg._M_obj);
 296       }
 297
 298     // modifiers
 299
 300     /// If not empty, destroy the contained object.
 301     void reset() noexcept
 302     {
 303       if (has_value())
 304       {
 305         _M_manager(_Op_destroy, this, nullptr);
 306         _M_manager = nullptr;
 307       }
 308     }
 309
 310     /// Exchange state with another object.
 311     void swap(any& __rhs) noexcept
 312     {
 313       if (!has_value() && !__rhs.has_value())
 314         return;
 315
 316       if (has_value() && __rhs.has_value())
 317         {
 318           if (this == &__rhs)
 319             return;
 320
 321           any __tmp;
 322           _Arg __arg;
 323           __arg._M_any = &__tmp;
 324           __rhs._M_manager(_Op_xfer, &__rhs, &__arg);
 325           __arg._M_any = &__rhs;
 326           _M_manager(_Op_xfer, this, &__arg);
 327           __arg._M_any = this;
 328           __tmp._M_manager(_Op_xfer, &__tmp, &__arg);
 329         }
 330       else
 331         {
 332           any* __empty = !has_value() ? this : &__rhs;
 333           any* __full = !has_value() ? &__rhs : this;
 334           _Arg __arg;
 335           __arg._M_any = __empty;
 336           __full->_M_manager(_Op_xfer, __full, &__arg);
 337         }
 338     }
 339
 340     // observers
 341
 342     /// Reports whether there is a contained object or not.
 343     bool has_value() const noexcept { return _M_manager != nullptr; }
 344
 345 #if __cpp_rtti
 346     /// The @c typeid of the contained object, or @c typeid(void) if empty.
 347     const type_info& type() const noexcept
 348     {
 349       if (!has_value())
 350         return typeid(void);
 351       _Arg __arg;
 352       _M_manager(_Op_get_type_info, this, &__arg);
 353       return *__arg._M_typeinfo;
 354     }
 355 #endif
 356
 357     template<typename _Tp>
 358       static constexpr bool __is_valid_cast()
 359       { return __or_<is_reference<_Tp>, is_copy_constructible<_Tp>>::value; }
 360
 361   private:
 362     enum _Op {
 363         _Op_access, _Op_get_type_info, _Op_clone, _Op_destroy, _Op_xfer
 364     };
 365
 366     union _Arg
 367     {
 368         void* _M_obj;
 369         const std::type_info* _M_typeinfo;
 370         any* _M_any;
 371     };
 372
 373     void (*_M_manager)(_Op, const any*, _Arg*);
 374     _Storage _M_storage;
 375
 376     template<typename _Tp>
 377       friend void* __any_caster(const any* __any);
 378
 379     // Manage in-place contained object.
 380     template<typename _Tp>
 381       struct _Manager_internal
 382       {
 383         static void
 384         _S_manage(_Op __which, const any* __anyp, _Arg* __arg);
 385
 386         template<typename _Up>
 387           static void
 388           _S_create(_Storage& __storage, _Up&& __value)
 389           {
 390             void* __addr = &__storage._M_buffer;
 391             ::new (__addr) _Tp(std::forward<_Up>(__value));
 392           }
 393
 394         template<typename... _Args>
 395           static void
 396           _S_create(_Storage& __storage, _Args&&... __args)
 397           {
 398             void* __addr = &__storage._M_buffer;
 399             ::new (__addr) _Tp(std::forward<_Args>(__args)...);
 400           }
 401       };
 402
 403     // Manage external contained object.
 404     template<typename _Tp>
 405       struct _Manager_external
 406       {
 407         static void
 408         _S_manage(_Op __which, const any* __anyp, _Arg* __arg);
 409
 410         template<typename _Up>
 411           static void
 412           _S_create(_Storage& __storage, _Up&& __value)
 413           {
 414             __storage._M_ptr = new _Tp(std::forward<_Up>(__value));
 415           }
 416         template<typename... _Args>
 417           static void
 418           _S_create(_Storage& __storage, _Args&&... __args)
 419           {
 420             __storage._M_ptr = new _Tp(std::forward<_Args>(__args)...);
 421           }
 422       };
 423   };
 424
 425   /// Exchange the states of two @c any objects.
 426   inline void swap(any& __x, any& __y) noexcept { __x.swap(__y); }
 427
 428   /// Create an any holding a @c _Tp constructed from @c __args.
 429   template <typename _Tp, typename... _Args>
 430     any make_any(_Args&&... __args)
 431     {
 432       return any(in_place_type<_Tp>, std::forward<_Args>(__args)...);
 433     }
 434
 435   /// Create an any holding a @c _Tp constructed from @c __il and @c __args.
 436   template <typename _Tp, typename _Up, typename... _Args>
 437     any make_any(initializer_list<_Up> __il, _Args&&... __args)
 438     {
 439       return any(in_place_type<_Tp>, __il, std::forward<_Args>(__args)...);
 440     }
 441
 442   template <typename _Tp>
 443     using _AnyCast = remove_cv_t<remove_reference_t<_Tp>>;
 444   /**
 445    * @brief Access the contained object.
 446    *
 447    * @tparam  _ValueType  A const-reference or CopyConstructible type.
 448    * @param   __any       The object to access.
 449    * @return  The contained object.
 450    * @throw   bad_any_cast If <code>
 451    *          __any.type() != typeid(remove_reference_t<_ValueType>)
 452    *          </code>
 453    */
 454   template<typename _ValueType>
 455     inline _ValueType any_cast(const any& __any)
 456     {
 457       static_assert(any::__is_valid_cast<_ValueType>(),
 458           "Template argument must be a reference or CopyConstructible type");
 459       auto __p = any_cast<_AnyCast<_ValueType>>(&__any);
 460       if (__p)
 461         return static_cast<_ValueType>(*__p);
 462       __throw_bad_any_cast();
 463     }
 464
 465   /**
 466    * @brief Access the contained object.
 467    *
 468    * @tparam  _ValueType  A reference or CopyConstructible type.
 469    * @param   __any       The object to access.
 470    * @return  The contained object.
 471    * @throw   bad_any_cast If <code>
 472    *          __any.type() != typeid(remove_reference_t<_ValueType>)
 473    *          </code>
 474    *
 475    * @{
 476    */
 477   template<typename _ValueType>
 478     inline _ValueType any_cast(any& __any)
 479     {
 480       static_assert(any::__is_valid_cast<_ValueType>(),
 481           "Template argument must be a reference or CopyConstructible type");
 482       auto __p = any_cast<_AnyCast<_ValueType>>(&__any);
 483       if (__p)
 484         return static_cast<_ValueType>(*__p);
 485       __throw_bad_any_cast();
 486     }
 487
 488   template<typename _ValueType,
 489            typename enable_if<!is_move_constructible<_ValueType>::value
 490                               || is_lvalue_reference<_ValueType>::value,
 491                               bool>::type = true>
 492     inline _ValueType any_cast(any&& __any)
 493     {
 494       static_assert(any::__is_valid_cast<_ValueType>(),
 495           "Template argument must be a reference or CopyConstructible type");
 496       auto __p = any_cast<_AnyCast<_ValueType>>(&__any);
 497       if (__p)
 498         return static_cast<_ValueType>(*__p);
 499       __throw_bad_any_cast();
 500     }
 501
 502   template<typename _ValueType,
 503            typename enable_if<is_move_constructible<_ValueType>::value
 504                               && !is_lvalue_reference<_ValueType>::value,
 505                               bool>::type = false>
 506     inline _ValueType any_cast(any&& __any)
 507     {
 508       static_assert(any::__is_valid_cast<_ValueType>(),
 509           "Template argument must be a reference or CopyConstructible type");
 510       auto __p = any_cast<_AnyCast<_ValueType>>(&__any);
 511       if (__p)
 512         return static_cast<_ValueType>(std::move(*__p));
 513       __throw_bad_any_cast();
 514     }
 515   // @}
 516
 517   template<typename _Tp>
 518     void* __any_caster(const any* __any)
 519     {
 520       if constexpr (is_copy_constructible_v<decay_t<_Tp>>)
 521         {
 522           if (__any->_M_manager == &any::_Manager<decay_t<_Tp>>::_S_manage)
 523             {
 524               any::_Arg __arg;
 525               __any->_M_manager(any::_Op_access, __any, &__arg);
 526               return __arg._M_obj;
 527             }
 528         }
 529       return nullptr;
 530     }
 531
 532   /**
 533    * @brief Access the contained object.
 534    *
 535    * @tparam  _ValueType  The type of the contained object.
 536    * @param   __any       A pointer to the object to access.
 537    * @return  The address of the contained object if <code>
 538    *          __any != nullptr && __any.type() == typeid(_ValueType)
 539    *          </code>, otherwise a null pointer.
 540    *
 541    * @{
 542    */
 543   template<typename _ValueType>
 544     inline const _ValueType* any_cast(const any* __any) noexcept
 545     {
 546       if (__any)
 547         return static_cast<_ValueType*>(__any_caster<_ValueType>(__any));
 548       return nullptr;
 549     }
 550
 551   template<typename _ValueType>
 552     inline _ValueType* any_cast(any* __any) noexcept
 553     {
 554       if (__any)
 555         return static_cast<_ValueType*>(__any_caster<_ValueType>(__any));
 556       return nullptr;
 557     }
 558   // @}
 559
 560   template<typename _Tp>
 561     void
 562     any::_Manager_internal<_Tp>::
 563     _S_manage(_Op __which, const any* __any, _Arg* __arg)
 564     {
 565       // The contained object is in _M_storage._M_buffer
 566       auto __ptr = reinterpret_cast<const _Tp*>(&__any->_M_storage._M_buffer);
 567       switch (__which)
 568       {
 569       case _Op_access:
 570         __arg->_M_obj = const_cast<_Tp*>(__ptr);
 571         break;
 572       case _Op_get_type_info:
 573 #if __cpp_rtti
 574         __arg->_M_typeinfo = &typeid(_Tp);
 575 #endif
 576         break;
 577       case _Op_clone:
 578         ::new(&__arg->_M_any->_M_storage._M_buffer) _Tp(*__ptr);
 579         __arg->_M_any->_M_manager = __any->_M_manager;
 580         break;
 581       case _Op_destroy:
 582         __ptr->~_Tp();
 583         break;
 584       case _Op_xfer:
 585         ::new(&__arg->_M_any->_M_storage._M_buffer) _Tp
 586           (std::move(*const_cast<_Tp*>(__ptr)));
 587         __ptr->~_Tp();
 588         __arg->_M_any->_M_manager = __any->_M_manager;
 589         const_cast<any*>(__any)->_M_manager = nullptr;
 590         break;
 591       }
 592     }
 593
 594   template<typename _Tp>
 595     void
 596     any::_Manager_external<_Tp>::
 597     _S_manage(_Op __which, const any* __any, _Arg* __arg)
 598     {
 599       // The contained object is *_M_storage._M_ptr
 600       auto __ptr = static_cast<const _Tp*>(__any->_M_storage._M_ptr);
 601       switch (__which)
 602       {
 603       case _Op_access:
 604         __arg->_M_obj = const_cast<_Tp*>(__ptr);
 605         break;
 606       case _Op_get_type_info:
 607 #if __cpp_rtti
 608         __arg->_M_typeinfo = &typeid(_Tp);
 609 #endif
 610         break;
 611       case _Op_clone:
 612         __arg->_M_any->_M_storage._M_ptr = new _Tp(*__ptr);
 613         __arg->_M_any->_M_manager = __any->_M_manager;
 614         break;
 615       case _Op_destroy:
 616         delete __ptr;
 617         break;
 618       case _Op_xfer:
 619         __arg->_M_any->_M_storage._M_ptr = __any->_M_storage._M_ptr;
 620         __arg->_M_any->_M_manager = __any->_M_manager;
 621         const_cast<any*>(__any)->_M_manager = nullptr;
 622         break;
 623       }
 624     }
 625
 626   /// @}
 627
 628 _GLIBCXX_END_NAMESPACE_VERSION
 629 } // namespace std
 630
 631 #endif // C++14
 632
 633 #endif // _GLIBCXX_ANY