Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $
You can buy this project and download/modify it how often you want.
io.netty.handler.codec.DefaultHeaders Maven / Gradle / Ivy
/*
* Copyright 2014 The Netty Project
*
* The Netty Project licenses this file to you under the Apache License, version 2.0 (the
* "License"); you may not use this file except in compliance with the License. You may obtain a
* copy of the License at:
*
* https://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software distributed under the License
* is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
* or implied. See the License for the specific language governing permissions and limitations under
* the License.
*/
package io.netty.handler.codec;
import io.netty.util.HashingStrategy;
import java.util.Arrays;
import java.util.Collections;
import java.util.Iterator;
import java.util.LinkedHashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.NoSuchElementException;
import java.util.Set;
import static io.netty.util.HashingStrategy.JAVA_HASHER;
import static io.netty.util.internal.MathUtil.findNextPositivePowerOfTwo;
import static io.netty.util.internal.ObjectUtil.checkNotNull;
import static java.lang.Math.max;
import static java.lang.Math.min;
/**
* Default implementation of {@link Headers};
*
* @param the type of the header name.
* @param the type of the header value.
* @param the type to use for return values when the intention is to return {@code this} object.
*/
public class DefaultHeaders> implements Headers {
/**
* Constant used to seed the hash code generation. Could be anything but this was borrowed from murmur3.
*/
static final int HASH_CODE_SEED = 0xc2b2ae35;
private final HeaderEntry[] entries;
protected final HeaderEntry head;
private final byte hashMask;
private final ValueConverter valueConverter;
private final NameValidator nameValidator;
private final ValueValidator valueValidator;
private final HashingStrategy hashingStrategy;
int size;
public interface NameValidator {
/**
* Verify that {@code name} is valid.
* @param name The name to validate.
* @throws RuntimeException if {@code name} is not valid.
*/
void validateName(K name);
@SuppressWarnings("rawtypes")
NameValidator NOT_NULL = new NameValidator() {
@Override
public void validateName(Object name) {
checkNotNull(name, "name");
}
};
}
public interface ValueValidator {
/**
* Validate the given value. If the validation fails, then an implementation specific runtime exception may be
* thrown.
*
* @param value The value to validate.
*/
void validate(V value);
ValueValidator NO_VALIDATION = new ValueValidator() {
@Override
public void validate(Object value) {
}
};
}
@SuppressWarnings("unchecked")
public DefaultHeaders(ValueConverter valueConverter) {
this(JAVA_HASHER, valueConverter);
}
@SuppressWarnings("unchecked")
public DefaultHeaders(ValueConverter valueConverter, NameValidator nameValidator) {
this(JAVA_HASHER, valueConverter, nameValidator);
}
@SuppressWarnings("unchecked")
public DefaultHeaders(HashingStrategy nameHashingStrategy, ValueConverter valueConverter) {
this(nameHashingStrategy, valueConverter, NameValidator.NOT_NULL);
}
public DefaultHeaders(HashingStrategy nameHashingStrategy,
ValueConverter valueConverter, NameValidator nameValidator) {
this(nameHashingStrategy, valueConverter, nameValidator, 16);
}
/**
* Create a new instance.
* @param nameHashingStrategy Used to hash and equality compare names.
* @param valueConverter Used to convert values to/from native types.
* @param nameValidator Used to validate name elements.
* @param arraySizeHint A hint as to how large the hash data structure should be.
* The next positive power of two will be used. An upper bound may be enforced.
*/
@SuppressWarnings("unchecked")
public DefaultHeaders(HashingStrategy nameHashingStrategy,
ValueConverter valueConverter, NameValidator nameValidator, int arraySizeHint) {
this(nameHashingStrategy, valueConverter, nameValidator, arraySizeHint,
(ValueValidator) ValueValidator.NO_VALIDATION);
}
/**
* Create a new instance.
* @param nameHashingStrategy Used to hash and equality compare names.
* @param valueConverter Used to convert values to/from native types.
* @param nameValidator Used to validate name elements.
* @param arraySizeHint A hint as to how large the hash data structure should be.
* The next positive power of two will be used. An upper bound may be enforced.
* @param valueValidator The validation strategy for entry values.
*/
@SuppressWarnings("unchecked")
public DefaultHeaders(HashingStrategy nameHashingStrategy, ValueConverter valueConverter,
NameValidator nameValidator, int arraySizeHint, ValueValidator valueValidator) {
this.valueConverter = checkNotNull(valueConverter, "valueConverter");
this.nameValidator = checkNotNull(nameValidator, "nameValidator");
hashingStrategy = checkNotNull(nameHashingStrategy, "nameHashingStrategy");
this.valueValidator = checkNotNull(valueValidator, "valueValidator");
// Enforce a bound of [2, 128] because hashMask is a byte. The max possible value of hashMask is one less
// than the length of this array, and we want the mask to be > 0.
entries = new HeaderEntry[findNextPositivePowerOfTwo(max(2, min(arraySizeHint, 128)))];
hashMask = (byte) (entries.length - 1);
head = new HeaderEntry();
}
@Override
public V get(K name) {
checkNotNull(name, "name");
int h = hashingStrategy.hashCode(name);
int i = index(h);
HeaderEntry e = entries[i];
V value = null;
// loop until the first header was found
while (e != null) {
if (e.hash == h && hashingStrategy.equals(name, e.key)) {
value = e.value;
}
e = e.next;
}
return value;
}
@Override
public V get(K name, V defaultValue) {
V value = get(name);
if (value == null) {
return defaultValue;
}
return value;
}
@Override
public V getAndRemove(K name) {
int h = hashingStrategy.hashCode(name);
return remove0(h, index(h), checkNotNull(name, "name"));
}
@Override
public V getAndRemove(K name, V defaultValue) {
V value = getAndRemove(name);
if (value == null) {
return defaultValue;
}
return value;
}
@Override
public List getAll(K name) {
checkNotNull(name, "name");
LinkedList values = new LinkedList();
int h = hashingStrategy.hashCode(name);
int i = index(h);
HeaderEntry e = entries[i];
while (e != null) {
if (e.hash == h && hashingStrategy.equals(name, e.key)) {
values.addFirst(e.getValue());
}
e = e.next;
}
return values;
}
/**
* Equivalent to {@link #getAll(Object)} but no intermediate list is generated.
* @param name the name of the header to retrieve
* @return an {@link Iterator} of header values corresponding to {@code name}.
*/
public Iterator valueIterator(K name) {
return new ValueIterator(name);
}
@Override
public List getAllAndRemove(K name) {
List all = getAll(name);
remove(name);
return all;
}
@Override
public boolean contains(K name) {
return get(name) != null;
}
@Override
public boolean containsObject(K name, Object value) {
return contains(name, fromObject(name, value));
}
@Override
public boolean containsBoolean(K name, boolean value) {
return contains(name, fromBoolean(name, value));
}
@Override
public boolean containsByte(K name, byte value) {
return contains(name, fromByte(name, value));
}
@Override
public boolean containsChar(K name, char value) {
return contains(name, fromChar(name, value));
}
@Override
public boolean containsShort(K name, short value) {
return contains(name, fromShort(name, value));
}
@Override
public boolean containsInt(K name, int value) {
return contains(name, fromInt(name, value));
}
@Override
public boolean containsLong(K name, long value) {
return contains(name, fromLong(name, value));
}
@Override
public boolean containsFloat(K name, float value) {
return contains(name, fromFloat(name, value));
}
@Override
public boolean containsDouble(K name, double value) {
return contains(name, fromDouble(name, value));
}
@Override
public boolean containsTimeMillis(K name, long value) {
return contains(name, fromTimeMillis(name, value));
}
@SuppressWarnings("unchecked")
@Override
public boolean contains(K name, V value) {
return contains(name, value, JAVA_HASHER);
}
public final boolean contains(K name, V value, HashingStrategy valueHashingStrategy) {
checkNotNull(name, "name");
int h = hashingStrategy.hashCode(name);
int i = index(h);
HeaderEntry e = entries[i];
while (e != null) {
if (e.hash == h && hashingStrategy.equals(name, e.key) && valueHashingStrategy.equals(value, e.value)) {
return true;
}
e = e.next;
}
return false;
}
@Override
public int size() {
return size;
}
@Override
public boolean isEmpty() {
return head == head.after;
}
@Override
public Set names() {
if (isEmpty()) {
return Collections.emptySet();
}
Set names = new LinkedHashSet(size());
HeaderEntry e = head.after;
while (e != head) {
names.add(e.getKey());
e = e.after;
}
return names;
}
@Override
public T add(K name, V value) {
validateName(nameValidator, true, name);
validateValue(valueValidator, name, value);
checkNotNull(value, "value");
int h = hashingStrategy.hashCode(name);
int i = index(h);
add0(h, i, name, value);
return thisT();
}
@Override
public T add(K name, Iterable values) {
validateName(nameValidator, true, name);
int h = hashingStrategy.hashCode(name);
int i = index(h);
for (V v: values) {
validateValue(valueValidator, name, v);
add0(h, i, name, v);
}
return thisT();
}
@Override
public T add(K name, V... values) {
validateName(nameValidator, true, name);
int h = hashingStrategy.hashCode(name);
int i = index(h);
for (V v: values) {
validateValue(valueValidator, name, v);
add0(h, i, name, v);
}
return thisT();
}
@Override
public T addObject(K name, Object value) {
return add(name, fromObject(name, value));
}
@Override
public T addObject(K name, Iterable values) {
for (Object value : values) {
addObject(name, value);
}
return thisT();
}
@Override
public T addObject(K name, Object... values) {
for (Object value: values) {
addObject(name, value);
}
return thisT();
}
@Override
public T addInt(K name, int value) {
return add(name, fromInt(name, value));
}
@Override
public T addLong(K name, long value) {
return add(name, fromLong(name, value));
}
@Override
public T addDouble(K name, double value) {
return add(name, fromDouble(name, value));
}
@Override
public T addTimeMillis(K name, long value) {
return add(name, fromTimeMillis(name, value));
}
@Override
public T addChar(K name, char value) {
return add(name, fromChar(name, value));
}
@Override
public T addBoolean(K name, boolean value) {
return add(name, fromBoolean(name, value));
}
@Override
public T addFloat(K name, float value) {
return add(name, fromFloat(name, value));
}
@Override
public T addByte(K name, byte value) {
return add(name, fromByte(name, value));
}
@Override
public T addShort(K name, short value) {
return add(name, fromShort(name, value));
}
@Override
public T add(Headers headers) {
if (headers == this) {
throw new IllegalArgumentException("can't add to itself.");
}
addImpl(headers);
return thisT();
}
protected void addImpl(Headers headers) {
if (headers instanceof DefaultHeaders) {
@SuppressWarnings("unchecked")
final DefaultHeaders defaultHeaders =
(DefaultHeaders) headers;
HeaderEntry e = defaultHeaders.head.after;
if (defaultHeaders.hashingStrategy == hashingStrategy &&
defaultHeaders.nameValidator == nameValidator) {
// Fastest copy
while (e != defaultHeaders.head) {
add0(e.hash, index(e.hash), e.key, e.value);
e = e.after;
}
} else {
// Fast copy
while (e != defaultHeaders.head) {
add(e.key, e.value);
e = e.after;
}
}
} else {
// Slow copy
for (Entry header : headers) {
add(header.getKey(), header.getValue());
}
}
}
@Override
public T set(K name, V value) {
validateName(nameValidator, false, name);
validateValue(valueValidator, name, value);
checkNotNull(value, "value");
int h = hashingStrategy.hashCode(name);
int i = index(h);
remove0(h, i, name);
add0(h, i, name, value);
return thisT();
}
@Override
public T set(K name, Iterable values) {
validateName(nameValidator, false, name);
checkNotNull(values, "values");
int h = hashingStrategy.hashCode(name);
int i = index(h);
remove0(h, i, name);
for (V v: values) {
if (v == null) {
break;
}
validateValue(valueValidator, name, v);
add0(h, i, name, v);
}
return thisT();
}
@Override
public T set(K name, V... values) {
validateName(nameValidator, false, name);
checkNotNull(values, "values");
int h = hashingStrategy.hashCode(name);
int i = index(h);
remove0(h, i, name);
for (V v: values) {
if (v == null) {
break;
}
validateValue(valueValidator, name, v);
add0(h, i, name, v);
}
return thisT();
}
@Override
public T setObject(K name, Object value) {
V convertedValue = checkNotNull(fromObject(name, value), "convertedValue");
return set(name, convertedValue);
}
@Override
public T setObject(K name, Iterable values) {
validateName(nameValidator, false, name);
int h = hashingStrategy.hashCode(name);
int i = index(h);
remove0(h, i, name);
for (Object v: values) {
if (v == null) {
break;
}
V converted = fromObject(name, v);
validateValue(valueValidator, name, converted);
add0(h, i, name, converted);
}
return thisT();
}
@Override
public T setObject(K name, Object... values) {
validateName(nameValidator, false, name);
int h = hashingStrategy.hashCode(name);
int i = index(h);
remove0(h, i, name);
for (Object v: values) {
if (v == null) {
break;
}
V converted = fromObject(name, v);
validateValue(valueValidator, name, converted);
add0(h, i, name, converted);
}
return thisT();
}
@Override
public T setInt(K name, int value) {
return set(name, fromInt(name, value));
}
@Override
public T setLong(K name, long value) {
return set(name, fromLong(name, value));
}
@Override
public T setDouble(K name, double value) {
return set(name, fromDouble(name, value));
}
@Override
public T setTimeMillis(K name, long value) {
return set(name, fromTimeMillis(name, value));
}
@Override
public T setFloat(K name, float value) {
return set(name, fromFloat(name, value));
}
@Override
public T setChar(K name, char value) {
return set(name, fromChar(name, value));
}
@Override
public T setBoolean(K name, boolean value) {
return set(name, fromBoolean(name, value));
}
@Override
public T setByte(K name, byte value) {
return set(name, fromByte(name, value));
}
@Override
public T setShort(K name, short value) {
return set(name, fromShort(name, value));
}
@Override
public T set(Headers headers) {
if (headers != this) {
clear();
addImpl(headers);
}
return thisT();
}
@Override
public T setAll(Headers headers) {
if (headers != this) {
for (K key : headers.names()) {
remove(key);
}
addImpl(headers);
}
return thisT();
}
@Override
public boolean remove(K name) {
return getAndRemove(name) != null;
}
@Override
public T clear() {
Arrays.fill(entries, null);
head.before = head.after = head;
size = 0;
return thisT();
}
@Override
public Iterator> iterator() {
return new HeaderIterator();
}
@Override
public Boolean getBoolean(K name) {
V v = get(name);
try {
return v != null ? toBoolean(name, v) : null;
} catch (RuntimeException ignore) {
return null;
}
}
@Override
public boolean getBoolean(K name, boolean defaultValue) {
Boolean v = getBoolean(name);
return v != null ? v : defaultValue;
}
@Override
public Byte getByte(K name) {
V v = get(name);
try {
return v != null ? toByte(name, v) : null;
} catch (RuntimeException ignore) {
return null;
}
}
@Override
public byte getByte(K name, byte defaultValue) {
Byte v = getByte(name);
return v != null ? v : defaultValue;
}
@Override
public Character getChar(K name) {
V v = get(name);
try {
return v != null ? toChar(name, v) : null;
} catch (RuntimeException ignore) {
return null;
}
}
@Override
public char getChar(K name, char defaultValue) {
Character v = getChar(name);
return v != null ? v : defaultValue;
}
@Override
public Short getShort(K name) {
V v = get(name);
try {
return v != null ? toShort(name, v) : null;
} catch (RuntimeException ignore) {
return null;
}
}
@Override
public short getShort(K name, short defaultValue) {
Short v = getShort(name);
return v != null ? v : defaultValue;
}
@Override
public Integer getInt(K name) {
V v = get(name);
try {
return v != null ? toInt(name, v) : null;
} catch (RuntimeException ignore) {
return null;
}
}
@Override
public int getInt(K name, int defaultValue) {
Integer v = getInt(name);
return v != null ? v : defaultValue;
}
@Override
public Long getLong(K name) {
V v = get(name);
try {
return v != null ? toLong(name, v) : null;
} catch (RuntimeException ignore) {
return null;
}
}
@Override
public long getLong(K name, long defaultValue) {
Long v = getLong(name);
return v != null ? v : defaultValue;
}
@Override
public Float getFloat(K name) {
V v = get(name);
try {
return v != null ? toFloat(name, v) : null;
} catch (RuntimeException ignore) {
return null;
}
}
@Override
public float getFloat(K name, float defaultValue) {
Float v = getFloat(name);
return v != null ? v : defaultValue;
}
@Override
public Double getDouble(K name) {
V v = get(name);
try {
return v != null ? toDouble(name, v) : null;
} catch (RuntimeException ignore) {
return null;
}
}
@Override
public double getDouble(K name, double defaultValue) {
Double v = getDouble(name);
return v != null ? v : defaultValue;
}
@Override
public Long getTimeMillis(K name) {
V v = get(name);
try {
return v != null ? toTimeMillis(name, v) : null;
} catch (RuntimeException ignore) {
return null;
}
}
@Override
public long getTimeMillis(K name, long defaultValue) {
Long v = getTimeMillis(name);
return v != null ? v : defaultValue;
}
@Override
public Boolean getBooleanAndRemove(K name) {
V v = getAndRemove(name);
try {
return v != null ? toBoolean(name, v) : null;
} catch (RuntimeException ignore) {
return null;
}
}
@Override
public boolean getBooleanAndRemove(K name, boolean defaultValue) {
Boolean v = getBooleanAndRemove(name);
return v != null ? v : defaultValue;
}
@Override
public Byte getByteAndRemove(K name) {
V v = getAndRemove(name);
try {
return v != null ? toByte(name, v) : null;
} catch (RuntimeException ignore) {
return null;
}
}
@Override
public byte getByteAndRemove(K name, byte defaultValue) {
Byte v = getByteAndRemove(name);
return v != null ? v : defaultValue;
}
@Override
public Character getCharAndRemove(K name) {
V v = getAndRemove(name);
try {
return v != null ? toChar(name, v) : null;
} catch (RuntimeException ignore) {
return null;
}
}
@Override
public char getCharAndRemove(K name, char defaultValue) {
Character v = getCharAndRemove(name);
return v != null ? v : defaultValue;
}
@Override
public Short getShortAndRemove(K name) {
V v = getAndRemove(name);
try {
return v != null ? toShort(name, v) : null;
} catch (RuntimeException ignore) {
return null;
}
}
@Override
public short getShortAndRemove(K name, short defaultValue) {
Short v = getShortAndRemove(name);
return v != null ? v : defaultValue;
}
@Override
public Integer getIntAndRemove(K name) {
V v = getAndRemove(name);
try {
return v != null ? toInt(name, v) : null;
} catch (RuntimeException ignore) {
return null;
}
}
@Override
public int getIntAndRemove(K name, int defaultValue) {
Integer v = getIntAndRemove(name);
return v != null ? v : defaultValue;
}
@Override
public Long getLongAndRemove(K name) {
V v = getAndRemove(name);
try {
return v != null ? toLong(name, v) : null;
} catch (RuntimeException ignore) {
return null;
}
}
@Override
public long getLongAndRemove(K name, long defaultValue) {
Long v = getLongAndRemove(name);
return v != null ? v : defaultValue;
}
@Override
public Float getFloatAndRemove(K name) {
V v = getAndRemove(name);
try {
return v != null ? toFloat(name, v) : null;
} catch (RuntimeException ignore) {
return null;
}
}
@Override
public float getFloatAndRemove(K name, float defaultValue) {
Float v = getFloatAndRemove(name);
return v != null ? v : defaultValue;
}
@Override
public Double getDoubleAndRemove(K name) {
V v = getAndRemove(name);
try {
return v != null ? toDouble(name, v) : null;
} catch (RuntimeException ignore) {
return null;
}
}
@Override
public double getDoubleAndRemove(K name, double defaultValue) {
Double v = getDoubleAndRemove(name);
return v != null ? v : defaultValue;
}
@Override
public Long getTimeMillisAndRemove(K name) {
V v = getAndRemove(name);
try {
return v != null ? toTimeMillis(name, v) : null;
} catch (RuntimeException ignore) {
return null;
}
}
@Override
public long getTimeMillisAndRemove(K name, long defaultValue) {
Long v = getTimeMillisAndRemove(name);
return v != null ? v : defaultValue;
}
@SuppressWarnings("unchecked")
@Override
public boolean equals(Object o) {
if (!(o instanceof Headers)) {
return false;
}
return equals((Headers) o, JAVA_HASHER);
}
@SuppressWarnings("unchecked")
@Override
public int hashCode() {
return hashCode(JAVA_HASHER);
}
/**
* Test this object for equality against {@code h2}.
* @param h2 The object to check equality for.
* @param valueHashingStrategy Defines how values will be compared for equality.
* @return {@code true} if this object equals {@code h2} given {@code valueHashingStrategy}.
* {@code false} otherwise.
*/
public final boolean equals(Headers h2, HashingStrategy valueHashingStrategy) {
if (h2.size() != size()) {
return false;
}
if (this == h2) {
return true;
}
for (K name : names()) {
List otherValues = h2.getAll(name);
List values = getAll(name);
if (otherValues.size() != values.size()) {
return false;
}
for (int i = 0; i < otherValues.size(); i++) {
if (!valueHashingStrategy.equals(otherValues.get(i), values.get(i))) {
return false;
}
}
}
return true;
}
/**
* Generate a hash code for this object given a {@link HashingStrategy} to generate hash codes for
* individual values.
* @param valueHashingStrategy Defines how values will be hashed.
*/
public final int hashCode(HashingStrategy valueHashingStrategy) {
int result = HASH_CODE_SEED;
for (K name : names()) {
result = 31 * result + hashingStrategy.hashCode(name);
List values = getAll(name);
for (int i = 0; i < values.size(); ++i) {
result = 31 * result + valueHashingStrategy.hashCode(values.get(i));
}
}
return result;
}
@Override
public String toString() {
return HeadersUtils.toString(getClass(), iterator(), size());
}
/**
* Call out to the given {@link NameValidator} to validate the given name.
*
* @param validator the validator to use
* @param forAdd {@code true } if this validation is for adding to the headers, or {@code false} if this is for
* setting (overwriting) the given header.
* @param name the name to validate.
*/
protected void validateName(NameValidator validator, boolean forAdd, K name) {
validator.validateName(name);
}
protected void validateValue(ValueValidator validator, K name, V value) {
try {
validator.validate(value);
} catch (IllegalArgumentException e) {
throw new IllegalArgumentException("Validation failed for header '" + name + "'", e);
}
}
protected HeaderEntry newHeaderEntry(int h, K name, V value, HeaderEntry next) {
return new HeaderEntry(h, name, value, next, head);
}
protected ValueConverter valueConverter() {
return valueConverter;
}
protected NameValidator nameValidator() {
return nameValidator;
}
protected ValueValidator valueValidator() {
return valueValidator;
}
private int index(int hash) {
return hash & hashMask;
}
private void add0(int h, int i, K name, V value) {
// Update the hash table.
entries[i] = newHeaderEntry(h, name, value, entries[i]);
++size;
}
/**
* @return the first value inserted whose hash code equals {@code h} and whose name is equal to {@code name}.
*/
private V remove0(int h, int i, K name) {
HeaderEntry e = entries[i];
if (e == null) {
return null;
}
V value = null;
HeaderEntry next = e.next;
while (next != null) {
if (next.hash == h && hashingStrategy.equals(name, next.key)) {
value = next.value;
e.next = next.next;
next.remove();
--size;
} else {
e = next;
}
next = e.next;
}
e = entries[i];
if (e.hash == h && hashingStrategy.equals(name, e.key)) {
if (value == null) {
value = e.value;
}
entries[i] = e.next;
e.remove();
--size;
}
return value;
}
HeaderEntry remove0(HeaderEntry entry, HeaderEntry previous) {
int i = index(entry.hash);
HeaderEntry firstEntry = entries[i];
if (firstEntry == entry) {
entries[i] = entry.next;
previous = entries[i];
} else if (previous == null) {
// If we don't have any existing starting point, then start from the beginning.
previous = firstEntry;
HeaderEntry next = firstEntry.next;
while (next != null && next != entry) {
previous = next;
next = next.next;
}
assert next != null: "Entry not found in its hash bucket: " + entry;
previous.next = entry.next;
} else {
previous.next = entry.next;
}
entry.remove();
--size;
return previous;
}
@SuppressWarnings("unchecked")
private T thisT() {
return (T) this;
}
private V fromObject(K name, Object value) {
try {
return valueConverter.convertObject(checkNotNull(value, "value"));
} catch (IllegalArgumentException e) {
throw new IllegalArgumentException("Failed to convert object value for header '" + name + '\'', e);
}
}
private V fromBoolean(K name, boolean value) {
try {
return valueConverter.convertBoolean(value);
} catch (IllegalArgumentException e) {
throw new IllegalArgumentException("Failed to convert boolean value for header '" + name + '\'', e);
}
}
private V fromByte(K name, byte value) {
try {
return valueConverter.convertByte(value);
} catch (IllegalArgumentException e) {
throw new IllegalArgumentException("Failed to convert byte value for header '" + name + '\'', e);
}
}
private V fromChar(K name, char value) {
try {
return valueConverter.convertChar(value);
} catch (IllegalArgumentException e) {
throw new IllegalArgumentException("Failed to convert char value for header '" + name + '\'', e);
}
}
private V fromShort(K name, short value) {
try {
return valueConverter.convertShort(value);
} catch (IllegalArgumentException e) {
throw new IllegalArgumentException("Failed to convert short value for header '" + name + '\'', e);
}
}
private V fromInt(K name, int value) {
try {
return valueConverter.convertInt(value);
} catch (IllegalArgumentException e) {
throw new IllegalArgumentException("Failed to convert int value for header '" + name + '\'', e);
}
}
private V fromLong(K name, long value) {
try {
return valueConverter.convertLong(value);
} catch (IllegalArgumentException e) {
throw new IllegalArgumentException("Failed to convert long value for header '" + name + '\'', e);
}
}
private V fromFloat(K name, float value) {
try {
return valueConverter.convertFloat(value);
} catch (IllegalArgumentException e) {
throw new IllegalArgumentException("Failed to convert float value for header '" + name + '\'', e);
}
}
private V fromDouble(K name, double value) {
try {
return valueConverter.convertDouble(value);
} catch (IllegalArgumentException e) {
throw new IllegalArgumentException("Failed to convert double value for header '" + name + '\'', e);
}
}
private V fromTimeMillis(K name, long value) {
try {
return valueConverter.convertTimeMillis(value);
} catch (IllegalArgumentException e) {
throw new IllegalArgumentException("Failed to convert millsecond value for header '" + name + '\'', e);
}
}
private boolean toBoolean(K name, V value) {
try {
return valueConverter.convertToBoolean(value);
} catch (IllegalArgumentException e) {
throw new IllegalArgumentException("Failed to convert header value to boolean for header '" + name + '\'');
}
}
private byte toByte(K name, V value) {
try {
return valueConverter.convertToByte(value);
} catch (IllegalArgumentException e) {
throw new IllegalArgumentException("Failed to convert header value to byte for header '" + name + '\'');
}
}
private char toChar(K name, V value) {
try {
return valueConverter.convertToChar(value);
} catch (IllegalArgumentException e) {
throw new IllegalArgumentException("Failed to convert header value to char for header '" + name + '\'');
}
}
private short toShort(K name, V value) {
try {
return valueConverter.convertToShort(value);
} catch (IllegalArgumentException e) {
throw new IllegalArgumentException("Failed to convert header value to short for header '" + name + '\'');
}
}
private int toInt(K name, V value) {
try {
return valueConverter.convertToInt(value);
} catch (IllegalArgumentException e) {
throw new IllegalArgumentException("Failed to convert header value to int for header '" + name + '\'');
}
}
private long toLong(K name, V value) {
try {
return valueConverter.convertToLong(value);
} catch (IllegalArgumentException e) {
throw new IllegalArgumentException("Failed to convert header value to long for header '" + name + '\'');
}
}
private float toFloat(K name, V value) {
try {
return valueConverter.convertToFloat(value);
} catch (IllegalArgumentException e) {
throw new IllegalArgumentException("Failed to convert header value to float for header '" + name + '\'');
}
}
private double toDouble(K name, V value) {
try {
return valueConverter.convertToDouble(value);
} catch (IllegalArgumentException e) {
throw new IllegalArgumentException("Failed to convert header value to double for header '" + name + '\'');
}
}
private long toTimeMillis(K name, V value) {
try {
return valueConverter.convertToTimeMillis(value);
} catch (IllegalArgumentException e) {
throw new IllegalArgumentException(
"Failed to convert header value to millsecond for header '" + name + '\'');
}
}
/**
* Returns a deep copy of this instance.
*/
public DefaultHeaders copy() {
DefaultHeaders copy = new DefaultHeaders(
hashingStrategy, valueConverter, nameValidator, entries.length);
copy.addImpl(this);
return copy;
}
private final class HeaderIterator implements Iterator> {
private HeaderEntry current = head;
@Override
public boolean hasNext() {
return current.after != head;
}
@Override
public Entry next() {
current = current.after;
if (current == head) {
throw new NoSuchElementException();
}
return current;
}
@Override
public void remove() {
throw new UnsupportedOperationException("read only");
}
}
private final class ValueIterator implements Iterator {
private final K name;
private final int hash;
private HeaderEntry removalPrevious;
private HeaderEntry previous;
private HeaderEntry next;
ValueIterator(K name) {
this.name = checkNotNull(name, "name");
hash = hashingStrategy.hashCode(name);
calculateNext(entries[index(hash)]);
}
@Override
public boolean hasNext() {
return next != null;
}
@Override
public V next() {
if (!hasNext()) {
throw new NoSuchElementException();
}
if (previous != null) {
removalPrevious = previous;
}
previous = next;
calculateNext(next.next);
return previous.value;
}
@Override
public void remove() {
if (previous == null) {
throw new IllegalStateException();
}
removalPrevious = remove0(previous, removalPrevious);
previous = null;
}
private void calculateNext(HeaderEntry entry) {
while (entry != null) {
if (entry.hash == hash && hashingStrategy.equals(name, entry.key)) {
next = entry;
return;
}
entry = entry.next;
}
next = null;
}
}
protected static class HeaderEntry implements Entry {
protected final int hash;
protected final K key;
protected V value;
/**
* In bucket linked list
*/
protected HeaderEntry next;
/**
* Overall insertion order linked list
*/
protected HeaderEntry before, after;
protected HeaderEntry(int hash, K key) {
this.hash = hash;
this.key = key;
}
HeaderEntry(int hash, K key, V value, HeaderEntry next, HeaderEntry head) {
this.hash = hash;
this.key = key;
this.value = value;
this.next = next;
after = head;
before = head.before;
pointNeighborsToThis();
}
HeaderEntry() {
hash = -1;
key = null;
before = after = this;
}
protected final void pointNeighborsToThis() {
before.after = this;
after.before = this;
}
public final HeaderEntry before() {
return before;
}
public final HeaderEntry after() {
return after;
}
protected void remove() {
before.after = after;
after.before = before;
}
@Override
public final K getKey() {
return key;
}
@Override
public final V getValue() {
return value;
}
@Override
public final V setValue(V value) {
checkNotNull(value, "value");
V oldValue = this.value;
this.value = value;
return oldValue;
}
@Override
public final String toString() {
return key.toString() + '=' + value.toString();
}
@Override
public boolean equals(Object o) {
if (!(o instanceof Map.Entry)) {
return false;
}
Entry other = (Entry) o;
return (getKey() == null ? other.getKey() == null : getKey().equals(other.getKey())) &&
(getValue() == null ? other.getValue() == null : getValue().equals(other.getValue()));
}
@Override
public int hashCode() {
return (key == null ? 0 : key.hashCode()) ^ (value == null ? 0 : value.hashCode());
}
}
}
