1 | // Nested Exception support header (nested_exception class) for -*- C++ -*- |
2 | |
3 | // Copyright (C) 2009-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 bits/nested_exception.h |
26 | * This is an internal header file, included by other library headers. |
27 | * Do not attempt to use it directly. @headername{exception} |
28 | */ |
29 | |
30 | #ifndef _GLIBCXX_NESTED_EXCEPTION_H |
31 | #define _GLIBCXX_NESTED_EXCEPTION_H 1 |
32 | |
33 | #pragma GCC visibility push(default) |
34 | |
35 | #if __cplusplus < 201103L |
36 | # include <bits/c++0x_warning.h> |
37 | #else |
38 | |
39 | #include <bits/c++config.h> |
40 | #include <bits/move.h> |
41 | |
42 | extern "C++" { |
43 | |
44 | namespace std |
45 | { |
46 | /** |
47 | * @addtogroup exceptions |
48 | * @{ |
49 | */ |
50 | |
51 | /// Exception class with exception_ptr data member. |
52 | class nested_exception |
53 | { |
54 | exception_ptr _M_ptr; |
55 | |
56 | public: |
57 | nested_exception() noexcept : _M_ptr(current_exception()) { } |
58 | |
59 | nested_exception(const nested_exception&) noexcept = default; |
60 | |
61 | nested_exception& operator=(const nested_exception&) noexcept = default; |
62 | |
63 | virtual ~nested_exception() noexcept; |
64 | |
65 | [[noreturn]] |
66 | void |
67 | rethrow_nested() const |
68 | { |
69 | if (_M_ptr) |
70 | rethrow_exception(_M_ptr); |
71 | std::terminate(); |
72 | } |
73 | |
74 | exception_ptr |
75 | nested_ptr() const noexcept |
76 | { return _M_ptr; } |
77 | }; |
78 | |
79 | template<typename _Except> |
80 | struct _Nested_exception : public _Except, public nested_exception |
81 | { |
82 | explicit _Nested_exception(const _Except& __ex) |
83 | : _Except(__ex) |
84 | { } |
85 | |
86 | explicit _Nested_exception(_Except&& __ex) |
87 | : _Except(static_cast<_Except&&>(__ex)) |
88 | { } |
89 | }; |
90 | |
91 | // [except.nested]/8 |
92 | // Throw an exception of unspecified type that is publicly derived from |
93 | // both remove_reference_t<_Tp> and nested_exception. |
94 | template<typename _Tp> |
95 | inline void |
96 | __throw_with_nested_impl(_Tp&& __t, true_type) |
97 | { |
98 | using _Up = typename remove_reference<_Tp>::type; |
99 | throw _Nested_exception<_Up>{std::forward<_Tp>(__t)}; |
100 | } |
101 | |
102 | template<typename _Tp> |
103 | inline void |
104 | __throw_with_nested_impl(_Tp&& __t, false_type) |
105 | { throw std::forward<_Tp>(__t); } |
106 | |
107 | /// If @p __t is derived from nested_exception, throws @p __t. |
108 | /// Else, throws an implementation-defined object derived from both. |
109 | template<typename _Tp> |
110 | [[noreturn]] |
111 | inline void |
112 | throw_with_nested(_Tp&& __t) |
113 | { |
114 | using _Up = typename decay<_Tp>::type; |
115 | using _CopyConstructible |
116 | = __and_<is_copy_constructible<_Up>, is_move_constructible<_Up>>; |
117 | static_assert(_CopyConstructible::value, |
118 | "throw_with_nested argument must be CopyConstructible" ); |
119 | using __nest = __and_<is_class<_Up>, __bool_constant<!__is_final(_Up)>, |
120 | __not_<is_base_of<nested_exception, _Up>>>; |
121 | std::__throw_with_nested_impl(std::forward<_Tp>(__t), __nest{}); |
122 | } |
123 | |
124 | // Determine if dynamic_cast<const nested_exception&> would be well-formed. |
125 | template<typename _Tp> |
126 | using __rethrow_if_nested_cond = typename enable_if< |
127 | __and_<is_polymorphic<_Tp>, |
128 | __or_<__not_<is_base_of<nested_exception, _Tp>>, |
129 | is_convertible<_Tp*, nested_exception*>>>::value |
130 | >::type; |
131 | |
132 | // Attempt dynamic_cast to nested_exception and call rethrow_nested(). |
133 | template<typename _Ex> |
134 | inline __rethrow_if_nested_cond<_Ex> |
135 | __rethrow_if_nested_impl(const _Ex* __ptr) |
136 | { |
137 | if (auto __ne_ptr = dynamic_cast<const nested_exception*>(__ptr)) |
138 | __ne_ptr->rethrow_nested(); |
139 | } |
140 | |
141 | // Otherwise, no effects. |
142 | inline void |
143 | __rethrow_if_nested_impl(const void*) |
144 | { } |
145 | |
146 | /// If @p __ex is derived from nested_exception, @p __ex.rethrow_nested(). |
147 | template<typename _Ex> |
148 | inline void |
149 | rethrow_if_nested(const _Ex& __ex) |
150 | { std::__rethrow_if_nested_impl(std::__addressof(__ex)); } |
151 | |
152 | // @} group exceptions |
153 | } // namespace std |
154 | |
155 | } // extern "C++" |
156 | |
157 | #endif // C++11 |
158 | |
159 | #pragma GCC visibility pop |
160 | |
161 | #endif // _GLIBCXX_NESTED_EXCEPTION_H |
162 | |