package io.netty.handler.codec;

import io.netty.handler.codec.Headers;
import io.netty.util.HashingStrategy;
import io.netty.util.concurrent.FastThreadLocal;
import io.netty.util.internal.MathUtil;
import io.netty.util.internal.ObjectUtil;
import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Arrays;
import java.util.Collections;
import java.util.Date;
import java.util.Iterator;
import java.util.LinkedHashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.NoSuchElementException;
import java.util.Set;
import java.util.TimeZone;

/* JADX INFO: loaded from: classes.dex */
public class DefaultHeaders<K, V, T extends Headers<K, V, T>> implements Headers<K, V, T> {
    static final int HASH_CODE_SEED = -1028477387;
    private final HeaderEntry<K, V>[] entries;
    private final byte hashMask;
    private final HashingStrategy<K> hashingStrategy;
    protected final HeaderEntry<K, V> head;
    private final NameValidator<K> nameValidator;
    int size;
    private final ValueConverter<V> valueConverter;

    public static final class HeaderDateFormat {
        private static final FastThreadLocal<HeaderDateFormat> dateFormatThreadLocal = new FastThreadLocal<HeaderDateFormat>() { // from class: io.netty.handler.codec.DefaultHeaders.HeaderDateFormat.1
            /* JADX INFO: Access modifiers changed from: protected */
            /* JADX WARN: Can't rename method to resolve collision */
            @Override // io.netty.util.concurrent.FastThreadLocal
            public HeaderDateFormat initialValue() {
                return new HeaderDateFormat();
            }
        };
        private final DateFormat dateFormat1;
        private final DateFormat dateFormat2;
        private final DateFormat dateFormat3;

        static HeaderDateFormat get() {
            return dateFormatThreadLocal.get();
        }

        long parse(String str) throws ParseException {
            Date date = this.dateFormat1.parse(str);
            if (date == null) {
                date = this.dateFormat2.parse(str);
            }
            if (date == null) {
                date = this.dateFormat3.parse(str);
            }
            if (date != null) {
                return date.getTime();
            }
            throw new ParseException(str, 0);
        }

        private HeaderDateFormat() {
            this.dateFormat1 = new SimpleDateFormat("E, dd MMM yyyy HH:mm:ss z", Locale.ENGLISH);
            this.dateFormat2 = new SimpleDateFormat("E, dd-MMM-yy HH:mm:ss z", Locale.ENGLISH);
            this.dateFormat3 = new SimpleDateFormat("E MMM d HH:mm:ss yyyy", Locale.ENGLISH);
            TimeZone timeZone = TimeZone.getTimeZone("GMT");
            this.dateFormat1.setTimeZone(timeZone);
            this.dateFormat2.setTimeZone(timeZone);
            this.dateFormat3.setTimeZone(timeZone);
        }
    }

    private final class HeaderIterator implements Iterator<Map.Entry<K, V>> {
        private HeaderEntry<K, V> current;

        private HeaderIterator() {
            this.current = DefaultHeaders.this.head;
        }

        @Override // java.util.Iterator
        public boolean hasNext() {
            return this.current.after != DefaultHeaders.this.head;
        }

        @Override // java.util.Iterator
        public void remove() {
            throw new UnsupportedOperationException("read-only iterator");
        }

        @Override // java.util.Iterator
        public Map.Entry<K, V> next() {
            HeaderEntry<K, V> headerEntry = this.current.after;
            this.current = headerEntry;
            if (headerEntry != DefaultHeaders.this.head) {
                return headerEntry;
            }
            throw new NoSuchElementException();
        }
    }

    public interface NameValidator<K> {
        public static final NameValidator NOT_NULL = new NameValidator() { // from class: io.netty.handler.codec.DefaultHeaders.NameValidator.1
            @Override // io.netty.handler.codec.DefaultHeaders.NameValidator
            public void validateName(Object obj) {
                ObjectUtil.checkNotNull(obj, "name");
            }
        };

        void validateName(K k2);
    }

    public DefaultHeaders(ValueConverter<V> valueConverter) {
        this(HashingStrategy.JAVA_HASHER, valueConverter);
    }

    private void add0(int i2, int i3, K k2, V v) {
        HeaderEntry<K, V>[] headerEntryArr = this.entries;
        headerEntryArr[i3] = newHeaderEntry(i2, k2, v, headerEntryArr[i3]);
        this.size++;
    }

    private int index(int i2) {
        return i2 & this.hashMask;
    }

    private V remove0(int i2, int i3, K k2) {
        HeaderEntry<K, V> headerEntry = this.entries[i3];
        V v = null;
        if (headerEntry == null) {
            return null;
        }
        for (HeaderEntry<K, V> headerEntry2 = headerEntry.next; headerEntry2 != null; headerEntry2 = headerEntry.next) {
            if (headerEntry2.hash == i2 && this.hashingStrategy.equals(k2, headerEntry2.key)) {
                v = headerEntry2.value;
                headerEntry.next = headerEntry2.next;
                headerEntry2.remove();
                this.size--;
            } else {
                headerEntry = headerEntry2;
            }
        }
        HeaderEntry<K, V> headerEntry3 = this.entries[i3];
        if (headerEntry3.hash == i2 && this.hashingStrategy.equals(k2, headerEntry3.key)) {
            if (v == null) {
                v = headerEntry3.value;
            }
            this.entries[i3] = headerEntry3.next;
            headerEntry3.remove();
            this.size--;
        }
        return v;
    }

    private T thisT() {
        return this;
    }

    @Override // io.netty.handler.codec.Headers
    public T add(K k2, V v) {
        this.nameValidator.validateName(k2);
        ObjectUtil.checkNotNull(v, "value");
        int iHashCode = this.hashingStrategy.hashCode(k2);
        add0(iHashCode, index(iHashCode), k2, v);
        return (T) thisT();
    }

    @Override // io.netty.handler.codec.Headers
    public T addBoolean(K k2, boolean z) {
        return (T) add(k2, this.valueConverter.convertBoolean(z));
    }

    @Override // io.netty.handler.codec.Headers
    public T addByte(K k2, byte b) {
        return (T) add(k2, this.valueConverter.convertByte(b));
    }

    @Override // io.netty.handler.codec.Headers
    public T addChar(K k2, char c2) {
        return (T) add(k2, this.valueConverter.convertChar(c2));
    }

    @Override // io.netty.handler.codec.Headers
    public T addDouble(K k2, double d2) {
        return (T) add(k2, this.valueConverter.convertDouble(d2));
    }

    @Override // io.netty.handler.codec.Headers
    public T addFloat(K k2, float f2) {
        return (T) add(k2, this.valueConverter.convertFloat(f2));
    }

    protected void addImpl(Headers<? extends K, ? extends V, ?> headers) {
        if (!(headers instanceof DefaultHeaders)) {
            for (Map.Entry<? extends K, ? extends V> entry : headers) {
                add(entry.getKey(), entry.getValue());
            }
            return;
        }
        DefaultHeaders defaultHeaders = (DefaultHeaders) headers;
        HeaderEntry<K, V> headerEntry = defaultHeaders.head.after;
        if (defaultHeaders.hashingStrategy == this.hashingStrategy && defaultHeaders.nameValidator == this.nameValidator) {
            while (headerEntry != defaultHeaders.head) {
                int i2 = headerEntry.hash;
                add0(i2, index(i2), headerEntry.key, headerEntry.value);
                headerEntry = headerEntry.after;
            }
        } else {
            while (headerEntry != defaultHeaders.head) {
                add(headerEntry.key, headerEntry.value);
                headerEntry = headerEntry.after;
            }
        }
    }

    @Override // io.netty.handler.codec.Headers
    public T addInt(K k2, int i2) {
        return (T) add(k2, this.valueConverter.convertInt(i2));
    }

    @Override // io.netty.handler.codec.Headers
    public T addLong(K k2, long j2) {
        return (T) add(k2, this.valueConverter.convertLong(j2));
    }

    @Override // io.netty.handler.codec.Headers
    public T addObject(K k2, Object obj) {
        return (T) add(k2, this.valueConverter.convertObject(ObjectUtil.checkNotNull(obj, "value")));
    }

    @Override // io.netty.handler.codec.Headers
    public T addShort(K k2, short s) {
        return (T) add(k2, this.valueConverter.convertShort(s));
    }

    @Override // io.netty.handler.codec.Headers
    public T addTimeMillis(K k2, long j2) {
        return (T) add(k2, this.valueConverter.convertTimeMillis(j2));
    }

    @Override // io.netty.handler.codec.Headers
    public T clear() {
        Arrays.fill(this.entries, (Object) null);
        HeaderEntry<K, V> headerEntry = this.head;
        headerEntry.after = headerEntry;
        headerEntry.before = headerEntry;
        this.size = 0;
        return (T) thisT();
    }

    @Override // io.netty.handler.codec.Headers
    public boolean contains(K k2) {
        return get(k2) != null;
    }

    @Override // io.netty.handler.codec.Headers
    public boolean containsBoolean(K k2, boolean z) {
        return contains(k2, this.valueConverter.convertBoolean(z));
    }

    @Override // io.netty.handler.codec.Headers
    public boolean containsByte(K k2, byte b) {
        return contains(k2, this.valueConverter.convertByte(b));
    }

    @Override // io.netty.handler.codec.Headers
    public boolean containsChar(K k2, char c2) {
        return contains(k2, this.valueConverter.convertChar(c2));
    }

    @Override // io.netty.handler.codec.Headers
    public boolean containsDouble(K k2, double d2) {
        return contains(k2, this.valueConverter.convertDouble(d2));
    }

    @Override // io.netty.handler.codec.Headers
    public boolean containsFloat(K k2, float f2) {
        return contains(k2, this.valueConverter.convertFloat(f2));
    }

    @Override // io.netty.handler.codec.Headers
    public boolean containsInt(K k2, int i2) {
        return contains(k2, this.valueConverter.convertInt(i2));
    }

    @Override // io.netty.handler.codec.Headers
    public boolean containsLong(K k2, long j2) {
        return contains(k2, this.valueConverter.convertLong(j2));
    }

    @Override // io.netty.handler.codec.Headers
    public boolean containsObject(K k2, Object obj) {
        return contains(k2, this.valueConverter.convertObject(ObjectUtil.checkNotNull(obj, "value")));
    }

    @Override // io.netty.handler.codec.Headers
    public boolean containsShort(K k2, short s) {
        return contains(k2, this.valueConverter.convertShort(s));
    }

    @Override // io.netty.handler.codec.Headers
    public boolean containsTimeMillis(K k2, long j2) {
        return contains(k2, this.valueConverter.convertTimeMillis(j2));
    }

    public boolean equals(Object obj) {
        if (obj instanceof Headers) {
            return equals((Headers) obj, HashingStrategy.JAVA_HASHER);
        }
        return false;
    }

    @Override // io.netty.handler.codec.Headers
    public V get(K k2) {
        ObjectUtil.checkNotNull(k2, "name");
        int iHashCode = this.hashingStrategy.hashCode(k2);
        V v = null;
        for (HeaderEntry<K, V> headerEntry = this.entries[index(iHashCode)]; headerEntry != null; headerEntry = headerEntry.next) {
            if (headerEntry.hash == iHashCode && this.hashingStrategy.equals(k2, headerEntry.key)) {
                v = headerEntry.value;
            }
        }
        return v;
    }

    @Override // io.netty.handler.codec.Headers
    public List<V> getAll(K k2) {
        ObjectUtil.checkNotNull(k2, "name");
        LinkedList linkedList = new LinkedList();
        int iHashCode = this.hashingStrategy.hashCode(k2);
        for (HeaderEntry<K, V> headerEntry = this.entries[index(iHashCode)]; headerEntry != null; headerEntry = headerEntry.next) {
            if (headerEntry.hash == iHashCode && this.hashingStrategy.equals(k2, headerEntry.key)) {
                linkedList.addFirst(headerEntry.getValue());
            }
        }
        return linkedList;
    }

    @Override // io.netty.handler.codec.Headers
    public List<V> getAllAndRemove(K k2) {
        List<V> all = getAll(k2);
        remove(k2);
        return all;
    }

    /* JADX WARN: Multi-variable type inference failed */
    @Override // io.netty.handler.codec.Headers
    public V getAndRemove(K k2) {
        int iHashCode = this.hashingStrategy.hashCode(k2);
        return (V) remove0(iHashCode, index(iHashCode), ObjectUtil.checkNotNull(k2, "name"));
    }

    @Override // io.netty.handler.codec.Headers
    public Boolean getBoolean(K k2) {
        V v = get(k2);
        if (v != null) {
            return Boolean.valueOf(this.valueConverter.convertToBoolean(v));
        }
        return null;
    }

    @Override // io.netty.handler.codec.Headers
    public Boolean getBooleanAndRemove(K k2) {
        V andRemove = getAndRemove(k2);
        if (andRemove != null) {
            return Boolean.valueOf(this.valueConverter.convertToBoolean(andRemove));
        }
        return null;
    }

    @Override // io.netty.handler.codec.Headers
    public Byte getByte(K k2) {
        V v = get(k2);
        if (v != null) {
            return Byte.valueOf(this.valueConverter.convertToByte(v));
        }
        return null;
    }

    @Override // io.netty.handler.codec.Headers
    public Byte getByteAndRemove(K k2) {
        V andRemove = getAndRemove(k2);
        if (andRemove != null) {
            return Byte.valueOf(this.valueConverter.convertToByte(andRemove));
        }
        return null;
    }

    @Override // io.netty.handler.codec.Headers
    public Character getChar(K k2) {
        V v = get(k2);
        if (v != null) {
            return Character.valueOf(this.valueConverter.convertToChar(v));
        }
        return null;
    }

    @Override // io.netty.handler.codec.Headers
    public Character getCharAndRemove(K k2) {
        V andRemove = getAndRemove(k2);
        if (andRemove == null) {
            return null;
        }
        try {
            return Character.valueOf(this.valueConverter.convertToChar(andRemove));
        } catch (Throwable unused) {
            return null;
        }
    }

    @Override // io.netty.handler.codec.Headers
    public Double getDouble(K k2) {
        V v = get(k2);
        if (v != null) {
            return Double.valueOf(this.valueConverter.convertToDouble(v));
        }
        return null;
    }

    @Override // io.netty.handler.codec.Headers
    public Double getDoubleAndRemove(K k2) {
        V andRemove = getAndRemove(k2);
        if (andRemove != null) {
            return Double.valueOf(this.valueConverter.convertToDouble(andRemove));
        }
        return null;
    }

    @Override // io.netty.handler.codec.Headers
    public Float getFloat(K k2) {
        V v = get(k2);
        if (v != null) {
            return Float.valueOf(this.valueConverter.convertToFloat(v));
        }
        return null;
    }

    @Override // io.netty.handler.codec.Headers
    public Float getFloatAndRemove(K k2) {
        V andRemove = getAndRemove(k2);
        if (andRemove != null) {
            return Float.valueOf(this.valueConverter.convertToFloat(andRemove));
        }
        return null;
    }

    @Override // io.netty.handler.codec.Headers
    public Integer getInt(K k2) {
        V v = get(k2);
        if (v != null) {
            return Integer.valueOf(this.valueConverter.convertToInt(v));
        }
        return null;
    }

    @Override // io.netty.handler.codec.Headers
    public Integer getIntAndRemove(K k2) {
        V andRemove = getAndRemove(k2);
        if (andRemove != null) {
            return Integer.valueOf(this.valueConverter.convertToInt(andRemove));
        }
        return null;
    }

    @Override // io.netty.handler.codec.Headers
    public Long getLong(K k2) {
        V v = get(k2);
        if (v != null) {
            return Long.valueOf(this.valueConverter.convertToLong(v));
        }
        return null;
    }

    @Override // io.netty.handler.codec.Headers
    public Long getLongAndRemove(K k2) {
        V andRemove = getAndRemove(k2);
        if (andRemove != null) {
            return Long.valueOf(this.valueConverter.convertToLong(andRemove));
        }
        return null;
    }

    @Override // io.netty.handler.codec.Headers
    public Short getShort(K k2) {
        V v = get(k2);
        if (v != null) {
            return Short.valueOf(this.valueConverter.convertToShort(v));
        }
        return null;
    }

    @Override // io.netty.handler.codec.Headers
    public Short getShortAndRemove(K k2) {
        V andRemove = getAndRemove(k2);
        if (andRemove != null) {
            return Short.valueOf(this.valueConverter.convertToShort(andRemove));
        }
        return null;
    }

    @Override // io.netty.handler.codec.Headers
    public Long getTimeMillis(K k2) {
        V v = get(k2);
        if (v != null) {
            return Long.valueOf(this.valueConverter.convertToTimeMillis(v));
        }
        return null;
    }

    @Override // io.netty.handler.codec.Headers
    public Long getTimeMillisAndRemove(K k2) {
        V andRemove = getAndRemove(k2);
        if (andRemove != null) {
            return Long.valueOf(this.valueConverter.convertToTimeMillis(andRemove));
        }
        return null;
    }

    public int hashCode() {
        return hashCode(HashingStrategy.JAVA_HASHER);
    }

    @Override // io.netty.handler.codec.Headers
    public boolean isEmpty() {
        HeaderEntry<K, V> headerEntry = this.head;
        return headerEntry == headerEntry.after;
    }

    @Override // io.netty.handler.codec.Headers, java.lang.Iterable
    public Iterator<Map.Entry<K, V>> iterator() {
        return new HeaderIterator();
    }

    @Override // io.netty.handler.codec.Headers
    public Set<K> names() {
        if (isEmpty()) {
            return Collections.emptySet();
        }
        LinkedHashSet linkedHashSet = new LinkedHashSet(size());
        for (HeaderEntry<K, V> headerEntry = this.head.after; headerEntry != this.head; headerEntry = headerEntry.after) {
            linkedHashSet.add(headerEntry.getKey());
        }
        return linkedHashSet;
    }

    protected HeaderEntry<K, V> newHeaderEntry(int i2, K k2, V v, HeaderEntry<K, V> headerEntry) {
        return new HeaderEntry<>(i2, k2, v, headerEntry, this.head);
    }

    @Override // io.netty.handler.codec.Headers
    public boolean remove(K k2) {
        return getAndRemove(k2) != null;
    }

    @Override // io.netty.handler.codec.Headers
    public T set(K k2, V v) {
        this.nameValidator.validateName(k2);
        ObjectUtil.checkNotNull(v, "value");
        int iHashCode = this.hashingStrategy.hashCode(k2);
        int iIndex = index(iHashCode);
        remove0(iHashCode, iIndex, k2);
        add0(iHashCode, iIndex, k2, v);
        return (T) thisT();
    }

    @Override // io.netty.handler.codec.Headers
    public T setAll(Headers<? extends K, ? extends V, ?> headers) {
        if (headers != this) {
            Iterator<? extends K> it = headers.names().iterator();
            while (it.hasNext()) {
                remove(it.next());
            }
            addImpl(headers);
        }
        return (T) thisT();
    }

    @Override // io.netty.handler.codec.Headers
    public T setBoolean(K k2, boolean z) {
        return (T) set(k2, this.valueConverter.convertBoolean(z));
    }

    @Override // io.netty.handler.codec.Headers
    public T setByte(K k2, byte b) {
        return (T) set(k2, this.valueConverter.convertByte(b));
    }

    @Override // io.netty.handler.codec.Headers
    public T setChar(K k2, char c2) {
        return (T) set(k2, this.valueConverter.convertChar(c2));
    }

    @Override // io.netty.handler.codec.Headers
    public T setDouble(K k2, double d2) {
        return (T) set(k2, this.valueConverter.convertDouble(d2));
    }

    @Override // io.netty.handler.codec.Headers
    public T setFloat(K k2, float f2) {
        return (T) set(k2, this.valueConverter.convertFloat(f2));
    }

    @Override // io.netty.handler.codec.Headers
    public T setInt(K k2, int i2) {
        return (T) set(k2, this.valueConverter.convertInt(i2));
    }

    @Override // io.netty.handler.codec.Headers
    public T setLong(K k2, long j2) {
        return (T) set(k2, this.valueConverter.convertLong(j2));
    }

    /* JADX WARN: Multi-variable type inference failed */
    @Override // io.netty.handler.codec.Headers
    public T setObject(K k2, Object obj) {
        ObjectUtil.checkNotNull(obj, "value");
        return (T) set(k2, ObjectUtil.checkNotNull(this.valueConverter.convertObject(obj), "convertedValue"));
    }

    @Override // io.netty.handler.codec.Headers
    public T setShort(K k2, short s) {
        return (T) set(k2, this.valueConverter.convertShort(s));
    }

    @Override // io.netty.handler.codec.Headers
    public T setTimeMillis(K k2, long j2) {
        return (T) set(k2, this.valueConverter.convertTimeMillis(j2));
    }

    @Override // io.netty.handler.codec.Headers
    public int size() {
        return this.size;
    }

    public String toString() {
        StringBuilder sb = new StringBuilder(getClass().getSimpleName());
        sb.append('[');
        String str = "";
        for (K k2 : names()) {
            List<V> all = getAll(k2);
            int i2 = 0;
            while (i2 < all.size()) {
                sb.append(str);
                sb.append(k2);
                sb.append(": ");
                sb.append(all.get(i2));
                i2++;
                str = ", ";
            }
        }
        sb.append(']');
        return sb.toString();
    }

    protected ValueConverter<V> valueConverter() {
        return this.valueConverter;
    }

    public DefaultHeaders(ValueConverter<V> valueConverter, NameValidator<K> nameValidator) {
        this(HashingStrategy.JAVA_HASHER, valueConverter, nameValidator);
    }

    @Override // io.netty.handler.codec.Headers
    public T addObject(K k2, Iterable<?> iterable) {
        Iterator<?> it = iterable.iterator();
        while (it.hasNext()) {
            addObject(k2, it.next());
        }
        return (T) thisT();
    }

    @Override // io.netty.handler.codec.Headers
    public boolean contains(K k2, V v) {
        return contains(k2, v, HashingStrategy.JAVA_HASHER);
    }

    public final int hashCode(HashingStrategy<V> hashingStrategy) {
        int iHashCode = HASH_CODE_SEED;
        for (K k2 : names()) {
            iHashCode = (iHashCode * 31) + this.hashingStrategy.hashCode(k2);
            List<V> all = getAll(k2);
            for (int i2 = 0; i2 < all.size(); i2++) {
                iHashCode = (iHashCode * 31) + hashingStrategy.hashCode(all.get(i2));
            }
        }
        return iHashCode;
    }

    protected static class HeaderEntry<K, V> implements Map.Entry<K, V> {
        protected HeaderEntry<K, V> after;
        protected HeaderEntry<K, V> before;
        protected final int hash;
        protected final K key;
        protected HeaderEntry<K, V> next;
        protected V value;

        protected HeaderEntry(int i2, K k2) {
            this.hash = i2;
            this.key = k2;
        }

        public final HeaderEntry<K, V> after() {
            return this.after;
        }

        public final HeaderEntry<K, V> before() {
            return this.before;
        }

        @Override // java.util.Map.Entry
        public final K getKey() {
            return this.key;
        }

        @Override // java.util.Map.Entry
        public final V getValue() {
            return this.value;
        }

        protected final void pointNeighborsToThis() {
            this.before.after = this;
            this.after.before = this;
        }

        protected void remove() {
            HeaderEntry<K, V> headerEntry = this.before;
            headerEntry.after = this.after;
            this.after.before = headerEntry;
        }

        @Override // java.util.Map.Entry
        public final V setValue(V v) {
            ObjectUtil.checkNotNull(v, "value");
            V v2 = this.value;
            this.value = v;
            return v2;
        }

        public final String toString() {
            return this.key.toString() + '=' + this.value.toString();
        }

        HeaderEntry(int i2, K k2, V v, HeaderEntry<K, V> headerEntry, HeaderEntry<K, V> headerEntry2) {
            this.hash = i2;
            this.key = k2;
            this.value = v;
            this.next = headerEntry;
            this.after = headerEntry2;
            this.before = headerEntry2.before;
            pointNeighborsToThis();
        }

        HeaderEntry() {
            this.hash = -1;
            this.key = null;
            this.after = this;
            this.before = this;
        }
    }

    public DefaultHeaders(HashingStrategy<K> hashingStrategy, ValueConverter<V> valueConverter) {
        this(hashingStrategy, valueConverter, NameValidator.NOT_NULL);
    }

    public final boolean contains(K k2, V v, HashingStrategy<? super V> hashingStrategy) {
        ObjectUtil.checkNotNull(k2, "name");
        int iHashCode = this.hashingStrategy.hashCode(k2);
        for (HeaderEntry<K, V> headerEntry = this.entries[index(iHashCode)]; headerEntry != null; headerEntry = headerEntry.next) {
            if (headerEntry.hash == iHashCode && this.hashingStrategy.equals(k2, headerEntry.key) && hashingStrategy.equals(v, headerEntry.value)) {
                return true;
            }
        }
        return false;
    }

    public final boolean equals(Headers<K, V, ?> headers, HashingStrategy<V> hashingStrategy) {
        if (headers.size() != size()) {
            return false;
        }
        if (this == headers) {
            return true;
        }
        for (K k2 : names()) {
            List<V> all = headers.getAll(k2);
            List<V> all2 = getAll(k2);
            if (all.size() != all2.size()) {
                return false;
            }
            for (int i2 = 0; i2 < all.size(); i2++) {
                if (!hashingStrategy.equals(all.get(i2), all2.get(i2))) {
                    return false;
                }
            }
        }
        return true;
    }

    @Override // io.netty.handler.codec.Headers
    public V getAndRemove(K k2, V v) {
        V andRemove = getAndRemove(k2);
        return andRemove == null ? v : andRemove;
    }

    @Override // io.netty.handler.codec.Headers
    public boolean getBoolean(K k2, boolean z) {
        Boolean bool = getBoolean(k2);
        return bool != null ? bool.booleanValue() : z;
    }

    @Override // io.netty.handler.codec.Headers
    public boolean getBooleanAndRemove(K k2, boolean z) {
        Boolean booleanAndRemove = getBooleanAndRemove(k2);
        return booleanAndRemove != null ? booleanAndRemove.booleanValue() : z;
    }

    @Override // io.netty.handler.codec.Headers
    public byte getByte(K k2, byte b) {
        Byte b2 = getByte(k2);
        return b2 != null ? b2.byteValue() : b;
    }

    @Override // io.netty.handler.codec.Headers
    public byte getByteAndRemove(K k2, byte b) {
        Byte byteAndRemove = getByteAndRemove(k2);
        return byteAndRemove != null ? byteAndRemove.byteValue() : b;
    }

    @Override // io.netty.handler.codec.Headers
    public char getChar(K k2, char c2) {
        Character ch = getChar(k2);
        return ch != null ? ch.charValue() : c2;
    }

    @Override // io.netty.handler.codec.Headers
    public char getCharAndRemove(K k2, char c2) {
        Character charAndRemove = getCharAndRemove(k2);
        return charAndRemove != null ? charAndRemove.charValue() : c2;
    }

    @Override // io.netty.handler.codec.Headers
    public double getDouble(K k2, double d2) {
        Double d3 = getDouble(k2);
        return d3 != null ? d3.doubleValue() : d2;
    }

    @Override // io.netty.handler.codec.Headers
    public double getDoubleAndRemove(K k2, double d2) {
        Double doubleAndRemove = getDoubleAndRemove(k2);
        return doubleAndRemove != null ? doubleAndRemove.doubleValue() : d2;
    }

    @Override // io.netty.handler.codec.Headers
    public float getFloat(K k2, float f2) {
        Float f3 = getFloat(k2);
        return f3 != null ? f3.floatValue() : f2;
    }

    @Override // io.netty.handler.codec.Headers
    public float getFloatAndRemove(K k2, float f2) {
        Float floatAndRemove = getFloatAndRemove(k2);
        return floatAndRemove != null ? floatAndRemove.floatValue() : f2;
    }

    @Override // io.netty.handler.codec.Headers
    public int getInt(K k2, int i2) {
        Integer num = getInt(k2);
        return num != null ? num.intValue() : i2;
    }

    @Override // io.netty.handler.codec.Headers
    public int getIntAndRemove(K k2, int i2) {
        Integer intAndRemove = getIntAndRemove(k2);
        return intAndRemove != null ? intAndRemove.intValue() : i2;
    }

    @Override // io.netty.handler.codec.Headers
    public long getLong(K k2, long j2) {
        Long l = getLong(k2);
        return l != null ? l.longValue() : j2;
    }

    @Override // io.netty.handler.codec.Headers
    public long getLongAndRemove(K k2, long j2) {
        Long longAndRemove = getLongAndRemove(k2);
        return longAndRemove != null ? longAndRemove.longValue() : j2;
    }

    @Override // io.netty.handler.codec.Headers
    public short getShort(K k2, short s) {
        Short sh = getShort(k2);
        return sh != null ? sh.shortValue() : s;
    }

    @Override // io.netty.handler.codec.Headers
    public short getShortAndRemove(K k2, short s) {
        Short shortAndRemove = getShortAndRemove(k2);
        return shortAndRemove != null ? shortAndRemove.shortValue() : s;
    }

    @Override // io.netty.handler.codec.Headers
    public long getTimeMillis(K k2, long j2) {
        Long timeMillis = getTimeMillis(k2);
        return timeMillis != null ? timeMillis.longValue() : j2;
    }

    @Override // io.netty.handler.codec.Headers
    public long getTimeMillisAndRemove(K k2, long j2) {
        Long timeMillisAndRemove = getTimeMillisAndRemove(k2);
        return timeMillisAndRemove != null ? timeMillisAndRemove.longValue() : j2;
    }

    public DefaultHeaders(HashingStrategy<K> hashingStrategy, ValueConverter<V> valueConverter, NameValidator<K> nameValidator) {
        this(hashingStrategy, valueConverter, nameValidator, 16);
    }

    @Override // io.netty.handler.codec.Headers
    public T setObject(K k2, Iterable<?> iterable) {
        Object next;
        this.nameValidator.validateName(k2);
        int iHashCode = this.hashingStrategy.hashCode(k2);
        int iIndex = index(iHashCode);
        remove0(iHashCode, iIndex, k2);
        Iterator<?> it = iterable.iterator();
        while (it.hasNext() && (next = it.next()) != null) {
            add0(iHashCode, iIndex, k2, this.valueConverter.convertObject(next));
        }
        return (T) thisT();
    }

    public DefaultHeaders(HashingStrategy<K> hashingStrategy, ValueConverter<V> valueConverter, NameValidator<K> nameValidator, int i2) {
        this.valueConverter = (ValueConverter) ObjectUtil.checkNotNull(valueConverter, "valueConverter");
        this.nameValidator = (NameValidator) ObjectUtil.checkNotNull(nameValidator, "nameValidator");
        this.hashingStrategy = (HashingStrategy) ObjectUtil.checkNotNull(hashingStrategy, "nameHashingStrategy");
        this.entries = new HeaderEntry[MathUtil.findNextPositivePowerOfTwo(Math.max(2, Math.min(i2, 128)))];
        this.hashMask = (byte) (r2.length - 1);
        this.head = new HeaderEntry<>();
    }

    @Override // io.netty.handler.codec.Headers
    public T addObject(K k2, Object... objArr) {
        for (Object obj : objArr) {
            addObject(k2, obj);
        }
        return (T) thisT();
    }

    @Override // io.netty.handler.codec.Headers
    public T add(K k2, Iterable<? extends V> iterable) {
        this.nameValidator.validateName(k2);
        int iHashCode = this.hashingStrategy.hashCode(k2);
        int iIndex = index(iHashCode);
        Iterator<? extends V> it = iterable.iterator();
        while (it.hasNext()) {
            add0(iHashCode, iIndex, k2, it.next());
        }
        return (T) thisT();
    }

    @Override // io.netty.handler.codec.Headers
    public V get(K k2, V v) {
        V v2 = get(k2);
        return v2 == null ? v : v2;
    }

    @Override // io.netty.handler.codec.Headers
    public T set(K k2, Iterable<? extends V> iterable) {
        V next;
        this.nameValidator.validateName(k2);
        ObjectUtil.checkNotNull(iterable, "values");
        int iHashCode = this.hashingStrategy.hashCode(k2);
        int iIndex = index(iHashCode);
        remove0(iHashCode, iIndex, k2);
        Iterator<? extends V> it = iterable.iterator();
        while (it.hasNext() && (next = it.next()) != null) {
            add0(iHashCode, iIndex, k2, next);
        }
        return (T) thisT();
    }

    @Override // io.netty.handler.codec.Headers
    public T setObject(K k2, Object... objArr) {
        this.nameValidator.validateName(k2);
        int iHashCode = this.hashingStrategy.hashCode(k2);
        int iIndex = index(iHashCode);
        remove0(iHashCode, iIndex, k2);
        for (Object obj : objArr) {
            if (obj == null) {
                break;
            }
            add0(iHashCode, iIndex, k2, this.valueConverter.convertObject(obj));
        }
        return (T) thisT();
    }

    @Override // io.netty.handler.codec.Headers
    public T add(K k2, V... vArr) {
        this.nameValidator.validateName(k2);
        int iHashCode = this.hashingStrategy.hashCode(k2);
        int iIndex = index(iHashCode);
        for (V v : vArr) {
            add0(iHashCode, iIndex, k2, v);
        }
        return (T) thisT();
    }

    @Override // io.netty.handler.codec.Headers
    public T set(K k2, V... vArr) {
        this.nameValidator.validateName(k2);
        ObjectUtil.checkNotNull(vArr, "values");
        int iHashCode = this.hashingStrategy.hashCode(k2);
        int iIndex = index(iHashCode);
        remove0(iHashCode, iIndex, k2);
        for (V v : vArr) {
            if (v == null) {
                break;
            }
            add0(iHashCode, iIndex, k2, v);
        }
        return (T) thisT();
    }

    @Override // io.netty.handler.codec.Headers
    public T add(Headers<? extends K, ? extends V, ?> headers) {
        if (headers != this) {
            addImpl(headers);
            return (T) thisT();
        }
        throw new IllegalArgumentException("can't add to itself.");
    }

    @Override // io.netty.handler.codec.Headers
    public T set(Headers<? extends K, ? extends V, ?> headers) {
        if (headers != this) {
            clear();
            addImpl(headers);
        }
        return (T) thisT();
    }
}