// Copyright 2018 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 // // https://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. // // Helper class to perform the Empty Base Optimization. // Ts can contain classes and non-classes, empty or not. For the ones that // are empty classes, we perform the optimization. If all types in Ts are empty // classes, then CompressedTuple<Ts...> is itself an empty class. // // To access the members, use member get<N>() function. // // Eg: // absl::container_internal::CompressedTuple<int, T1, T2, T3> value(7, t1, t2, // t3); // assert(value.get<0>() == 7); // T1& t1 = value.get<1>(); // const T2& t2 = value.get<2>(); // ... // // https://en.cppreference.com/w/cpp/language/ebo #ifndef ABSL_CONTAINER_INTERNAL_COMPRESSED_TUPLE_H_ #define ABSL_CONTAINER_INTERNAL_COMPRESSED_TUPLE_H_ #include <initializer_list> #include <tuple> #include <type_traits> #include <utility> #include "absl/utility/utility.h" #if defined(_MSC_VER) && !defined(__NVCC__) // We need to mark these classes with this declspec to ensure that // CompressedTuple happens. #define ABSL_INTERNAL_COMPRESSED_TUPLE_DECLSPEC … #else #define ABSL_INTERNAL_COMPRESSED_TUPLE_DECLSPEC #endif namespace absl { ABSL_NAMESPACE_BEGIN namespace container_internal { template <typename... Ts> class CompressedTuple; namespace internal_compressed_tuple { template <typename D, size_t I> struct Elem; Elem<CompressedTuple<B...>, I>; ElemT; // We can't use EBCO on other CompressedTuples because that would mean that we // derive from multiple Storage<> instantiations with the same I parameter, // and potentially from multiple identical Storage<> instantiations. So anytime // we use type inheritance rather than encapsulation, we mark // CompressedTupleImpl, to make this easy to detect. struct uses_inheritance { … }; template <typename T> constexpr bool ShouldUseBase() { … } // The storage class provides two specializations: // - For empty classes, it stores T as a base class. // - For everything else, it stores T as a member. template <typename T, size_t I, bool UseBase = ShouldUseBase<T>()> struct Storage { … }; Storage<T, I, true>; template <typename D, typename I, bool ShouldAnyUseBase> struct ABSL_INTERNAL_COMPRESSED_TUPLE_DECLSPEC CompressedTupleImpl; CompressedTupleImpl<CompressedTuple<Ts...>, absl::index_sequence<I...>, ShouldAnyUseBase>; CompressedTupleImpl<CompressedTuple<Ts...>, absl::index_sequence<I...>, false>; std::false_type Or(std::initializer_list<std::false_type>); std::true_type Or(std::initializer_list<bool>); // MSVC requires this to be done separately rather than within the declaration // of CompressedTuple below. template <typename... Ts> constexpr bool ShouldAnyUseBase() { … } TupleElementMoveConstructible; template <bool SizeMatches, class T, class... Vs> struct TupleMoveConstructible : std::false_type { … }; TupleMoveConstructible<true, CompressedTuple<Ts...>, Vs...>; template <typename T> struct compressed_tuple_size; compressed_tuple_size<CompressedTuple<Es...>>; template <class T, class... Vs> struct TupleItemsMoveConstructible : std::integral_constant< bool, TupleMoveConstructible<compressed_tuple_size<T>::value == sizeof...(Vs), T, Vs...>::value> { … }; } // namespace internal_compressed_tuple // Helper class to perform the Empty Base Class Optimization. // Ts can contain classes and non-classes, empty or not. For the ones that // are empty classes, we perform the CompressedTuple. If all types in Ts are // empty classes, then CompressedTuple<Ts...> is itself an empty class. (This // does not apply when one or more of those empty classes is itself an empty // CompressedTuple.) // // To access the members, use member .get<N>() function. // // Eg: // absl::container_internal::CompressedTuple<int, T1, T2, T3> value(7, t1, t2, // t3); // assert(value.get<0>() == 7); // T1& t1 = value.get<1>(); // const T2& t2 = value.get<2>(); // ... // // https://en.cppreference.com/w/cpp/language/ebo template <typename... Ts> class ABSL_INTERNAL_COMPRESSED_TUPLE_DECLSPEC CompressedTuple : private internal_compressed_tuple::CompressedTupleImpl< CompressedTuple<Ts...>, absl::index_sequence_for<Ts...>, internal_compressed_tuple::ShouldAnyUseBase<Ts...>()> { … }; // Explicit specialization for a zero-element tuple // (needed to avoid ambiguous overloads for the default constructor). template <> class ABSL_INTERNAL_COMPRESSED_TUPLE_DECLSPEC CompressedTuple<> { … }; } // namespace container_internal ABSL_NAMESPACE_END } // namespace absl #undef ABSL_INTERNAL_COMPRESSED_TUPLE_DECLSPEC #endif // ABSL_CONTAINER_INTERNAL_COMPRESSED_TUPLE_H_