libcxx/include/__exception/nested_exception.h

   1 //===----------------------------------------------------------------------===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8
   9 #ifndef _LIBCPP___EXCEPTION_NESTED_EXCEPTION_H
  10 #define _LIBCPP___EXCEPTION_NESTED_EXCEPTION_H
  11
  12 #include <__config>
  13 #include <__exception/exception_ptr.h>
  14 #include <__memory/addressof.h>
  15 #include <__type_traits/decay.h>
  16 #include <__type_traits/is_base_of.h>
  17 #include <__type_traits/is_class.h>
  18 #include <__type_traits/is_convertible.h>
  19 #include <__type_traits/is_copy_constructible.h>
  20 #include <__type_traits/is_final.h>
  21 #include <__type_traits/is_polymorphic.h>
  22 #include <__utility/forward.h>
  23 #include <cstddef>
  24
  25 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
  26 #  pragma GCC system_header
  27 #endif
  28
  29 namespace std { // purposefully not using versioning namespace
  30
  31 class _LIBCPP_EXPORTED_FROM_ABI nested_exception {
  32   exception_ptr __ptr_;
  33
  34 public:
  35   nested_exception() _NOEXCEPT;
  36   _LIBCPP_HIDE_FROM_ABI nested_exception(const nested_exception&) _NOEXCEPT            = default;
  37   _LIBCPP_HIDE_FROM_ABI nested_exception& operator=(const nested_exception&) _NOEXCEPT = default;
  38   virtual ~nested_exception() _NOEXCEPT;
  39
  40   // access functions
  41   _LIBCPP_NORETURN void rethrow_nested() const;
  42   _LIBCPP_HIDE_FROM_ABI exception_ptr nested_ptr() const _NOEXCEPT { return __ptr_; }
  43 };
  44
  45 template <class _Tp>
  46 struct __nested : public _Tp, public nested_exception {
  47   _LIBCPP_HIDE_FROM_ABI explicit __nested(const _Tp& __t) : _Tp(__t) {}
  48 };
  49
  50 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
  51 template <class _Tp, class _Up, bool>
  52 struct __throw_with_nested;
  53
  54 template <class _Tp, class _Up>
  55 struct __throw_with_nested<_Tp, _Up, true> {
  56   _LIBCPP_NORETURN static inline _LIBCPP_INLINE_VISIBILITY void __do_throw(_Tp&& __t) {
  57     throw __nested<_Up>(std::forward<_Tp>(__t));
  58   }
  59 };
  60
  61 template <class _Tp, class _Up>
  62 struct __throw_with_nested<_Tp, _Up, false> {
  63   _LIBCPP_NORETURN static inline _LIBCPP_INLINE_VISIBILITY void __do_throw(_Tp&& __t) { throw std::forward<_Tp>(__t); }
  64 };
  65 #endif
  66
  67 template <class _Tp>
  68 _LIBCPP_NORETURN _LIBCPP_HIDE_FROM_ABI void throw_with_nested(_Tp&& __t) {
  69 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
  70   using _Up = __decay_t<_Tp>;
  71   static_assert(is_copy_constructible<_Up>::value, "type thrown must be CopyConstructible");
  72   __throw_with_nested<_Tp,
  73                       _Up,
  74                       is_class<_Up>::value && !is_base_of<nested_exception, _Up>::value &&
  75                           !__libcpp_is_final<_Up>::value>::__do_throw(std::forward<_Tp>(__t));
  76 #else
  77   ((void)__t);
  78   // FIXME: Make this abort
  79 #endif
  80 }
  81
  82 template <class _From, class _To>
  83 struct __can_dynamic_cast
  84     : _BoolConstant< is_polymorphic<_From>::value &&
  85                      (!is_base_of<_To, _From>::value || is_convertible<const _From*, const _To*>::value)> {};
  86
  87 template <class _Ep>
  88 inline _LIBCPP_HIDE_FROM_ABI void
  89 rethrow_if_nested(const _Ep& __e, __enable_if_t< __can_dynamic_cast<_Ep, nested_exception>::value>* = 0) {
  90   const nested_exception* __nep = dynamic_cast<const nested_exception*>(std::addressof(__e));
  91   if (__nep)
  92     __nep->rethrow_nested();
  93 }
  94
  95 template <class _Ep>
  96 inline _LIBCPP_HIDE_FROM_ABI void
  97 rethrow_if_nested(const _Ep&, __enable_if_t<!__can_dynamic_cast<_Ep, nested_exception>::value>* = 0) {}
  98
  99 } // namespace std
 100
 101 #endif // _LIBCPP___EXCEPTION_NESTED_EXCEPTION_H