// Copyright 2017 The Abseil Authors.
//
// 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.
//
// absl/utility:utility is an extension of the <utility> header
//
// It provides stand-ins for C++14's std::integer_sequence and
// related utilities. They are intended to be exactly equivalent.
// - integer_sequence<T, Ints...> == std::integer_sequence<T, Ints...>
// - index_sequence<Ints...> == std::index_sequence<Ints...>
// - make_integer_sequence<T, N> == std::make_integer_sequence<T, N>
// - make_index_sequence<N> == std::make_index_sequence<N>
// - index_sequence_for<Ts...> == std::index_sequence_for<Ts...>
//
// It also provides the tag types in_place_t, in_place_type_t, and
// in_place_index_t, as well as the constant in_place, and constexpr std::move
// and std::forward impolementations in C++11.
//
// References:
// http://en.cppreference.com/w/cpp/utility/integer_sequence
// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3658.html
//
// Example:
// // Unpack a tuple for use as a function call's argument list.
//
// template <typename F, typename Tup, size_t... Is>
// auto Impl(F f, const Tup& tup, index_sequence<Is...>)
// -> decltype(f(std::get<Is>(tup) ...)) {
// return f(std::get<Is>(tup) ...);
// }
//
// template <typename Tup>
// using TupIdxSeq = make_index_sequence<std::tuple_size<Tup>::value>;
//
// template <typename F, typename Tup>
// auto ApplyFromTuple(F f, const Tup& tup)
// -> decltype(Impl(f, tup, TupIdxSeq<Tup>{})) {
// return Impl(f, tup, TupIdxSeq<Tup>{});
// }
#ifndef ABSL_UTILITY_UTILITY_H_
#define ABSL_UTILITY_UTILITY_H_
#include <cstddef>
#include <cstdlib>
#include <utility>
#include "absl/base/config.h"
#include "absl/meta/type_traits.h"
namespace absl {
// Equivalent to std::integer_sequence.
//
// Function templates can deduce compile-time integer sequences by accepting
// an argument of integer_sequence<T, Ints...>. This is a common need when
// working with C++11 variadic templates.
//
// T - the integer type of the sequence elements
// ...Ints - a parameter pack of T values representing the sequence
template <typename T, T... Ints>
struct integer_sequence {
using value_type = T;
static constexpr size_t size() noexcept { return sizeof...(Ints); }
};
// Equivalent to std::index_sequence.
//
// Alias for an integer_sequence of size_t.
template <size_t... Ints>
using index_sequence = integer_sequence<size_t, Ints...>;
namespace utility_internal {
template <typename Seq, size_t SeqSize, size_t Rem>
struct Extend;
// Note that SeqSize == sizeof...(Ints). It's passed explicitly for efficiency.
template <typename T, T... Ints, size_t SeqSize>
struct Extend<integer_sequence<T, Ints...>, SeqSize, 0> {
using type = integer_sequence<T, Ints..., (Ints + SeqSize)...>;
};
template <typename T, T... Ints, size_t SeqSize>
struct Extend<integer_sequence<T, Ints...>, SeqSize, 1> {
using type = integer_sequence<T, Ints..., (Ints + SeqSize)..., 2 * SeqSize>;
};
// Recursion helper for 'make_integer_sequence<T, N>'.
// 'Gen<T, N>::type' is an alias for 'integer_sequence<T, 0, 1, ... N-1>'.
template <typename T, size_t N>
struct Gen {
using type =
typename Extend<typename Gen<T, N / 2>::type, N / 2, N % 2>::type;
};
template <typename T>
struct Gen<T, 0> {
using type = integer_sequence<T>;
};
} // namespace utility_internal
// Compile-time sequences of integers
// Equivalent to std::make_integer_sequence.
//
// make_integer_sequence<int, N> is integer_sequence<int, 0, 1, ..., N-1>;
template <typename T, T N>
using make_integer_sequence = typename utility_internal::Gen<T, N>::type;
// Equivalent to std::make_index_sequence.
//
// make_index_sequence<N> is index_sequence<0, 1, ..., N-1>;
template <size_t N>
using make_index_sequence = make_integer_sequence<size_t, N>;
// Equivalent to std::index_sequence_for.
//
// Convert a typename pack into an index sequence of the same length.
template <typename... Ts>
using index_sequence_for = make_index_sequence<sizeof...(Ts)>;
// Tag types
#ifdef ABSL_HAVE_STD_OPTIONAL
using std::in_place_t;
using std::in_place;
#else // ABSL_HAVE_STD_OPTIONAL
// Tag type used in order to specify in-place construction, such as with
// absl::optional.
struct in_place_t {};
extern const in_place_t in_place;
#endif // ABSL_HAVE_STD_OPTIONAL
#ifdef ABSL_HAVE_STD_ANY
using std::in_place_type_t;
#else
// Tag types used for in-place construction when the type to construct needs to
// be specified, such as with absl::variant and absl::any.
template <typename T>
struct in_place_type_t {};
#endif // ABSL_HAVE_STD_ANY
template <size_t I>
struct in_place_index_t {};
// Constexpr move and forward
template <typename T>
constexpr absl::remove_reference_t<T>&& move(T&& t) noexcept {
return static_cast<absl::remove_reference_t<T>&&>(t);
}
template <typename T>
constexpr T&& forward(
absl::remove_reference_t<T>& t) noexcept { // NOLINT(runtime/references)
return static_cast<T&&>(t);
}
} // namespace absl
#endif // ABSL_UTILITY_UTILITY_H_
