A smaller implementation of try_and_catch

Summary:
[Folly] A smaller implementation of `try_and_catch`.

No longer done as a derived class. This lets us make the protected members of `exception_wrapper` into private members.

Reviewed By: ericniebler

Differential Revision: D4366065

fbshipit-source-id: ae4763b55e431ac08260f74f6a23a257581247c9

diff --git a/folly/ExceptionWrapper.h b/folly/ExceptionWrapper.h
index 1086a8a0b813dec9e99d332bf4633b7ed635f3c9..c6003818769d00cf797a700dfe9e45614178170e 100644 (file)
--- a/folly/ExceptionWrapper.h
+++ b/folly/ExceptionWrapper.h
@@ -19,6 +19,7 @@
 #include <exception>
 #include <memory>
 #include <string>
 #include <exception>
 #include <memory>
 #include <string>

+#include <tuple>

 #include <type_traits>
 #include <utility>
 
 #include <type_traits>
 #include <utility>
 


@@ -105,7 +106,7 @@ namespace folly {
  *
  */
 class exception_wrapper {
  *
  */
 class exception_wrapper {

- protected:
+ private:

   template <typename Ex>
   struct optimize;
 
   template <typename Ex>
   struct optimize;
 


@@ -269,7 +270,7 @@ class exception_wrapper {
     return std::exception_ptr();
   }
 
     return std::exception_ptr();
   }
 

- protected:
+ private:

   template <typename Ex>
   struct optimize {
     static const bool value =
   template <typename Ex>
   struct optimize {
     static const bool value =


@@ -408,67 +409,43 @@ fbstring exceptionStr(const exception_wrapper& ew);
  * });
  */
 
  * });
  */
 

-namespace detail {
-
-template <typename... Exceptions>
-class try_and_catch;
-
-template <typename LastException, typename... Exceptions>
-class try_and_catch<LastException, Exceptions...> :
-    public try_and_catch<Exceptions...> {
- public:
-  template <typename F>
-  explicit try_and_catch(F&& fn) : Base() {
-    call_fn(fn);
-  }
+namespace try_and_catch_detail {

 
 

- protected:
-  typedef try_and_catch<Exceptions...> Base;
+template <bool V, typename T = void>
+using enable_if_t_ = typename std::enable_if<V, T>::type;

 
 

-  try_and_catch() : Base() {}
+template <typename... Args>
+using is_wrap_ctor = std::is_constructible<exception_wrapper, Args...>;

 
 

-  template <typename Ex>
-  typename std::enable_if<!exception_wrapper::optimize<Ex>::value>::type
-  assign_exception(Ex& e, std::exception_ptr eptr) {
-    exception_wrapper::assign_eptr(eptr, e);
-  }
-
-  template <typename Ex>
-  typename std::enable_if<exception_wrapper::optimize<Ex>::value>::type
-  assign_exception(Ex& e, std::exception_ptr /*eptr*/) {
-    exception_wrapper::assign_sptr(std::make_shared<Ex>(e));
-  }
+template <typename Ex>
+inline enable_if_t_<!is_wrap_ctor<Ex&>::value, exception_wrapper> make(Ex& ex) {
+  return exception_wrapper(std::current_exception(), ex);
+}

 
 

-  template <typename F>
-  void call_fn(F&& fn) {
-    try {
-      Base::call_fn(std::move(fn));
-    } catch (LastException& e) {
-      if (typeid(e) == typeid(LastException&)) {
-        assign_exception(e, std::current_exception());
-      } else {
-        exception_wrapper::assign_eptr(std::current_exception(), e);
-      }
-    }
-  }
-};
+template <typename Ex>
+inline enable_if_t_<is_wrap_ctor<Ex&>::value, exception_wrapper> make(Ex& ex) {
+  return typeid(Ex&) == typeid(ex)
+      ? exception_wrapper(ex)
+      : exception_wrapper(std::current_exception(), ex);
+}

 
 

-template<>
-class try_and_catch<> : public exception_wrapper {
- public:
-  try_and_catch() = default;
+template <typename F>
+inline exception_wrapper impl(F&& f) {
+  return (f(), exception_wrapper());
+}

 
 

- protected:
-  template <typename F>
-  void call_fn(F&& fn) {
-    fn();
+template <typename F, typename Ex, typename... Exs>
+inline exception_wrapper impl(F&& f) {
+  try {
+    return impl<F, Exs...>(std::forward<F>(f));
+  } catch (Ex& ex) {
+    return make(ex);

   }
   }

-};

 }
 }

+} // try_and_catch_detail

 
 template <typename... Exceptions, typename F>
 exception_wrapper try_and_catch(F&& fn) {
 
 template <typename... Exceptions, typename F>
 exception_wrapper try_and_catch(F&& fn) {

-  return detail::try_and_catch<Exceptions...>(std::forward<F>(fn));
-} // detail
-
+  return try_and_catch_detail::impl<F, Exceptions...>(std::forward<F>(fn));
+}

 } // folly
 } // folly