#pragma once
#include <functional>
+#include <tuple>
#include <utility>
namespace folly {
template <std::size_t... Is>
struct MakeIndexSequence<0, Is...> : IndexSequence<Is...> {};
-template <class Tuple>
-using MakeIndexSequenceFromTuple =
- MakeIndexSequence<std::tuple_size<typename std::decay<Tuple>::type>::value>;
+inline constexpr std::size_t sum() {
+ return 0;
+}
+template <typename... Args>
+inline constexpr std::size_t sum(std::size_t v1, Args... vs) {
+ return v1 + sum(vs...);
+}
+
+template <class... Tuple>
+using MakeIndexSequenceFromTuple = MakeIndexSequence<sum(
+ std::tuple_size<typename std::decay<Tuple>::type>::value...)>;
// This is to allow using this with pointers to member functions,
// where the first argument in the tuple will be the this pointer.
return std::forward<F>(f)(std::get<Indexes>(std::forward<Tuple>(t))...);
}
+template <class Tuple, std::size_t... Indexes>
+inline constexpr auto forwardTuple(Tuple&& t, IndexSequence<Indexes...>)
+ -> decltype(
+ std::forward_as_tuple(std::get<Indexes>(std::forward<Tuple>(t))...)) {
+ return std::forward_as_tuple(std::get<Indexes>(std::forward<Tuple>(t))...);
+}
+
} // namespace apply_tuple
} // namespace detail
//////////////////////////////////////////////////////////////////////
-template <class F, class Tuple>
-inline constexpr auto applyTuple(F&& f, Tuple&& t)
+/**
+ * Invoke a callable object with a set of arguments passed as a tuple, or a
+ * series of tuples
+ *
+ * Example: the following lines are equivalent
+ * func(1, 2, 3, "foo");
+ * applyTuple(func, std::make_tuple(1, 2, 3, "foo"));
+ * applyTuple(func, std::make_tuple(1, 2), std::make_tuple(3, "foo"));
+ */
+
+template <class F, class... Tuples>
+inline constexpr auto applyTuple(F&& f, Tuples&&... t)
-> decltype(detail::apply_tuple::call(
detail::apply_tuple::makeCallable(std::forward<F>(f)),
- std::forward<Tuple>(t),
- detail::apply_tuple::MakeIndexSequenceFromTuple<Tuple>{})) {
+ std::tuple_cat(detail::apply_tuple::forwardTuple(
+ std::forward<Tuples>(t),
+ detail::apply_tuple::MakeIndexSequenceFromTuple<Tuples>{})...),
+ detail::apply_tuple::MakeIndexSequenceFromTuple<Tuples...>{})) {
return detail::apply_tuple::call(
detail::apply_tuple::makeCallable(std::forward<F>(f)),
- std::forward<Tuple>(t),
- detail::apply_tuple::MakeIndexSequenceFromTuple<Tuple>{});
+ std::tuple_cat(detail::apply_tuple::forwardTuple(
+ std::forward<Tuples>(t),
+ detail::apply_tuple::MakeIndexSequenceFromTuple<Tuples>{})...),
+ detail::apply_tuple::MakeIndexSequenceFromTuple<Tuples...>{});
}
//////////////////////////////////////////////////////////////////////
EXPECT_EQ(folly::applyTuple(add, std::pair<int, int>{1200, 34}), 1234);
}
+
+TEST(ApplyTuple, MultipleTuples) {
+ auto add = [](int x, int y, int z) { return x * 100 + y * 10 + z; };
+
+ EXPECT_EQ(123, folly::applyTuple(add, std::make_tuple(1, 2, 3)));
+ EXPECT_EQ(
+ 123, folly::applyTuple(add, std::make_tuple(1, 2, 3), std::make_tuple()));
+ EXPECT_EQ(
+ 123, folly::applyTuple(add, std::make_tuple(1, 2), std::make_tuple(3)));
+ EXPECT_EQ(
+ 123, folly::applyTuple(add, std::make_tuple(1), std::make_tuple(2, 3)));
+ EXPECT_EQ(
+ 123, folly::applyTuple(add, std::make_tuple(), std::make_tuple(1, 2, 3)));
+
+ EXPECT_EQ(
+ 123,
+ folly::applyTuple(
+ add, std::make_tuple(1, 2, 3), std::make_tuple(), std::make_tuple()));
+ EXPECT_EQ(
+ 123,
+ folly::applyTuple(
+ add, std::make_tuple(1), std::make_tuple(2), std::make_tuple(3)));
+ EXPECT_EQ(
+ 123,
+ folly::applyTuple(
+ add, std::make_tuple(1), std::make_tuple(), std::make_tuple(2, 3)));
+}