//! // Thread2: Exceptions are ok!
//! void processResult() {
//! try {
-//! globalExceptionWrapper.throwException();
+//! globalExceptionWrapper.throw_exception();
//! } catch (const FacePlantException& e) {
//! LOG(ERROR) << "FACEPLANT!";
//! } catch (const FailWhaleException& e) {
};
template <class Fn>
- struct arg_type2_;
- template <class Fn, class = void>
struct arg_type_;
template <class Fn>
using arg_type = _t<arg_type_<Fn>>;
static std::type_info const* uninit_type_(exception_wrapper const*);
- static constexpr VTable const uninit_{
- &noop_<void, exception_wrapper const*, exception_wrapper*>,
- &noop_<void, exception_wrapper*, exception_wrapper*>,
- &noop_<void, exception_wrapper*>,
- &noop_<void, exception_wrapper const*>,
- &uninit_type_,
- &noop_<std::exception const*, exception_wrapper const*>,
- &noop_<exception_wrapper, exception_wrapper const*>};
+ static VTable const uninit_;
template <class Ex>
using IsStdException = std::is_base_of<std::exception, _t<std::decay<Ex>>>;
static std::type_info const* type_(exception_wrapper const* that);
static std::exception const* get_exception_(exception_wrapper const* that);
static exception_wrapper get_exception_ptr_(exception_wrapper const* that);
- static constexpr VTable const ops_{copy_,
- move_,
- delete_,
- throw_,
- type_,
- get_exception_,
- get_exception_ptr_};
+ static VTable const ops_;
};
template <class Ex>
static std::type_info const* type_(exception_wrapper const* that);
static std::exception const* get_exception_(exception_wrapper const* that);
static exception_wrapper get_exception_ptr_(exception_wrapper const* that);
- static constexpr VTable ops_{copy_,
- move_,
- delete_,
- throw_,
- type_,
- get_exception_,
- get_exception_ptr_};
+ static VTable const ops_;
};
union {
class Ex,
class Ex_ = _t<std::decay<Ex>>,
FOLLY_REQUIRES(
- Conjunction<IsStdException<Ex_>, IsRegularExceptionType<Ex_>>())>
+ Conjunction<IsStdException<Ex_>, IsRegularExceptionType<Ex_>>::value)>
/* implicit */ exception_wrapper(Ex&& ex);
//! \pre `typeid(ex) == typeid(typename decay<Ex>::type)`
template <
class Ex,
class Ex_ = _t<std::decay<Ex>>,
- FOLLY_REQUIRES(IsRegularExceptionType<Ex_>())>
+ FOLLY_REQUIRES(IsRegularExceptionType<Ex_>::value)>
exception_wrapper(in_place_t, Ex&& ex);
//! Swaps the value of `*this` with the value of `that`
//! \overload
std::exception const* get_exception() const noexcept;
+ //! \returns a pointer to the `Ex` held by `*this`, if it holds an object
+ //! whose type `From` permits `std::is_convertible<From*, Ex*>`;
+ //! otherwise, returns `nullptr`.
+ //! \note This function does not mutate the `exception_wrapper` object.
+ //! \note This function may cause an exception to be thrown and immediately
+ //! caught internally, affecting runtime performance.
+ template <typename Ex>
+ Ex* get_object() noexcept;
+ //! \overload
+ template <typename Ex>
+ Ex const* get_object() const noexcept;
+
//! \return A `std::exception_ptr` that references either the exception held
//! by `*this`, or a copy of same.
//! \note This function may need to throw an exception to complete the action.
//! \pre `bool(*this)`
//! Throws the wrapped expression.
- [[noreturn]] void throwException() const;
+ [[noreturn]] void throw_exception() const;
+
+ [[noreturn]] FOLLY_DEPRECATED(
+ "use throw_exception") void throwException() const {
+ throw_exception();
+ }
//! Call `fn` with the wrapped exception (if any), if `fn` can accept it.
//! \par Example
//! ew.handle(
//! [&](std::logic_error const& e) {
//! LOG(DFATAL) << "ruh roh";
- //! ew.throwException(); // rethrow the active exception without
+ //! ew.throw_exception(); // rethrow the active exception without
//! // slicing it. Will not be caught by other
//! // handlers in this call.
//! },
//!
//! \par Example Usage:
//! \code
-//! // This catches my runtime_error and if I call throwException() on ew, it
+//! // This catches my runtime_error and if I call throw_exception() on ew, it
//! // will throw a runtime_error
//! auto ew = folly::try_and_catch<std::exception, std::runtime_error>([=]() {
//! if (badThingHappens()) {
//! }
//! });
//!
-//! // This will catch the exception and if I call throwException() on ew, it
+//! // This will catch the exception and if I call throw_exception() on ew, it
//! // will throw a std::exception
//! auto ew = folly::try_and_catch<std::exception, std::runtime_error>([=]() {
//! if (badThingHappens()) {