HeaderTable.h

Go to the documentation of this file.

/*
 *  Copyright (c) 2015-present, Facebook, Inc.
 *  All rights reserved.
 *
 *  This source code is licensed under the BSD-style license found in the
 *  LICENSE file in the root directory of this source tree. An additional grant
 *  of patent rights can be found in the PATENTS file in the same directory.
 *
 */
#pragma once

#include <list>
#include <proxygen/lib/http/codec/compress/HPACKHeader.h>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>

namespace proxygen {

class HeaderTable {
 public:
  using names_map = std::unordered_map<HPACKHeaderName, std::list<uint32_t>>;

  explicit HeaderTable(uint32_t capacityVal) {
    init(capacityVal);
  }

  virtual ~HeaderTable() {}
  HeaderTable(const HeaderTable&) = delete;
  HeaderTable& operator=(const HeaderTable&) = delete;

  virtual bool add(HPACKHeader header);

  uint32_t getIndex(const HPACKHeader& header) const;

  const HPACKHeader& getHeader(uint32_t index) const;

  bool isValid(uint32_t index) const;

  bool hasName(const HPACKHeaderName& headerName);

  const names_map& names() const {
    return names_;
  }

  uint32_t nameIndex(const HPACKHeaderName& headerName) const;

  uint32_t capacity() const {
    return capacity_;
  }

  uint32_t getMaxTableLength(uint32_t capacityVal);

  virtual bool setCapacity(uint32_t capacity);

  uint32_t size() const {
    return size_;
  }

  uint32_t bytes() const {
    return bytes_;
  }

  size_t length() const {
    return table_.size();
  }

  bool operator==(const HeaderTable& other) const;

  static uint32_t toExternal(uint32_t head, uint32_t length,
                             uint32_t internalIndex);

  static uint32_t toInternal(uint32_t head, uint32_t length,
                             uint32_t externalIndex);

 protected:
  void init(uint32_t capacityVal);

  /*
   * Increase table length to newLength
   */
  virtual void increaseTableLengthTo(uint32_t newLength);

  virtual void resizeTable(uint32_t newLength);

  virtual void updateResizedTable(uint32_t oldTail, uint32_t oldLength,
                                  uint32_t newLength);

  virtual uint32_t removeLast();

  void reset();

  virtual uint32_t evict(uint32_t needed, uint32_t desiredCapacity);

  uint32_t next(uint32_t i) const;

  uint32_t tail() const;

  uint32_t toExternal(uint32_t internalIndex) const;

  uint32_t toInternal(uint32_t externalIndex) const;

  uint32_t capacity_{0};
  uint32_t bytes_{0};     // size in bytes of the current entries
  std::vector<HPACKHeader> table_;

  uint32_t size_{0};    // how many entries we have in the table
  uint32_t head_{0};     // points to the first element of the ring

  names_map names_;

 private:
  /*
   * Shared implementation for getIndex and nameIndex
   */
  uint32_t getIndexImpl(const HPACKHeaderName& header,
                        const folly::fbstring& value,
                        bool nameOnly) const;
};

std::ostream& operator<<(std::ostream& os, const HeaderTable& table);

}