mirror of
https://github.com/greg7mdp/parallel-hashmap.git
synced 2026-08-29 16:40:39 +08:00
Replace custom CompressedTuple with std::tuple.
This commit is contained in:
greg7mdp
Vendored
-174
@@ -4127,180 +4127,6 @@ public:
|
||||
: internal_layout::LayoutType<sizeof...(Ts), Ts...>(sizes...) {}
|
||||
};
|
||||
|
||||
} // namespace priv
|
||||
} // namespace phmap
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// compressed_tuple.h
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
#ifdef _MSC_VER
|
||||
// We need to mark these classes with this declspec to ensure that
|
||||
// CompressedTuple happens.
|
||||
#define PHMAP_INTERNAL_COMPRESSED_TUPLE_DECLSPEC __declspec(empty_bases)
|
||||
#else // _MSC_VER
|
||||
#define PHMAP_INTERNAL_COMPRESSED_TUPLE_DECLSPEC
|
||||
#endif // _MSC_VER
|
||||
|
||||
namespace phmap {
|
||||
namespace priv {
|
||||
|
||||
template <typename... Ts>
|
||||
class CompressedTuple;
|
||||
|
||||
namespace internal_compressed_tuple {
|
||||
|
||||
template <typename D, size_t I>
|
||||
struct Elem;
|
||||
template <typename... B, size_t I>
|
||||
struct Elem<CompressedTuple<B...>, I>
|
||||
: std::tuple_element<I, std::tuple<B...>> {};
|
||||
template <typename D, size_t I>
|
||||
using ElemT = typename Elem<D, I>::type;
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Use the __is_final intrinsic if available. Where it's not available, classes
|
||||
// declared with the 'final' specifier cannot be used as CompressedTuple
|
||||
// elements.
|
||||
// TODO(sbenza): Replace this with std::is_final in C++14.
|
||||
// ---------------------------------------------------------------------------
|
||||
template <typename T>
|
||||
constexpr bool IsFinal() {
|
||||
#if defined(__clang__) || defined(__GNUC__)
|
||||
return __is_final(T);
|
||||
#else
|
||||
return false;
|
||||
#endif
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
constexpr bool ShouldUseBase() {
|
||||
#ifdef __INTEL_COMPILER
|
||||
// avoid crash in Intel compiler
|
||||
// assertion failed at: "shared/cfe/edgcpfe/lower_init.c", line 7013
|
||||
return false;
|
||||
#else
|
||||
return std::is_class<T>::value && std::is_empty<T>::value && !IsFinal<T>();
|
||||
#endif
|
||||
}
|
||||
|
||||
// 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 D, size_t I, bool = ShouldUseBase<ElemT<D, I>>()>
|
||||
struct Storage
|
||||
{
|
||||
using T = ElemT<D, I>;
|
||||
T value;
|
||||
constexpr Storage() = default;
|
||||
explicit constexpr Storage(T&& v) : value(phmap::forward<T>(v)) {}
|
||||
constexpr const T& get() const& { return value; }
|
||||
T& get() & { return value; }
|
||||
constexpr const T&& get() const&& { return phmap::move(*this).value; }
|
||||
T&& get() && { return std::move(*this).value; }
|
||||
};
|
||||
|
||||
template <typename D, size_t I>
|
||||
struct PHMAP_INTERNAL_COMPRESSED_TUPLE_DECLSPEC Storage<D, I, true>
|
||||
: ElemT<D, I>
|
||||
{
|
||||
using T = internal_compressed_tuple::ElemT<D, I>;
|
||||
constexpr Storage() = default;
|
||||
explicit constexpr Storage(T&& v) : T(phmap::forward<T>(v)) {}
|
||||
constexpr const T& get() const& { return *this; }
|
||||
T& get() & { return *this; }
|
||||
constexpr const T&& get() const&& { return phmap::move(*this); }
|
||||
T&& get() && { return std::move(*this); }
|
||||
};
|
||||
|
||||
template <typename D, typename I>
|
||||
struct PHMAP_INTERNAL_COMPRESSED_TUPLE_DECLSPEC CompressedTupleImpl;
|
||||
|
||||
template <typename... Ts, size_t... I>
|
||||
struct PHMAP_INTERNAL_COMPRESSED_TUPLE_DECLSPEC
|
||||
CompressedTupleImpl<CompressedTuple<Ts...>, phmap::index_sequence<I...>>
|
||||
// We use the dummy identity function through std::integral_constant to
|
||||
// convince MSVC of accepting and expanding I in that context. Without it
|
||||
// you would get:
|
||||
// error C3548: 'I': parameter pack cannot be used in this context
|
||||
: Storage<CompressedTuple<Ts...>,
|
||||
std::integral_constant<size_t, I>::value>...
|
||||
{
|
||||
constexpr CompressedTupleImpl() = default;
|
||||
explicit constexpr CompressedTupleImpl(Ts&&... args)
|
||||
: Storage<CompressedTuple<Ts...>, I>(phmap::forward<Ts>(args))... {}
|
||||
};
|
||||
|
||||
} // 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.
|
||||
//
|
||||
// To access the members, use member .get<N>() function.
|
||||
//
|
||||
// Eg:
|
||||
// phmap::priv::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 PHMAP_INTERNAL_COMPRESSED_TUPLE_DECLSPEC CompressedTuple
|
||||
: private internal_compressed_tuple::CompressedTupleImpl<
|
||||
CompressedTuple<Ts...>, phmap::index_sequence_for<Ts...>>
|
||||
{
|
||||
private:
|
||||
template <int I>
|
||||
using ElemT = internal_compressed_tuple::ElemT<CompressedTuple, I>;
|
||||
|
||||
public:
|
||||
constexpr CompressedTuple() = default;
|
||||
explicit constexpr CompressedTuple(Ts... base)
|
||||
: CompressedTuple::CompressedTupleImpl(phmap::forward<Ts>(base)...) {}
|
||||
|
||||
template <int I>
|
||||
ElemT<I>& get() & {
|
||||
return internal_compressed_tuple::Storage<CompressedTuple, I>::get();
|
||||
}
|
||||
|
||||
template <int I>
|
||||
constexpr const ElemT<I>& get() const& {
|
||||
return internal_compressed_tuple::Storage<CompressedTuple, I>::get();
|
||||
}
|
||||
|
||||
template <int I>
|
||||
ElemT<I>&& get() && {
|
||||
return std::move(*this)
|
||||
.internal_compressed_tuple::template Storage<CompressedTuple, I>::get();
|
||||
}
|
||||
|
||||
template <int I>
|
||||
constexpr const ElemT<I>&& get() const&& {
|
||||
return phmap::move(*this)
|
||||
.internal_compressed_tuple::template Storage<CompressedTuple, I>::get();
|
||||
}
|
||||
};
|
||||
|
||||
// Explicit specialization for a zero-element tuple
|
||||
// (needed to avoid ambiguous overloads for the default constructor).
|
||||
// ---------------------------------------------------------------------------
|
||||
template <>
|
||||
class PHMAP_INTERNAL_COMPRESSED_TUPLE_DECLSPEC CompressedTuple<> {};
|
||||
|
||||
} // namespace priv
|
||||
} // namespace phmap
|
||||
|
||||
|
||||
namespace phmap {
|
||||
namespace priv {
|
||||
|
||||
#ifdef _MSC_VER
|
||||
#pragma warning(push)
|
||||
|
||||
Reference in New Issue
Block a user