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