libstdc++-v3/include/experimental/any

   1 // <experimental/any> -*- C++ -*-
   2
   3 // Copyright (C) 2014-2015 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 experimental/any
  26  *  This is a TS C++ Library header.
  27  */
  28
  29 #ifndef _GLIBCXX_EXPERIMENTAL_ANY
  30 #define _GLIBCXX_EXPERIMENTAL_ANY 1
  31
  32 #pragma GCC system_header
  33
  34 #if __cplusplus <= 201103L
  35 # include <bits/c++14_warning.h>
  36 #else
  37
  38 #include <typeinfo>
  39 #include <new>
  40 #include <utility>
  41 #include <type_traits>
  42
  43 namespace std _GLIBCXX_VISIBILITY(default)
  44 {
  45 namespace experimental
  46 {
  47 inline namespace fundamentals_v1
  48 {
  49 _GLIBCXX_BEGIN_NAMESPACE_VERSION
  50
  51   /**
  52    * @defgroup any Type-safe container of any type
  53    * @ingroup experimental
  54    *
  55    * A type-safe container for single values of value types, as
  56    * described in n3804 "Any Library Proposal (Revision 3)".
  57    *
  58    * @{
  59    */
  60
  61 #define __cpp_lib_experimental_any 201411
  62
  63   /**
  64    *  @brief Exception class thrown by a failed @c any_cast
  65    *  @ingroup exceptions
  66    */
  67   class bad_any_cast : public bad_cast
  68   {
  69   public:
  70     virtual const char* what() const noexcept { return "bad any_cast"; }
  71   };
  72
  73   [[gnu::noreturn]] inline void __throw_bad_any_cast()
  74   {
  75 #if __cpp_exceptions
  76     throw bad_any_cast{};
  77 #else
  78     __builtin_abort();
  79 #endif
  80   }
  81
  82   /**
  83    *  @brief A type-safe container of any type.
  84    *
  85    *  An @c any object's state is either empty or it stores a contained object
  86    *  of CopyConstructible type.
  87    */
  88   class any
  89   {
  90     // Holds either pointer to a heap object or the contained object itself.
  91     union _Storage
  92     {
  93       // This constructor intentionally doesn't initialize anything.
  94       _Storage() = default;
  95
  96       // Prevent trivial copies of this type, buffer might hold a non-POD.
  97       _Storage(const _Storage&) = delete;
  98       _Storage& operator=(const _Storage&) = delete;
  99
 100       void* _M_ptr;
 101       aligned_storage<sizeof(_M_ptr), alignof(void*)>::type _M_buffer;
 102     };
 103
 104     template<typename _Tp, typename _Safe = is_nothrow_move_constructible<_Tp>,
 105              bool _Fits = (sizeof(_Tp) <= sizeof(_Storage))
 106                           && (alignof(_Tp) <= alignof(_Storage))>
 107       using _Internal = std::integral_constant<bool, _Safe::value && _Fits>;
 108
 109     template<typename _Tp>
 110       struct _Manager_internal; // uses small-object optimization
 111
 112     template<typename _Tp>
 113       struct _Manager_external; // creates contained object on the heap
 114
 115     template<typename _Tp>
 116       using _Manager = conditional_t<_Internal<_Tp>::value,
 117                                      _Manager_internal<_Tp>,
 118                                      _Manager_external<_Tp>>;
 119
 120     template<typename _Tp, typename _Decayed = decay_t<_Tp>>
 121       using _Decay = enable_if_t<!is_same<_Decayed, any>::value, _Decayed>;
 122
 123   public:
 124     // construct/destruct
 125
 126     /// Default constructor, creates an empty object.
 127     any() noexcept : _M_manager(nullptr) { }
 128
 129     /// Copy constructor, copies the state of @p __other
 130     any(const any& __other)
 131     {
 132       if (__other.empty())
 133         _M_manager = nullptr;
 134       else
 135         {
 136           _Arg __arg;
 137           __arg._M_any = this;
 138           __other._M_manager(_Op_clone, &__other, &__arg);
 139         }
 140     }
 141
 142     /**
 143      * @brief Move constructor, transfer the state from @p __other
 144      *
 145      * @post @c __other.empty() (this postcondition is a GNU extension)
 146      */
 147     any(any&& __other) noexcept
 148     {
 149       if (__other.empty())
 150         _M_manager = nullptr;
 151       else
 152         {
 153           _Arg __arg;
 154           __arg._M_any = this;
 155           __other._M_manager(_Op_xfer, &__other, &__arg);
 156         }
 157     }
 158
 159     /// Construct with a copy of @p __value as the contained object.
 160     template <typename _ValueType, typename _Tp = _Decay<_ValueType>,
 161               typename _Mgr = _Manager<_Tp>>
 162       any(_ValueType&& __value)
 163       : _M_manager(&_Mgr::_S_manage)
 164       {
 165         _Mgr::_S_create(_M_storage, std::forward<_ValueType>(__value));
 166         static_assert(is_copy_constructible<_Tp>::value,
 167                       "The contained object must be CopyConstructible");
 168       }
 169
 170     /// Destructor, calls @c clear()
 171     ~any() { clear(); }
 172
 173     // assignments
 174
 175     /// Copy the state of another object.
 176     any& operator=(const any& __rhs)
 177     {
 178       if (__rhs.empty())
 179         clear();
 180       else if (this != &__rhs)
 181         {
 182           if (!empty())
 183             _M_manager(_Op_destroy, this, nullptr);
 184           _Arg __arg;
 185           __arg._M_any = this;
 186           __rhs._M_manager(_Op_clone, &__rhs, &__arg);
 187         }
 188       return *this;
 189     }
 190
 191     /**
 192      * @brief Move assignment operator
 193      *
 194      * @post @c __rhs.empty() (not guaranteed for other implementations)
 195      */
 196     any& operator=(any&& __rhs) noexcept
 197     {
 198       if (__rhs.empty())
 199         clear();
 200       else if (this != &__rhs)
 201         {
 202           if (!empty())
 203             _M_manager(_Op_destroy, this, nullptr);
 204           _Arg __arg;
 205           __arg._M_any = this;
 206           __rhs._M_manager(_Op_xfer, &__rhs, &__arg);
 207         }
 208       return *this;
 209     }
 210
 211     /// Store a copy of @p __rhs as the contained object.
 212     template<typename _ValueType>
 213       enable_if_t<!is_same<any, decay_t<_ValueType>>::value, any&>
 214       operator=(_ValueType&& __rhs)
 215       {
 216         *this = any(std::forward<_ValueType>(__rhs));
 217         return *this;
 218       }
 219
 220     // modifiers
 221
 222     /// If not empty, destroy the contained object.
 223     void clear() noexcept
 224     {
 225       if (!empty())
 226       {
 227         _M_manager(_Op_destroy, this, nullptr);
 228         _M_manager = nullptr;
 229       }
 230     }
 231
 232     /// Exchange state with another object.
 233     void swap(any& __rhs) noexcept
 234     {
 235       if (empty() && __rhs.empty())
 236         return;
 237
 238       if (!empty() && !__rhs.empty())
 239         {
 240           if (this == &__rhs)
 241             return;
 242
 243           any __tmp;
 244           _Arg __arg;
 245           __arg._M_any = &__tmp;
 246           __rhs._M_manager(_Op_xfer, &__rhs, &__arg);
 247           __arg._M_any = &__rhs;
 248           _M_manager(_Op_xfer, this, &__arg);
 249           __arg._M_any = this;
 250           __tmp._M_manager(_Op_xfer, &__tmp, &__arg);
 251         }
 252       else
 253         {
 254           any* __empty = empty() ? this : &__rhs;
 255           any* __full = empty() ? &__rhs : this;
 256           _Arg __arg;
 257           __arg._M_any = __empty;
 258           __full->_M_manager(_Op_xfer, __full, &__arg);
 259         }
 260     }
 261
 262     // observers
 263
 264     /// Reports whether there is a contained object or not.
 265     bool empty() const noexcept { return _M_manager == nullptr; }
 266
 267 #if __cpp_rtti
 268     /// The @c typeid of the contained object, or @c typeid(void) if empty.
 269     const type_info& type() const noexcept
 270     {
 271       if (empty())
 272         return typeid(void);
 273       _Arg __arg;
 274       _M_manager(_Op_get_type_info, this, &__arg);
 275       return *__arg._M_typeinfo;
 276     }
 277 #endif
 278
 279     template<typename _Tp>
 280       static constexpr bool __is_valid_cast()
 281       { return __or_<is_reference<_Tp>, is_copy_constructible<_Tp>>::value; }
 282
 283   private:
 284     enum _Op {
 285         _Op_access, _Op_get_type_info, _Op_clone, _Op_destroy, _Op_xfer
 286     };
 287
 288     union _Arg
 289     {
 290         void* _M_obj;
 291         const std::type_info* _M_typeinfo;
 292         any* _M_any;
 293     };
 294
 295     void (*_M_manager)(_Op, const any*, _Arg*);
 296     _Storage _M_storage;
 297
 298     template<typename _Tp>
 299       friend void* __any_caster(const any* __any)
 300       {
 301         if (__any->_M_manager != &_Manager<decay_t<_Tp>>::_S_manage)
 302           return nullptr;
 303         _Arg __arg;
 304         __any->_M_manager(_Op_access, __any, &__arg);
 305         return __arg._M_obj;
 306       }
 307
 308     // Manage in-place contained object.
 309     template<typename _Tp>
 310       struct _Manager_internal
 311       {
 312         static void
 313         _S_manage(_Op __which, const any* __anyp, _Arg* __arg);
 314
 315         template<typename _Up>
 316           static void
 317           _S_create(_Storage& __storage, _Up&& __value)
 318           {
 319             void* __addr = &__storage._M_buffer;
 320             ::new (__addr) _Tp(std::forward<_Up>(__value));
 321           }
 322       };
 323
 324     // Manage external contained object.
 325     template<typename _Tp>
 326       struct _Manager_external
 327       {
 328         static void
 329         _S_manage(_Op __which, const any* __anyp, _Arg* __arg);
 330
 331         template<typename _Up>
 332           static void
 333           _S_create(_Storage& __storage, _Up&& __value)
 334           {
 335             __storage._M_ptr = new _Tp(std::forward<_Up>(__value));
 336           }
 337       };
 338   };
 339
 340   /// Exchange the states of two @c any objects.
 341   inline void swap(any& __x, any& __y) noexcept { __x.swap(__y); }
 342
 343   /**
 344    * @brief Access the contained object.
 345    *
 346    * @tparam  _ValueType  A const-reference or CopyConstructible type.
 347    * @param   __any       The object to access.
 348    * @return  The contained object.
 349    * @throw   bad_any_cast If <code>
 350    *          __any.type() != typeid(remove_reference_t<_ValueType>)
 351    *          </code>
 352    */
 353   template<typename _ValueType>
 354     inline _ValueType any_cast(const any& __any)
 355     {
 356       static_assert(any::__is_valid_cast<_ValueType>(),
 357           "Template argument must be a reference or CopyConstructible type");
 358       auto __p = any_cast<add_const_t<remove_reference_t<_ValueType>>>(&__any);
 359       if (__p)
 360         return *__p;
 361       __throw_bad_any_cast();
 362     }
 363
 364   /**
 365    * @brief Access the contained object.
 366    *
 367    * @tparam  _ValueType  A reference or CopyConstructible type.
 368    * @param   __any       The object to access.
 369    * @return  The contained object.
 370    * @throw   bad_any_cast If <code>
 371    *          __any.type() != typeid(remove_reference_t<_ValueType>)
 372    *          </code>
 373    *
 374    * @{
 375    */
 376   template<typename _ValueType>
 377     inline _ValueType any_cast(any& __any)
 378     {
 379       static_assert(any::__is_valid_cast<_ValueType>(),
 380           "Template argument must be a reference or CopyConstructible type");
 381       auto __p = any_cast<remove_reference_t<_ValueType>>(&__any);
 382       if (__p)
 383         return *__p;
 384       __throw_bad_any_cast();
 385     }
 386
 387   template<typename _ValueType>
 388     inline _ValueType any_cast(any&& __any)
 389     {
 390       static_assert(any::__is_valid_cast<_ValueType>(),
 391           "Template argument must be a reference or CopyConstructible type");
 392       auto __p = any_cast<remove_reference_t<_ValueType>>(&__any);
 393       if (__p)
 394         return *__p;
 395       __throw_bad_any_cast();
 396     }
 397   // @}
 398
 399   /**
 400    * @brief Access the contained object.
 401    *
 402    * @tparam  _ValueType  The type of the contained object.
 403    * @param   __any       A pointer to the object to access.
 404    * @return  The address of the contained object if <code>
 405    *          __any != nullptr && __any.type() == typeid(_ValueType)
 406    *          </code>, otherwise a null pointer.
 407    *
 408    * @{
 409    */
 410   template<typename _ValueType>
 411     inline const _ValueType* any_cast(const any* __any) noexcept
 412     {
 413       if (__any)
 414         return static_cast<_ValueType*>(__any_caster<_ValueType>(__any));
 415       return nullptr;
 416     }
 417
 418   template<typename _ValueType>
 419     inline _ValueType* any_cast(any* __any) noexcept
 420     {
 421       if (__any)
 422         return static_cast<_ValueType*>(__any_caster<_ValueType>(__any));
 423       return nullptr;
 424     }
 425   // @}
 426
 427   template<typename _Tp>
 428     void
 429     any::_Manager_internal<_Tp>::
 430     _S_manage(_Op __which, const any* __any, _Arg* __arg)
 431     {
 432       // The contained object is in _M_storage._M_buffer
 433       auto __ptr = reinterpret_cast<const _Tp*>(&__any->_M_storage._M_buffer);
 434       switch (__which)
 435       {
 436       case _Op_access:
 437         __arg->_M_obj = const_cast<_Tp*>(__ptr);
 438         break;
 439       case _Op_get_type_info:
 440 #if __cpp_rtti
 441         __arg->_M_typeinfo = &typeid(_Tp);
 442 #endif
 443         break;
 444       case _Op_clone:
 445         ::new(&__arg->_M_any->_M_storage._M_buffer) _Tp(*__ptr);
 446         __arg->_M_any->_M_manager = __any->_M_manager;
 447         break;
 448       case _Op_destroy:
 449         __ptr->~_Tp();
 450         break;
 451       case _Op_xfer:
 452         ::new(&__arg->_M_any->_M_storage._M_buffer) _Tp(*__ptr);
 453         __ptr->~_Tp();
 454         __arg->_M_any->_M_manager = __any->_M_manager;
 455         const_cast<any*>(__any)->_M_manager = nullptr;
 456         break;
 457       }
 458     }
 459
 460   template<typename _Tp>
 461     void
 462     any::_Manager_external<_Tp>::
 463     _S_manage(_Op __which, const any* __any, _Arg* __arg)
 464     {
 465       // The contained object is *_M_storage._M_ptr
 466       auto __ptr = static_cast<const _Tp*>(__any->_M_storage._M_ptr);
 467       switch (__which)
 468       {
 469       case _Op_access:
 470         __arg->_M_obj = const_cast<_Tp*>(__ptr);
 471         break;
 472       case _Op_get_type_info:
 473 #if __cpp_rtti
 474         __arg->_M_typeinfo = &typeid(_Tp);
 475 #endif
 476         break;
 477       case _Op_clone:
 478         __arg->_M_any->_M_storage._M_ptr = new _Tp(*__ptr);
 479         __arg->_M_any->_M_manager = __any->_M_manager;
 480         break;
 481       case _Op_destroy:
 482         delete __ptr;
 483         break;
 484       case _Op_xfer:
 485         __arg->_M_any->_M_storage._M_ptr = __any->_M_storage._M_ptr;
 486         __arg->_M_any->_M_manager = __any->_M_manager;
 487         const_cast<any*>(__any)->_M_manager = nullptr;
 488         break;
 489       }
 490     }
 491
 492   // @} group any
 493 _GLIBCXX_END_NAMESPACE_VERSION
 494 } // namespace fundamentals_v1
 495 } // namespace experimental
 496 } // namespace std
 497
 498 #endif // C++14
 499
 500 #endif // _GLIBCXX_EXPERIMENTAL_ANY