Class TTable

library/cpp/containers/flat_hash/lib/table.h:30–312

    // Used in the TSet to make iterator behave as const_iterator
    template <class> class IteratorModifier = NPrivate::TTypeIdentity>
class TTable {
private:
    static_assert(NConcepts::ContainerV<Container>);
    static_assert(NConcepts::SizeFitterV<SizeFitter>);

    template <class C, class V>
    class TIteratorImpl : public TIterator<C, V> {
    private:
        using TBase = TIterator<C, V>;
        friend class TTable;

        using TBase::TBase;

    public:
        TIteratorImpl() : TBase(nullptr, 0) {}
    };

public:
    using value_type = typename Container::value_type;
    using size_type = typename Container::size_type;
    using difference_type = typename Container::difference_type;
    using hasher = Hash;
    using key_equal = KeyEqual;

    using reference = value_type&;
    using const_reference = const value_type&;

    using iterator = TIteratorImpl<typename IteratorModifier<Container>::type,
                                   typename IteratorModifier<value_type>::type>;
    using const_iterator = TIteratorImpl<const Container, const value_type>;
    using allocator_type = typename Container::allocator_type;
    using pointer = typename Container::pointer;
    using const_pointer = typename Container::const_pointer;

private:
    TTable(Container buckets)
        : Buckets_(std::move(buckets))
    {
        SizeFitter_.Update(bucket_count());
    }

    static constexpr size_type INIT_SIZE = 8;

public:
    template <class... Rest>
    TTable(size_type initSize, Rest&&... rest)
        : Buckets_(initSize == 0 ? INIT_SIZE : SizeFitter_.EvalSize(initSize),
                   std::forward<Rest>(rest)...)
    {
        SizeFitter_.Update(bucket_count());
    }

    TTable(const TTable&) = default;
    TTable(TTable&& rhs)
        : SizeFitter_(std::move(rhs.SizeFitter_))
        , Buckets_(std::move(rhs.Buckets_))
        , Hasher_(std::move(rhs.Hasher_))
        , KeyEqual_(std::move(rhs.KeyEqual_))