std/hpack

pub alias Bytes = Std::Slice::Bytes

pub class Decoder
  def decode(payload : Bytes) : Array(HeaderField) | HpackError
  def dynamic_table : DynamicTable
  def initialize(max_table_size : Int32 = 4096, protocol_max_table_size : Int32 = 4096, max_header_list_size : Int32 = 65536, max_header_count : Int32 = 1000)
  def max_header_count : Int32
  def max_header_count=(value : Int32) : Int32
  def max_header_list_size : Int32
  def max_header_list_size=(value : Int32) : Int32
  def protocol_max_table_size : Int32
  # A SETTINGS_HEADER_TABLE_SIZE change reaches the table too: the limit
  # was only this field's, and the table went on refusing an update above
  # the size it was made with.
  def protocol_max_table_size=(limit : Int32) : Nil
end

pub class DynamicTable
  def add(name : String, value : String, never_indexed : Bool = false) : Nil
  def add(field : HeaderField) : Nil
  def empty? : Bool
  def entries : Array(HeaderField)
  def find(name : String, value : String) : Tuple(Int32, Bool)
  def find_name(name : String) : Int32
  def get(relative_index : Int32) : HeaderField | ::Nil
  # A table is made within the limit it is resized within: made above it,
  # an encoder's table outgrew the peer's, and an Encoder made with 8192
  # sent blocks a default Decoder refused ("Index 121 out of range (max:
  # 103)") while `set_max_size(8192)` on it was refused.
  def initialize(max_size : Int32 = 4096, settings_max_size : Int32 = 4096)
  def length : Int32
  def max_size : Int32
  def set_max_size(new_max : Int32) : Nil | HpackError
  def settings_max_size : Int32
  # The protocol's limit (SETTINGS_HEADER_TABLE_SIZE) as it changes during
  # a connection; the size in use still moves only by `set_max_size`.
  def settings_max_size=(limit : Int32) : Nil
  def size : Int32
  def self.size_error(new_max : Int32, limit : Int32) : HpackError | ::Nil
end

pub class Encoder
  def dynamic_table : DynamicTable
  def encode(headers : Array(HeaderField), force_huffman : Bool | ::Nil = nil) : Bytes
  def initialize(max_table_size : Int32 = 4096, protocol_max_table_size : Int32 = 4096, use_huffman : Bool = true)
  def protocol_max_table_size : Int32
  # A SETTINGS_HEADER_TABLE_SIZE change reaches the table too: the limit
  # was only this field's, so a raised one was refused by the table and a
  # lowered one left the table above it (RFC 7541 4.2), with no update.
  # A lowered limit is always signalled: the peer's table may still be the
  # size the old limit let it start at, which this encoder never sent.
  def protocol_max_table_size=(limit : Int32) : Nil
  def set_max_table_size(new_max : Int32) : Nil | HpackError
  def use_huffman : Bool
  def use_huffman=(value : Bool) : Bool
end

pub struct HeaderField
  def ==(other : HeaderField) : Bool
  def indexing : IndexingMode
  def initialize(name : String, value : String, indexing : IndexingMode = IndexingMode::Incremental)
  def initialize(name : String, value : String, never_indexed : Bool)
  def name : String
  def never_indexed : Bool
  def size : Int32
  def to_s : String
  def value : String
end

pub struct HpackError
  def initialize(message : String)
  def to_s : String
end

pub class Huffman
  def self.decode(bytes : Bytes, offset : Int32, length : Int32) : String | HpackError
  def self.decode(bytes : Bytes) : String | HpackError
  def self.encode(input : String, buffer : Array(UInt8)) : Nil
  def self.encode(input : String) : Bytes
  def self.encode(input : Bytes) : Bytes
  def self.encoded_size(input : String) : Int32
end

pub struct IndexingMode
  def ==(other : IndexingMode) : Bool
  def initialize(value : Int32)
  def value : Int32
end

pub class Integer
  def self.decode(bytes : Bytes, offset : Int32, prefix_bits : Int32) : Tuple(UInt64, Int32) | HpackError
  def self.encode(val : UInt64, prefix_bits : Int32, prefix_byte : UInt8, buffer : Array(UInt8)) : Nil
  def self.encode(val : UInt64, prefix_bits : Int32, prefix_byte : UInt8 = 0_u8) : Bytes
end

pub alias IntegerCodec = Integer

pub class StaticTable
  def self.find(name : String, value : String) : Tuple(Int32, Bool)
  def self.find_name(name : String) : Int32
  def self.get(index : Int32) : HeaderField | ::Nil
  def self.size : Int32
end

pub class Table
  def self.find(dynamic_table : DynamicTable, name : String, value : String) : Tuple(Int32, Bool)
  def self.find_name(dynamic_table : DynamicTable, name : String) : Int32
  def self.get(dynamic_table : DynamicTable, global_index : Int32) : HeaderField | ::Nil
end

impl Error for HpackError
  def message : String
end