Commit ec7690d7 authored by Orvid King's avatar Orvid King Committed by Facebook Github Bot

Always use folly::index_sequence

Summary:
Continuing from D7482813, ensure everywhere in folly is using the folly versions of integer and index sequences.
Also implement index_sequence_for and use it.

Reviewed By: aary

Differential Revision: D7490483

fbshipit-source-id: 082209dd6c6ca11f67b38dbe4529d46e9dce57ce
parent 92320e04
main v2022.02.14.00 v2022.02.07.00 v2022.01.31.00 v2022.01.24.00 v2022.01.17.00 v2022.01.10.00 v2022.01.03.00 v2021.12.27.00 v2021.12.20.00 v2021.12.13.00 v2021.12.06.00 v2021.11.29.00 v2021.11.15.00 v2021.11.08.00 v2021.11.01.00 v2021.10.25.00 v2021.10.18.00 v2021.10.11.00 v2021.10.04.00 v2021.09.27.00 v2021.09.20.00 v2021.09.13.00 v2021.09.06.00 v2021.08.30.00 v2021.08.23.00 v2021.08.02.00 v2021.07.22.00 v2021.07.20.01 v2021.07.20.00 v2021.06.28.00 v2021.06.14.00 v2021.06.07.00 v2021.05.31.00 v2021.05.24.00 v2021.05.17.00 v2021.05.10.00 v2021.05.03.00 v2021.04.26.00 v2021.04.19.00 v2021.04.12.00 v2021.04.05.00 v2021.03.29.00 v2021.03.22.00 v2021.03.15.00 v2021.03.08.00 v2021.03.01.00 v2021.02.22.00 v2021.02.15.00 v2021.02.08.00 v2021.02.01.00 v2021.01.25.00 v2021.01.18.01 v2021.01.18.00 v2021.01.11.00 v2021.01.04.00 v2020.12.28.00 v2020.12.21.00 v2020.12.14.00 v2020.12.07.00 v2020.11.30.00 v2020.11.23.00 v2020.11.16.00 v2020.11.09.00 v2020.11.02.00 v2020.10.26.00 v2020.10.19.00 v2020.10.12.00 v2020.10.05.00 v2020.09.28.00 v2020.09.21.00 v2020.09.14.00 v2020.09.07.00 v2020.08.31.00 v2020.08.24.00 v2020.08.17.00 v2020.08.10.00 v2020.08.03.00 v2020.07.27.00 v2020.07.20.00 v2020.07.13.00 v2020.07.06.00 v2020.06.29.00 v2020.06.15.00 v2020.06.08.00 v2020.06.01.00 v2020.05.25.00 v2020.05.18.00 v2020.05.11.00 v2020.05.04.00 v2020.04.27.00 v2020.04.20.00 v2020.04.13.00 v2020.04.06.00 v2020.03.30.00 v2020.03.23.00 v2020.03.16.00 v2020.03.09.00 v2020.03.02.00 v2020.02.24.00 v2020.02.17.00 v2020.02.10.00 v2020.02.03.00 v2020.01.27.00 v2020.01.20.00 v2020.01.13.00 v2020.01.06.00 v2019.12.30.00 v2019.12.23.00 v2019.12.16.00 v2019.12.09.00 v2019.12.06.00 v2019.12.02.00 v2019.11.11.00 v2019.11.04.00 v2019.10.28.00 v2019.10.21.00 v2019.10.14.00 v2019.10.07.00 v2019.09.30.00 v2019.09.23.00 v2019.09.16.00 v2019.09.09.00 v2019.09.02.00 v2019.08.26.00 v2019.08.19.00 v2019.08.12.00 v2019.08.05.00 v2019.07.29.00 v2019.07.22.00 v2019.06.17.00 v2019.06.10.00 v2019.06.03.00 v2019.05.27.00 v2019.05.20.00 v2019.05.13.00 v2019.05.06.00 v2019.04.29.00 v2019.04.22.00 v2019.04.15.00 v2019.04.08.00 v2019.04.01.00 v2019.03.25.00 v2019.03.18.00 v2019.03.04.00 v2019.02.25.00 v2019.02.18.00 v2019.02.11.00 v2019.02.04.00 v2019.01.28.00 v2019.01.21.00 v2019.01.14.00 v2019.01.07.00 v2018.12.31.00 v2018.12.24.00 v2018.12.17.00 v2018.12.10.00 v2018.12.03.00 v2018.11.26.00 v2018.11.19.00 v2018.11.12.00 v2018.11.05.00 v2018.10.29.00 v2018.10.22.00 v2018.10.15.00 v2018.10.08.00 v2018.10.01.00 v2018.09.24.00 v2018.09.17.00 v2018.09.10.01 v2018.09.10.00 v2018.09.03.01 v2018.09.03.00 v2018.08.27.00 v2018.08.20.00 v2018.08.13.00 v2018.08.09.00 v2018.08.06.00 v2018.07.30.00 v2018.07.23.00 v2018.07.16.00 v2018.07.09.00 v2018.07.02.00 v2018.06.25.00 v2018.06.18.00 v2018.06.11.00 v2018.06.04.00 v2018.05.28.00 v2018.05.21.00 v2018.05.14.00 v2018.05.07.00 v2018.04.30.00 v2018.04.23.00 v2018.04.16.00 v2018.04.09.00
No related merge requests found
......@@ -183,6 +183,8 @@ using make_integer_sequence = typename utility_detail::make_seq<
template <std::size_t Size>
using make_index_sequence = make_integer_sequence<std::size_t, Size>;
template <class... T>
using index_sequence_for = make_index_sequence<sizeof...(T)>;
/**
* Backports from C++17 of:
......
......@@ -24,6 +24,7 @@
#include <folly/Portability.h>
#include <folly/Traits.h>
#include <folly/Utility.h>
namespace folly {
......@@ -256,8 +257,7 @@ void for_each_range_impl(Sequence&& range, Func& func) {
template <typename Seq, typename F, typename = void>
struct ForEachTupleImpl {
template <typename Sequence, typename Func, std::size_t... Indices>
static void
impl(Sequence&& seq, Func& func, std::index_sequence<Indices...>) {
static void impl(Sequence&& seq, Func& func, index_sequence<Indices...>) {
// unroll the loop in an initializer list construction parameter expansion
// pack
static_cast<void>(std::initializer_list<int>{
......@@ -270,8 +270,7 @@ struct ForEachTupleImpl {
template <typename Seq, typename F>
struct ForEachTupleImpl<Seq, F, EnableIfBreaksTuple<Seq, F>> {
template <typename Sequence, typename Func, std::size_t... Indices>
static void
impl(Sequence&& seq, Func& func, std::index_sequence<Indices...>) {
static void impl(Sequence&& seq, Func& func, index_sequence<Indices...>) {
// unroll the loop in an initializer list construction parameter expansion
// pack
LoopControl break_or_not = LoopControl::CONTINUE;
......@@ -307,7 +306,7 @@ void for_each_tuple_impl(Sequence&& seq, Func& func) {
constexpr auto length =
std::tuple_size<typename std::decay<Sequence>::type>::value;
ForEachTupleImpl<Sequence, Func>::impl(
std::forward<Sequence>(seq), func, std::make_index_sequence<length>{});
std::forward<Sequence>(seq), func, make_index_sequence<length>{});
}
template <
typename Sequence,
......
......@@ -23,6 +23,7 @@
#include <type_traits>
#include <utility>
#include <folly/Utility.h>
#include <folly/lang/RValueReferenceWrapper.h>
namespace folly {
......@@ -251,16 +252,15 @@ class emplace_iterator_base<Derived, EmplaceImpl, false>
*/
template <typename... Args>
Derived& operator=(emplace_args<Args...>& args) {
return unpackAndEmplace(args, std::index_sequence_for<Args...>{});
return unpackAndEmplace(args, index_sequence_for<Args...>{});
}
template <typename... Args>
Derived& operator=(const emplace_args<Args...>& args) {
return unpackAndEmplace(args, std::index_sequence_for<Args...>{});
return unpackAndEmplace(args, index_sequence_for<Args...>{});
}
template <typename... Args>
Derived& operator=(emplace_args<Args...>&& args) {
return unpackAndEmplace(
std::move(args), std::index_sequence_for<Args...>{});
return unpackAndEmplace(std::move(args), index_sequence_for<Args...>{});
}
// No-ops.
......@@ -284,17 +284,17 @@ class emplace_iterator_base<Derived, EmplaceImpl, false>
protected:
template <typename Args, std::size_t... I>
Derived& unpackAndEmplace(Args& args, std::index_sequence<I...>) {
Derived& unpackAndEmplace(Args& args, index_sequence<I...>) {
this->emplace(get_emplace_arg<I>(args)...);
return static_cast<Derived&>(*this);
}
template <typename Args, std::size_t... I>
Derived& unpackAndEmplace(const Args& args, std::index_sequence<I...>) {
Derived& unpackAndEmplace(const Args& args, index_sequence<I...>) {
this->emplace(get_emplace_arg<I>(args)...);
return static_cast<Derived&>(*this);
}
template <typename Args, std::size_t... I>
Derived& unpackAndEmplace(Args&& args, std::index_sequence<I...>) {
Derived& unpackAndEmplace(Args&& args, index_sequence<I...>) {
this->emplace(get_emplace_arg<I>(std::move(args))...);
return static_cast<Derived&>(*this);
}
......@@ -323,16 +323,16 @@ class emplace_iterator_base<Derived, EmplaceImpl, true>
*/
template <typename... Args>
Derived& operator=(std::pair<Args...>& args) {
return this->unpackAndEmplace(args, std::index_sequence_for<Args...>{});
return this->unpackAndEmplace(args, index_sequence_for<Args...>{});
}
template <typename... Args>
Derived& operator=(const std::pair<Args...>& args) {
return this->unpackAndEmplace(args, std::index_sequence_for<Args...>{});
return this->unpackAndEmplace(args, index_sequence_for<Args...>{});
}
template <typename... Args>
Derived& operator=(std::pair<Args...>&& args) {
return this->unpackAndEmplace(
std::move(args), std::index_sequence_for<Args...>{});
std::move(args), index_sequence_for<Args...>{});
}
/**
......@@ -341,16 +341,16 @@ class emplace_iterator_base<Derived, EmplaceImpl, true>
*/
template <typename... Args>
Derived& operator=(std::tuple<Args...>& args) {
return this->unpackAndEmplace(args, std::index_sequence_for<Args...>{});
return this->unpackAndEmplace(args, index_sequence_for<Args...>{});
}
template <typename... Args>
Derived& operator=(const std::tuple<Args...>& args) {
return this->unpackAndEmplace(args, std::index_sequence_for<Args...>{});
return this->unpackAndEmplace(args, index_sequence_for<Args...>{});
}
template <typename... Args>
Derived& operator=(std::tuple<Args...>&& args) {
return this->unpackAndEmplace(
std::move(args), std::index_sequence_for<Args...>{});
std::move(args), index_sequence_for<Args...>{});
}
// We need all of these explicit defaults because the custom operator=
......
......@@ -20,6 +20,7 @@
#include <folly/Benchmark.h>
#include <folly/FBVector.h>
#include <folly/Utility.h>
#include <folly/dynamic.h>
#include <folly/init/Init.h>
#include <folly/json.h>
......@@ -99,7 +100,7 @@ BENCHMARK_RELATIVE(intAppend_format) {
BENCHMARK_DRAW_LINE();
template <size_t... Indexes>
int snprintf20Numbers(int i, std::index_sequence<Indexes...>) {
int snprintf20Numbers(int i, index_sequence<Indexes...>) {
static_assert(20 == sizeof...(Indexes), "Must have exactly 20 indexes");
return snprintf(
bigBuf.data(),
......@@ -114,13 +115,13 @@ int snprintf20Numbers(int i, std::index_sequence<Indexes...>) {
BENCHMARK(bigFormat_snprintf, iters) {
while (iters--) {
for (int i = -100; i < 100; i++) {
snprintf20Numbers(i, std::make_index_sequence<20>());
snprintf20Numbers(i, make_index_sequence<20>());
}
}
}
template <size_t... Indexes>
decltype(auto) format20Numbers(int i, std::index_sequence<Indexes...>) {
decltype(auto) format20Numbers(int i, index_sequence<Indexes...>) {
static_assert(20 == sizeof...(Indexes), "Must have exactly 20 indexes");
return format(
"{} {} {} {} {}"
......@@ -141,9 +142,8 @@ BENCHMARK_RELATIVE(bigFormat_format, iters) {
while (iters--) {
for (int i = -100; i < 100; i++) {
p = bigBuf.data();
suspender.dismissing([&] {
format20Numbers(i, std::make_index_sequence<20>())(writeToBuf);
});
suspender.dismissing(
[&] { format20Numbers(i, make_index_sequence<20>())(writeToBuf); });
}
}
}
......
Markdown is supported
0%
or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment