29 #ifndef ABSL_CONTAINER_FLAT_HASH_SET_H_ 30 #define ABSL_CONTAINER_FLAT_HASH_SET_H_ 32 #include <type_traits> 43 namespace container_internal {
97 template <
class T,
class Hash = absl::container_
internal::hash_default_hash<T>,
98 class Eq = absl::container_
internal::hash_default_eq<T>,
99 class Allocator = std::allocator<T>>
102 absl::container_internal::FlatHashSetPolicy<T>, Hash, Eq, Allocator> {
176 using Base::capacity;
189 using Base::max_size;
303 using Base::emplace_hint;
372 using Base::contains;
386 using Base::equal_range;
398 using Base::bucket_count;
404 using Base::load_factor;
422 using Base::max_load_factor;
427 using Base::get_allocator;
433 using Base::hash_function;
441 namespace container_internal {
444 struct FlatHashSetPolicy {
450 template <
class Allocator,
class... Args>
453 std::forward<Args>(args)...);
456 template <
class Allocator>
461 template <
class Allocator>
470 template <
class F,
class... Args>
472 std::declval<F>(), std::declval<Args>()...))
473 apply(F&& f, Args&&... args) {
475 std::forward<F>(f), std::forward<Args>(args)...);
482 namespace container_algorithm_internal {
485 template <
class Key,
class Hash,
class KeyEqual,
class Allocator>
493 #endif // ABSL_CONTAINER_FLAT_HASH_SET_H_
hash_default_eq< T > key_eq
static size_t space_used(const T *)
raw_hash_set() noexcept(std::is_nothrow_default_constructible< hasher >::value &&std::is_nothrow_default_constructible< key_equal >::value &&std::is_nothrow_default_constructible< allocator_type >::value)
static void destroy(Allocator *alloc, slot_type *slot)
decltype(std::declval< F >()(std::declval< const Arg & >(), std::declval< Arg >())) DecomposeValue(F &&f, Arg &&arg)
static void destroy(Alloc &a, T *p)
typename flat_hash_set::raw_hash_set Base
static std::function< void(void *, Slot *)> destroy
static void construct(Allocator *alloc, slot_type *slot, Args &&... args)
static T & element(slot_type *slot)
void swap(absl::InlinedVector< T, N, A > &a, absl::InlinedVector< T, N, A > &b) noexcept(noexcept(a.swap(b)))
static std::function< void(void *, Slot *, Slot)> construct
auto apply(Functor &&functor, Tuple &&t) -> decltype(utility_internal::apply_helper(absl::forward< Functor >(functor), absl::forward< Tuple >(t), absl::make_index_sequence< std::tuple_size< typename std::remove_reference< Tuple >::type >::value >
static void transfer(Allocator *alloc, slot_type *new_slot, slot_type *old_slot)
std::true_type constant_iterators
std::allocator< int > alloc
constexpr absl::remove_reference_t< T > && move(T &&t) noexcept
static void construct(Alloc &a, T *p, Args &&... args)