namespace std {
class nested_exception {
public:
nested_exception() noexcept;
nested_exception(const nested_exception&) noexcept = default;
nested_exception& operator=(const nested_exception&) noexcept = default;
virtual ~nested_exception() = default;
// access functions
[[noreturn]] void rethrow_nested() const;
exception_ptr nested_ptr() const noexcept;
};
[[noreturn]] template<class T> void throw_with_nested(T&& t);
template <class E> void rethrow_if_nested(const E& e);
}
The class nested_exception is designed for use as a mixin through multiple inheritance. It captures the currently handled exception and stores it for later use.
[ Note: nested_exception has a virtual destructor to make it a polymorphic class. Its presence can be tested for with dynamic_cast. — end note ]
Effects: The constructor calls current_exception() and stores the returned value.
[[noreturn]] void rethrow_nested() const;
Effects: If nested_ptr() returns a null pointer, the function calls std::terminate(). Otherwise, it throws the stored exception captured by *this.
exception_ptr nested_ptr() const noexcept;
Returns: The stored exception captured by this nested_exception object.
[[noreturn]] template <class T> void throw_with_nested(T&& t);
Let U be remove_reference<T>::type.
Requires: U shall be CopyConstructible.
Throws: if U is a non-union class type not derived from nested_exception, an exception of unspecified type that is publicly derived from both U and nested_exception and constructed from std::forward<T>(t), otherwise std::forward<T>(t).
template <class E> void rethrow_if_nested(const E& e);
Effects: If the dynamic type of e is publicly and unambiguously derived from nested_exception, calls dynamic_cast<const nested_exception&>(e).rethrow_nested().