public:

explicit hpack_dynamic_table(server::resource_budget budget, std::size_t capacity = 4096)

: budget_(std::move(budget)), capacity_(capacity) {}

hpack_dynamic_table(const hpack_dynamic_table&) = delete;

hpack_dynamic_table& operator=(const hpack_dynamic_table&) = delete;

// Dynamic views are invalidated by insertion, eviction, or destruction.

std::optional<hpack_static_entry> lookup(std::uint64_t index) const noexcept;

std::uint64_t find(std::string_view name, std::string_view value) const noexcept;

std::uint64_t find_name(std::string_view name) const noexcept;

hpack_status insert(std::string name, std::string value);

// Views must refer to externally owned fields, not table storage. Admission

// precedes string copies; use insert with owned strings for table references.

hpack_status insert_copy(std::string_view name, std::string_view value);

void set_capacity(std::size_t capacity) noexcept;

void clear() noexcept;

std::size_t bytes() const noexcept { return bytes_; }

std::size_t size() const noexcept { return entries_.size(); }

std::size_t capacity() const noexcept { return capacity_; }

private:

struct entry {

std::string name;

std::string value;

server::reservation charge;

};

template<typename MakeEntry>

hpack_status insert_entry(std::size_t name, std::size_t value, MakeEntry make_entry) {

std::size_t size = 0;

if (!hpack_entry_size(name, value, size)) return {hpack_state::limit_exceeded};

if (size > capacity_) {

clear();

return {};

}

evict_to(capacity_ - size);

server::reservation charge;

if (!budget_.reserve(server::resource::hpack_table_bytes, size, charge).ok()) return {hpack_state::limit_exceeded};

entries_.insert(entries_.begin(), make_entry(std::move(charge)));

bytes_ += size;

return {};

}

void evict_to(std::size_t limit) noexcept;

server::resource_budget budget_;

std::size_t capacity_;

std::size_t bytes_ = 0;

std::vector<entry> entries_;