UsingUninitializedTry() : TryException("Using uninitialized try") {}
};
+namespace try_detail {
+[[noreturn]] void throwTryDoesNotContainException();
+[[noreturn]] void throwUsingUninitializedTry();
+} // namespace try_detail
+
/*
* Try<T> is a wrapper that contains either an instance of T, an exception, or
* nothing. Exceptions are stored as exception_wrappers so that the user can
*/
FOLLY_DEPRECATED("use Try(exception_wrapper)")
explicit Try(std::exception_ptr ep)
- : contains_(Contains::EXCEPTION) {
- try {
- std::rethrow_exception(ep);
- } catch (std::exception& e) {
- e_ = exception_wrapper(std::current_exception(), e);
- } catch (...) {
- e_ = exception_wrapper(std::current_exception());
- }
- }
+ : contains_(Contains::EXCEPTION),
+ e_(exception_wrapper::from_exception_ptr(ep)) {}
// Move constructor
Try(Try<T>&& t) noexcept;
*
* @returns mutable reference to the contained value
*/
- T& value()&;
+ T& value() &;
/*
* Get a rvalue reference to the contained value. If the Try contains an
* exception it will be rethrown.
*
* @returns rvalue reference to the contained value
*/
- T&& value()&&;
+ T&& value() &&;
/*
* Get a const reference to the contained value. If the Try contains an
* exception it will be rethrown.
*
* @returns const reference to the contained value
*/
- const T& value() const&;
+ const T& value() const &;
+ /*
+ * Get a const rvalue reference to the contained value. If the Try contains an
+ * exception it will be rethrown.
+ *
+ * @returns const rvalue reference to the contained value
+ */
+ const T&& value() const &&;
/*
* If the Try contains an exception, rethrow it. Otherwise do nothing.
*
* @returns const reference to the contained value
*/
- const T& operator*() const { return value(); }
+ const T& operator*() const & {
+ return value();
+ }
/*
* Dereference operator. If the Try contains an exception it will be rethrown.
*
* @returns mutable reference to the contained value
*/
- T& operator*() { return value(); }
+ T& operator*() & {
+ return value();
+ }
+ /*
+ * Mutable rvalue dereference operator. If the Try contains an exception it
+ * will be rethrown.
+ *
+ * @returns rvalue reference to the contained value
+ */
+ T&& operator*() && {
+ return std::move(value());
+ }
+ /*
+ * Const rvalue dereference operator. If the Try contains an exception it
+ * will be rethrown.
+ *
+ * @returns rvalue reference to the contained value
+ */
+ const T&& operator*() const && {
+ return std::move(value());
+ }
/*
* Const arrow operator. If the Try contains an exception it will be
return hasException() && e_.is_compatible_with<Ex>();
}
- exception_wrapper& exception() {
- if (UNLIKELY(!hasException())) {
- throw TryException("exception(): Try does not contain an exception");
+ exception_wrapper& exception() & {
+ if (!hasException()) {
+ try_detail::throwTryDoesNotContainException();
}
return e_;
}
- const exception_wrapper& exception() const {
- if (UNLIKELY(!hasException())) {
- throw TryException("exception(): Try does not contain an exception");
+ exception_wrapper&& exception() && {
+ if (!hasException()) {
+ try_detail::throwTryDoesNotContainException();
+ }
+ return std::move(e_);
+ }
+
+ const exception_wrapper& exception() const & {
+ if (!hasException()) {
+ try_detail::throwTryDoesNotContainException();
}
return e_;
}
+ const exception_wrapper&& exception() const && {
+ if (!hasException()) {
+ try_detail::throwTryDoesNotContainException();
+ }
+ return std::move(e_);
+ }
+
/*
* @returns a pointer to the `std::exception` held by `*this`, if one is held;
* otherwise, returns `nullptr`.
* @param ep The exception_pointer. Will be rethrown.
*/
FOLLY_DEPRECATED("use Try(exception_wrapper)")
- explicit Try(std::exception_ptr ep) : hasValue_(false) {
- try {
- std::rethrow_exception(ep);
- } catch (const std::exception& e) {
- e_ = exception_wrapper(std::current_exception(), e);
- } catch (...) {
- e_ = exception_wrapper(std::current_exception());
- }
- }
+ explicit Try(std::exception_ptr ep)
+ : hasValue_(false), e_(exception_wrapper::from_exception_ptr(ep)) {}
// Copy assigner
Try& operator=(const Try<void>& t) {
*
* @returns mutable reference to the exception contained by this Try
*/
- exception_wrapper& exception() {
- if (UNLIKELY(!hasException())) {
- throw TryException("exception(): Try does not contain an exception");
+ exception_wrapper& exception() & {
+ if (!hasException()) {
+ try_detail::throwTryDoesNotContainException();
}
return e_;
}
- const exception_wrapper& exception() const {
- if (UNLIKELY(!hasException())) {
- throw TryException("exception(): Try does not contain an exception");
+ exception_wrapper&& exception() && {
+ if (!hasException()) {
+ try_detail::throwTryDoesNotContainException();
+ }
+ return std::move(e_);
+ }
+
+ const exception_wrapper& exception() const & {
+ if (!hasException()) {
+ try_detail::throwTryDoesNotContainException();
}
return e_;
}
+ const exception_wrapper&& exception() const && {
+ if (!hasException()) {
+ try_detail::throwTryDoesNotContainException();
+ }
+ return std::move(e_);
+ }
+
/*
* @returns a pointer to the `std::exception` held by `*this`, if one is held;
* otherwise, returns `nullptr`.
exception_wrapper e_;
};
-/*
- * Extracts value from try and returns it. Throws if try contained an exception.
- *
- * @param t Try to extract value from
- *
- * @returns value contained in t
- */
-template <typename T>
-T moveFromTry(Try<T>& t);
-
-/*
- * Throws if try contained an exception.
- *
- * @param t Try to move from
- */
-void moveFromTry(Try<void>& t);
-
/*
* @param f a function to execute and capture the result of (value or exception)
*
Try<void>>::type
makeTryWith(F&& f);
-template <typename... Ts>
-std::tuple<Ts...> unwrapTryTuple(std::tuple<folly::Try<Ts>...>&& ts);
+/**
+ * Tuple<Try<Type>...> -> std::tuple<Type...>
+ *
+ * Unwraps a tuple-like type containing a sequence of Try<Type> instances to
+ * std::tuple<Type>
+ */
+template <typename Tuple>
+auto unwrapTryTuple(Tuple&&);
-} // folly
+} // namespace folly
#include <folly/Try-inl.h>