proxygen: proxygen::HPACKEncoder Class Reference

#include <HPACKEncoder.h>

Inheritance diagram for proxygen::HPACKEncoder:

Public Member Functions
	HPACKEncoder (bool huffman, uint32_t tableSize=HPACK::kTableSize)

std::unique_ptr< folly::IOBuf >	encode (const std::vector< HPACKHeader > &headers, uint32_t headroom=0)

void	setHeaderTableSize (uint32_t size)

Public Member Functions inherited from proxygen::HPACKEncoderBase
	HPACKEncoderBase (bool huffman)

void	setHeaderTableSize (HeaderTable &table, uint32_t size)

void	setHeaderIndexingStrategy (const HeaderIndexingStrategy *indexingStrat)

const HeaderIndexingStrategy *	getHeaderIndexingStrategy () const

Public Member Functions inherited from proxygen::HPACKContext
	HPACKContext (uint32_t tableSize)

	~HPACKContext ()

uint32_t	getIndex (const HPACKHeader &header) const

uint32_t	nameIndex (const HPACKHeaderName &headerName) const

bool	isStatic (uint32_t index) const

const HPACKHeader &	getHeader (uint32_t index)

const HeaderTable &	getTable () const

uint32_t	getTableSize () const

uint32_t	getBytesStored () const

uint32_t	getHeadersStored () const

void	seedHeaderTable (std::vector< HPACKHeader > &headers)

void	describe (std::ostream &os) const

Private Member Functions
void	encodeAsIndex (uint32_t index)

void	encodeHeader (const HPACKHeader &header)

bool	encodeAsLiteral (const HPACKHeader &header, bool indexing)

void	encodeLiteral (const HPACKHeader &header, uint32_t nameIndex, const HPACK::Instruction &instruction)

Additional Inherited Members
Static Public Attributes inherited from proxygen::HPACKEncoderBase
static const uint32_t	kBufferGrowth = 4000

Protected Member Functions inherited from proxygen::HPACKEncoderBase
void	handlePendingContextUpdate (HPACKEncodeBuffer &buf, uint32_t tableCapacity)

Protected Member Functions inherited from proxygen::HPACKContext
const StaticHeaderTable &	getStaticTable () const

uint32_t	globalToDynamicIndex (uint32_t index) const

uint32_t	globalToStaticIndex (uint32_t index) const

uint32_t	dynamicToGlobalIndex (uint32_t index) const

uint32_t	staticToGlobalIndex (uint32_t index) const

Protected Attributes inherited from proxygen::HPACKEncoderBase
const HeaderIndexingStrategy *	indexingStrat_

HPACKEncodeBuffer	streamBuffer_

bool	pendingContextUpdate_ {false}

Protected Attributes inherited from proxygen::HPACKContext
HeaderTable	table_

Detailed Description

Definition at line 19 of file HPACKEncoder.h.

Constructor & Destructor Documentation

proxygen::HPACKEncoder::HPACKEncoder	(	bool	huffman,
		uint32_t	tableSize = `HPACK::kTableSize`
	)

inlineexplicit

Definition at line 22 of file HPACKEncoder.h.

References encode(), and uint32_t.

24 : HPACKEncoderBase(huffman)

25 , HPACKContext(tableSize) {}

proxygen::HPACKEncoderBase::HPACKEncoderBase

HPACKEncoderBase(bool huffman)

Definition: HPACKEncoderBase.h:24

proxygen::HPACKContext::HPACKContext

HPACKContext(uint32_t tableSize)

Definition: HPACKContext.cpp:14

Member Function Documentation

std::unique_ptr< folly::IOBuf > proxygen::HPACKEncoder::encode	(	const std::vector< HPACKHeader > &	headers,
		uint32_t	headroom = `0`
	)

Encode the given headers.

Definition at line 17 of file HPACKEncoder.cpp.

References proxygen::HPACKEncodeBuffer::addHeadroom(), proxygen::HeaderTable::capacity(), encodeHeader(), proxygen::HPACKEncoderBase::handlePendingContextUpdate(), proxygen::HPACKEncodeBuffer::release(), proxygen::HPACKEncoderBase::streamBuffer_, and proxygen::HPACKContext::table_.

Referenced by encode(), proxygen::HPACKCodec::encode(), proxygen::hpack::encodeDecode(), HPACKEncoder(), TEST_F(), and TEST_P().

                                                                           {
   if (headroom) {
     streamBuffer_.addHeadroom(headroom);
   }
   handlePendingContextUpdate(streamBuffer_, table_.capacity());
   for (const auto& header : headers) {
     encodeHeader(header);
   }
   return streamBuffer_.release();
 }

void proxygen::HPACKEncoder::encodeAsIndex ( uint32_t index )

private

Definition at line 63 of file HPACKEncoder.cpp.

References proxygen::HPACKEncodeBuffer::encodeInteger(), proxygen::HPACK::INDEX_REF, and proxygen::HPACKEncoderBase::streamBuffer_.

Referenced by encodeHeader(), and setHeaderTableSize().

                                                {
   VLOG(10) << "encoding index=" << index;
   streamBuffer_.encodeInteger(index, HPACK::INDEX_REF);
 }

bool proxygen::HPACKEncoder::encodeAsLiteral	(	const HPACKHeader &	header,
		bool	indexing
	)

private

Definition at line 28 of file HPACKEncoder.cpp.

References proxygen::HeaderTable::add(), proxygen::HPACKHeader::bytes(), proxygen::HeaderTable::capacity(), proxygen::HPACKHeader::copy(), encodeLiteral(), proxygen::HPACK::LITERAL, proxygen::HPACK::LITERAL_INC_INDEX, proxygen::HPACKHeader::name, proxygen::HPACKContext::nameIndex(), and proxygen::HPACKContext::table_.

Referenced by encodeHeader(), and setHeaderTableSize().

                                                                            {
   if (header.bytes() > table_.capacity()) {
     // May want to investigate further whether or not this is wanted.
     // Flushing the table on a large header frees up some memory,
     // however, there will be no compression due to an empty table, and
     // the table will fill up again fairly quickly
     indexing = false;
   }
 
   HPACK::Instruction instruction = (indexing) ?
     HPACK::LITERAL_INC_INDEX : HPACK::LITERAL;
 
   encodeLiteral(header, nameIndex(header.name), instruction);
   // indexed ones need to get added to the header table
   if (indexing) {
     CHECK(table_.add(header.copy()));
   }
   return true;
 }

void proxygen::HPACKEncoder::encodeHeader ( const HPACKHeader & header )

private

Definition at line 68 of file HPACKEncoder.cpp.

References encodeAsIndex(), encodeAsLiteral(), proxygen::HPACKContext::getIndex(), proxygen::HeaderIndexingStrategy::indexHeader(), proxygen::HPACKEncoderBase::indexingStrat_, and uint32_t.

Referenced by encode(), and setHeaderTableSize().

                                                          {
   // First determine whether the header is defined as indexable using the
   // set strategy if applicable, else assume it is indexable
   bool indexable = !indexingStrat_ || indexingStrat_->indexHeader(header);
 
   // If the header was not defined as indexable, its a reasonable assumption
   // that it does not appear in either the static or dynamic table and should
   // not be searched.  The only time this is not true is if the header indexing
   // strat specified an exact header/value pair that is in the static header
   // table although semantically the header indexing strategy should indeed act
   // as an override so we assume this is desired if such a case occurs
   uint32_t index = 0;
   if (indexable) {
     index = getIndex(header);
   }
 
   // Finally encode the header as determined above
   if (index) {
     encodeAsIndex(index);
   } else {
     encodeAsLiteral(header, indexable);
   }
 }

void proxygen::HPACKEncoder::encodeLiteral	(	const HPACKHeader &	header,
		uint32_t	nameIndex,
		const HPACK::Instruction &	instruction
	)

private

Definition at line 48 of file HPACKEncoder.cpp.

References proxygen::HPACKEncodeBuffer::encodeInteger(), proxygen::HPACKEncodeBuffer::encodeLiteral(), proxygen::HPACKHeaderName::get(), proxygen::HPACKHeader::name, proxygen::HPACKContext::nameIndex(), proxygen::HPACKEncoderBase::streamBuffer_, and proxygen::HPACKHeader::value.

Referenced by encodeAsLiteral(), and setHeaderTableSize().

                                                                       {
   // name
   if (nameIndex) {
     VLOG(10) << "encoding name index=" << nameIndex;
     streamBuffer_.encodeInteger(nameIndex, instruction);
   } else {
     streamBuffer_.encodeInteger(0, instruction);
     streamBuffer_.encodeLiteral(header.name.get());
   }
   // value
   streamBuffer_.encodeLiteral(header.value);
 }

void proxygen::HPACKEncoder::setHeaderTableSize ( uint32_t size )

inline

Definition at line 35 of file HPACKEncoder.h.

References encodeAsIndex(), encodeAsLiteral(), encodeHeader(), encodeLiteral(), proxygen::HPACKContext::nameIndex(), proxygen::HPACKEncoderBase::setHeaderTableSize(), proxygen::HPACKContext::table_, and uint32_t.

Referenced by TEST_P().

                                          {
     HPACKEncoderBase::setHeaderTableSize(table_, size);
   }

The documentation for this class was generated from the following files:

proxygen/lib/http/codec/compress/HPACKEncoder.h
proxygen/lib/http/codec/compress/HPACKEncoder.cpp

Public Member Functions

Private Member Functions

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation