/** * Return the maximum table size. * This is the maximum size allowed by both the encoder and the decoder. */ public int getMaxHeaderTableSize() { return dynamicTable.capacity(); }
/** * Return the header field at the given index. * Exposed for testing. */ HeaderField getHeaderField(int index) { return dynamicTable.getEntry(index + 1); }
/** * Return the number of header fields in the dynamic table. * Exposed for testing. */ int length() { return dynamicTable.length(); }
private void readName(int index) throws IOException { if (index <= StaticTable.length) { HeaderField headerField = StaticTable.getEntry(index); name = headerField.name; } else if (index - StaticTable.length <= dynamicTable.length()) { HeaderField headerField = dynamicTable.getEntry(index - StaticTable.length); name = headerField.name; } else { throw ILLEGAL_INDEX_VALUE; } }
/** * Add the header field to the dynamic table. * Entries are evicted from the dynamic table until the size of the table * and the new header field is less than or equal to the table's capacity. * If the size of the new entry is larger than the table's capacity, * the dynamic table will be cleared. */ public void add(HeaderField header) { int headerSize = header.size(); if (headerSize > capacity) { clear(); return; } while (size + headerSize > capacity) { remove(); } headerFields[head++] = header; size += header.size(); if (head == headerFields.length) { head = 0; } }
if (nameLength + HEADER_ENTRY_OVERHEAD > dynamicTable.capacity()) { dynamicTable.clear(); name = EMPTY; skipLength = nameLength; if (nameLength + HEADER_ENTRY_OVERHEAD > dynamicTable.capacity()) { dynamicTable.clear(); name = EMPTY; skipLength = nameLength; if (newHeaderSize + HEADER_ENTRY_OVERHEAD > dynamicTable.capacity()) { dynamicTable.clear(); state = State.SKIP_LITERAL_HEADER_VALUE; break; if (newHeaderSize + HEADER_ENTRY_OVERHEAD > dynamicTable.capacity()) { dynamicTable.clear(); state = State.SKIP_LITERAL_HEADER_VALUE; break;
/** * Creates a new dynamic table with the specified initial capacity. */ DynamicTable(int initialCapacity) { setCapacity(initialCapacity); }
/** * Return the size of the dynamic table. * Exposed for testing. */ int size() { return dynamicTable.size(); }
private void insertHeader(HeaderListener headerListener, byte[] name, byte[] value, IndexType indexType) { addHeader(headerListener, name, value, indexType == IndexType.NEVER); switch (indexType) { case NONE: case NEVER: break; case INCREMENTAL: dynamicTable.add(new HeaderField(name, value)); break; default: throw new IllegalStateException("should not reach here"); } }
/** * Creates a new decoder. */ public Decoder(int maxHeaderSize, int maxHeaderTableSize) { dynamicTable = new DynamicTable(maxHeaderTableSize); this.maxHeaderSize = maxHeaderSize; maxDynamicTableSize = maxHeaderTableSize; encoderMaxDynamicTableSize = maxHeaderTableSize; maxDynamicTableSizeChangeRequired = false; reset(); }
private void readName(int index) throws IOException { if (index <= StaticTable.length) { HeaderField headerField = StaticTable.getEntry(index); name = headerField.name; } else if (index - StaticTable.length <= dynamicTable.length()) { HeaderField headerField = dynamicTable.getEntry(index - StaticTable.length); name = headerField.name; } else { throw ILLEGAL_INDEX_VALUE; } }
/** * Add the header field to the dynamic table. * Entries are evicted from the dynamic table until the size of the table * and the new header field is less than or equal to the table's capacity. * If the size of the new entry is larger than the table's capacity, * the dynamic table will be cleared. */ public void add(HeaderField header) { int headerSize = header.size(); if (headerSize > capacity) { clear(); return; } while (size + headerSize > capacity) { remove(); } headerFields[head++] = header; size += header.size(); if (head == headerFields.length) { head = 0; } }
if (nameLength + HEADER_ENTRY_OVERHEAD > dynamicTable.capacity()) { dynamicTable.clear(); name = EMPTY; skipLength = nameLength; if (nameLength + HEADER_ENTRY_OVERHEAD > dynamicTable.capacity()) { dynamicTable.clear(); name = EMPTY; skipLength = nameLength; if (newHeaderSize + HEADER_ENTRY_OVERHEAD > dynamicTable.capacity()) { dynamicTable.clear(); state = State.SKIP_LITERAL_HEADER_VALUE; break; if (newHeaderSize + HEADER_ENTRY_OVERHEAD > dynamicTable.capacity()) { dynamicTable.clear(); state = State.SKIP_LITERAL_HEADER_VALUE; break;
private void setDynamicTableSize(int dynamicTableSize) throws IOException { if (dynamicTableSize > maxDynamicTableSize) { throw INVALID_MAX_DYNAMIC_TABLE_SIZE; } encoderMaxDynamicTableSize = dynamicTableSize; maxDynamicTableSizeChangeRequired = false; dynamicTable.setCapacity(dynamicTableSize); }
/** * Return the size of the dynamic table. * Exposed for testing. */ int size() { return dynamicTable.size(); }
private void insertHeader(HeaderListener headerListener, byte[] name, byte[] value, IndexType indexType) { addHeader(headerListener, name, value, indexType == IndexType.NEVER); switch (indexType) { case NONE: case NEVER: break; case INCREMENTAL: dynamicTable.add(new HeaderField(name, value)); break; default: throw new IllegalStateException("should not reach here"); } }
/** * Creates a new decoder. */ public Decoder(int maxHeaderSize, int maxHeaderTableSize) { dynamicTable = new DynamicTable(maxHeaderTableSize); this.maxHeaderSize = maxHeaderSize; maxDynamicTableSize = maxHeaderTableSize; encoderMaxDynamicTableSize = maxHeaderTableSize; maxDynamicTableSizeChangeRequired = false; reset(); }
private void indexHeader(int index, HeaderListener headerListener) throws IOException { if (index <= StaticTable.length) { HeaderField headerField = StaticTable.getEntry(index); addHeader(headerListener, headerField.name, headerField.value, false); } else if (index - StaticTable.length <= dynamicTable.length()) { HeaderField headerField = dynamicTable.getEntry(index - StaticTable.length); addHeader(headerListener, headerField.name, headerField.value, false); } else { throw ILLEGAL_INDEX_VALUE; } }