Provide a unpackTryTuple function in folly

Summary: This feature already exists in detail, move it to public instead.

Reviewed By: andriigrynenko

Differential Revision: D4013691

fbshipit-source-id: 1779cc53d114ddc97993b41e0ad63c104008f6b0

diff --git a/folly/Makefile.am b/folly/Makefile.am
index bc507a77e352ba32908985a690060d6b9928b8e5..b7860ee9a1c6880006b4801e2532c5844f5f851a 100644 (file)
--- a/folly/Makefile.am
+++ b/folly/Makefile.am
@@ -77,6 +77,7 @@ nobase_follyinclude_HEADERS = \
        detail/StaticSingletonManager.h \
        detail/Stats.h \
        detail/ThreadLocalDetail.h \
+  detail/TryDetail.h \
        detail/TurnSequencer.h \
        detail/UncaughtExceptionCounter.h \
        Demangle.h \

diff --git a/folly/Try-inl.h b/folly/Try-inl.h
index ba988e3dbc59a6b0615997fea025b3a99814974f..ed85e3dd1235de3a94fd904c38f730d27362e03a 100644 (file)
--- a/folly/Try-inl.h
+++ b/folly/Try-inl.h
@@ -16,6 +16,7 @@
 
 #pragma once
 
+#include <folly/detail/TryDetail.h>
 #include <stdexcept>
 
 namespace folly {
@@ -173,4 +174,10 @@ makeTryWith(F&& f) {
   }
 }
 
+template <typename... Ts>
+std::tuple<Ts...> unwrapTryTuple(std::tuple<folly::Try<Ts>...>&& ts) {
+  return detail::TryTuple<Ts...>::unwrap(
+      std::forward<std::tuple<folly::Try<Ts>...>>(ts));
+}
+
 } // folly

diff --git a/folly/Try.h b/folly/Try.h
index edfe6a7e3e450f5e386ed7a3effd88be073c3dd5..e6b6ebad3298450c5f4fa6f001fd751fd79c849b 100644 (file)
--- a/folly/Try.h
+++ b/folly/Try.h
@@ -418,6 +418,9 @@ typename std::enable_if<
   Try<void>>::type
 makeTryWith(F&& f);
 
+template <typename... Ts>
+std::tuple<Ts...> unwrapTryTuple(std::tuple<folly::Try<Ts>...>&& ts);
+
 } // folly
 
 #include <folly/Try-inl.h>

diff --git a/folly/detail/TryDetail.h b/folly/detail/TryDetail.h
new file mode 100644 (file)
index 0000000..0515763
--- /dev/null
+++ b/folly/detail/TryDetail.h
@@ -0,0 +1,46 @@
+/*
+ * Copyright 2016 Facebook, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+namespace folly {
+namespace detail {
+
+template <typename... Ts>
+struct TryTuple {
+  template <typename... Ts2>
+  static std::tuple<Ts...> unwrap(
+      std::tuple<folly::Try<Ts>...>&& o,
+      Ts2&&... ts2) {
+    static_assert(
+        sizeof...(ts2) < std::tuple_size<std::tuple<folly::Try<Ts>...>>::value,
+        "Non-templated unwrap should be used instead");
+
+    return unwrap(
+        std::move(o),
+        std::forward<Ts2>(ts2)...,
+        std::move(*std::get<sizeof...(ts2)>(o)));
+  }
+
+  static std::tuple<Ts...> unwrap(
+      std::tuple<folly::Try<Ts>...>&& /* o */,
+      Ts&&... ts) {
+    return std::tuple<Ts...>(std::forward<Ts>(ts)...);
+  }
+};
+
+} // namespace detail
+} // namespace folly

diff --git a/folly/futures/detail/Core.h b/folly/futures/detail/Core.h
index 66a6e74c503dcd59b8710899f89587c1093f889a..c4beaa4c43a7e5388101176b065c85161687af1a 100644 (file)
--- a/folly/futures/detail/Core.h
+++ b/folly/futures/detail/Core.h
@@ -468,32 +468,13 @@ struct CollectVariadicContext {
   }
   ~CollectVariadicContext() {
     if (!threw.exchange(true)) {
-      p.setValue(unwrap(std::move(results)));
+      p.setValue(unwrapTryTuple(std::move(results)));
     }
   }
   Promise<std::tuple<Ts...>> p;
   std::tuple<folly::Try<Ts>...> results;
   std::atomic<bool> threw {false};
   typedef Future<std::tuple<Ts...>> type;
-
- private:
-  template <typename... Ts2>
-  static std::tuple<Ts...> unwrap(std::tuple<folly::Try<Ts>...>&& o,
-                                  Ts2&&... ts2) {
-    static_assert(sizeof...(ts2) <
-                  std::tuple_size<std::tuple<folly::Try<Ts>...>>::value,
-                  "Non-templated unwrap should be used instead");
-    assert(std::get<sizeof...(ts2)>(o).hasValue());
-
-    return unwrap(std::move(o),
-                  std::forward<Ts2>(ts2)...,
-                  std::move(*std::get<sizeof...(ts2)>(o)));
-  }
-
-  static std::tuple<Ts...> unwrap(std::tuple<folly::Try<Ts>...>&& /* o */,
-                                  Ts&&... ts) {
-    return std::tuple<Ts...>(std::forward<Ts>(ts)...);
-  }
 };
 
 template <template <typename...> class T, typename... Ts>