SpeedCash v6.5.1482 - Metadata.java 源代码

package io.grpc;

import com.facebook.gamingservices.cloudgaming.internal.SDKConstants;
import com.google.common.annotations.VisibleForTesting;
import com.google.common.base.Charsets;
import com.google.common.base.Preconditions;
import com.google.common.io.BaseEncoding;
import com.google.common.io.ByteStreams;
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.nio.ByteBuffer;
import java.nio.charset.Charset;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.BitSet;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Locale;
import java.util.NoSuchElementException;
import java.util.Set;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.annotation.Nullable;
import javax.annotation.concurrent.Immutable;
import javax.annotation.concurrent.NotThreadSafe;

@NotThreadSafe
public final class Metadata {
    public static final String BINARY_HEADER_SUFFIX = "-bin";
    public Object[] a;
    public int b;
    public static final Logger c = Logger.getLogger(Metadata.class.getName());
    public static final BinaryMarshaller<byte[]> BINARY_BYTE_MARSHALLER = new a();
    public static final AsciiMarshaller<String> ASCII_STRING_MARSHALLER = new b();
    public static final BaseEncoding d = BaseEncoding.base64().omitPadding();

    public interface AsciiMarshaller<T> {
        T parseAsciiString(String str);

        String toAsciiString(T t);
    }

    public interface BinaryMarshaller<T> {
        T parseBytes(byte[] bArr);

        byte[] toBytes(T t);
    }

    @ExperimentalApi("https://github.com/grpc/grpc-java/issues/6575")
    public interface BinaryStreamMarshaller<T> {
        T parseStream(InputStream inputStream);

        InputStream toStream(T t);
    }

    @Immutable
    public static abstract class Key<T> {
        public static final BitSet e = b();
        public final String a;
        public final String b;
        public final byte[] c;
        public final Object d;

        public Key(String str, boolean z, Object obj, a aVar) {
            this(str, z, obj);
        }

        public static BitSet b() {
            BitSet bitSet = new BitSet(127);
            bitSet.set(45);
            bitSet.set(95);
            bitSet.set(46);
            for (char c = '0'; c <= '9'; c = (char) (c + 1)) {
                bitSet.set(c);
            }
            for (char c2 = 'a'; c2 <= 'z'; c2 = (char) (c2 + 1)) {
                bitSet.set(c2);
            }
            return bitSet;
        }

        public static <T> Key<T> d(String str, boolean z, AsciiMarshaller<T> asciiMarshaller) {
            return new c(str, z, asciiMarshaller, null);
        }

        public static <T> Key<T> e(String str, boolean z, i<T> iVar) {
            return new h(str, z, iVar, null);
        }

        public static String i(String str, boolean z) {
            Preconditions.checkNotNull(str, "name");
            Preconditions.checkArgument(!str.isEmpty(), "token must have at least 1 tchar");
            if (str.equals("connection")) {
                Metadata.c.log(Level.WARNING, "Metadata key is 'Connection', which should not be used. That is used by HTTP/1 for connection-specific headers which are not to be forwarded. There is probably an HTTP/1 conversion bug. Simply removing the Connection header is not enough; you should remove all headers it references as well. See RFC 7230 section 6.1", (Throwable) new RuntimeException("exception to show backtrace"));
            }
            for (int i = 0; i < str.length(); i++) {
                char charAt = str.charAt(i);
                if (!z || charAt != ':' || i != 0) {
                    Preconditions.checkArgument(e.get(charAt), "Invalid character '%s' in key name '%s'", charAt, str);
                }
            }
            return str;
        }

        public static <T> Key<T> of(String str, BinaryMarshaller<T> binaryMarshaller) {
            return new d(str, binaryMarshaller, null);
        }

        @VisibleForTesting
        public byte[] a() {
            return this.c;
        }

        @Nullable
        public final <M> M c(Class<M> cls) {
            if (cls.isInstance(this.d)) {
                return cls.cast(this.d);
            }
            return null;
        }

        public final boolean equals(Object obj) {
            if (this == obj) {
                return true;
            }
            if (obj == null || getClass() != obj.getClass()) {
                return false;
            }
            return this.b.equals(((Key) obj).b);
        }

        public abstract T f(byte[] bArr);

        public boolean g() {
            return false;
        }

        public abstract byte[] h(T t);

        public final int hashCode() {
            return this.b.hashCode();
        }

        public final String name() {
            return this.b;
        }

        public final String originalName() {
            return this.a;
        }

        public String toString() {
            return "Key{name='" + this.b + "'}";
        }

        public Key(String str, boolean z, Object obj) {
            String str2 = (String) Preconditions.checkNotNull(str, "name");
            this.a = str2;
            String i = i(str2.toLowerCase(Locale.ROOT), z);
            this.b = i;
            this.c = i.getBytes(Charsets.US_ASCII);
            this.d = obj;
        }

        @ExperimentalApi("https://github.com/grpc/grpc-java/issues/6575")
        public static <T> Key<T> of(String str, BinaryStreamMarshaller<T> binaryStreamMarshaller) {
            return new f(str, binaryStreamMarshaller, null);
        }

        public static <T> Key<T> of(String str, AsciiMarshaller<T> asciiMarshaller) {
            return d(str, false, asciiMarshaller);
        }
    }

    public class a implements BinaryMarshaller<byte[]> {
        @Override
        public byte[] parseBytes(byte[] bArr) {
            return bArr;
        }

        @Override
        public byte[] toBytes(byte[] bArr) {
            return bArr;
        }
    }

    public class b implements AsciiMarshaller<String> {
        @Override
        public String parseAsciiString(String str) {
            return str;
        }

        @Override
        public String toAsciiString(String str) {
            return str;
        }
    }

    public static class c<T> extends Key<T> {
        public final AsciiMarshaller<T> f;

        public c(String str, boolean z, AsciiMarshaller asciiMarshaller, a aVar) {
            this(str, z, asciiMarshaller);
        }

        @Override
        public T f(byte[] bArr) {
            return this.f.parseAsciiString(new String(bArr, Charsets.US_ASCII));
        }

        @Override
        public byte[] h(T t) {
            return this.f.toAsciiString(t).getBytes(Charsets.US_ASCII);
        }

        public c(String str, boolean z, AsciiMarshaller<T> asciiMarshaller) {
            super(str, z, asciiMarshaller, null);
            Preconditions.checkArgument(!str.endsWith(Metadata.BINARY_HEADER_SUFFIX), "ASCII header is named %s.  Only binary headers may end with %s", str, Metadata.BINARY_HEADER_SUFFIX);
            this.f = (AsciiMarshaller) Preconditions.checkNotNull(asciiMarshaller, "marshaller");
        }
    }

    public static class d<T> extends Key<T> {
        public final BinaryMarshaller<T> f;

        public d(String str, BinaryMarshaller binaryMarshaller, a aVar) {
            this(str, binaryMarshaller);
        }

        @Override
        public T f(byte[] bArr) {
            return this.f.parseBytes(bArr);
        }

        @Override
        public byte[] h(T t) {
            return this.f.toBytes(t);
        }

        public d(String str, BinaryMarshaller<T> binaryMarshaller) {
            super(str, false, binaryMarshaller, null);
            Preconditions.checkArgument(str.endsWith(Metadata.BINARY_HEADER_SUFFIX), "Binary header is named %s. It must end with %s", str, Metadata.BINARY_HEADER_SUFFIX);
            Preconditions.checkArgument(str.length() > 4, "empty key name");
            this.f = (BinaryMarshaller) Preconditions.checkNotNull(binaryMarshaller, "marshaller is null");
        }
    }

    public final class e<T> implements Iterable<T> {
        public final Key<T> a;
        public int b;

        public class a implements Iterator<T> {
            public boolean a = true;
            public int b;

            public a() {
                this.b = e.this.b;
            }

            @Override
            public boolean hasNext() {
                if (this.a) {
                    return true;
                }
                while (this.b < Metadata.this.b) {
                    e eVar = e.this;
                    if (Metadata.this.g(eVar.a.a(), Metadata.this.o(this.b))) {
                        this.a = true;
                        return true;
                    }
                    this.b++;
                }
                return false;
            }

            @Override
            public T next() {
                if (!hasNext()) {
                    throw new NoSuchElementException();
                }
                this.a = false;
                e eVar = e.this;
                Metadata metadata = Metadata.this;
                int i = this.b;
                this.b = i + 1;
                return (T) metadata.x(i, eVar.a);
            }

            @Override
            public void remove() {
                throw new UnsupportedOperationException();
            }
        }

        public e(Metadata metadata, Key key, int i, a aVar) {
            this(key, i);
        }

        @Override
        public Iterator<T> iterator() {
            return new a();
        }

        public e(Key<T> key, int i) {
            this.a = key;
            this.b = i;
        }
    }

    public static class f<T> extends Key<T> {
        public final BinaryStreamMarshaller<T> f;

        public f(String str, BinaryStreamMarshaller binaryStreamMarshaller, a aVar) {
            this(str, binaryStreamMarshaller);
        }

        @Override
        public T f(byte[] bArr) {
            return this.f.parseStream(new ByteArrayInputStream(bArr));
        }

        @Override
        public boolean g() {
            return true;
        }

        @Override
        public byte[] h(T t) {
            return Metadata.r(this.f.toStream(t));
        }

        public f(String str, BinaryStreamMarshaller<T> binaryStreamMarshaller) {
            super(str, false, binaryStreamMarshaller, null);
            Preconditions.checkArgument(str.endsWith(Metadata.BINARY_HEADER_SUFFIX), "Binary header is named %s. It must end with %s", str, Metadata.BINARY_HEADER_SUFFIX);
            Preconditions.checkArgument(str.length() > 4, "empty key name");
            this.f = (BinaryStreamMarshaller) Preconditions.checkNotNull(binaryStreamMarshaller, "marshaller is null");
        }
    }

    public static final class g<T> {
        public final BinaryStreamMarshaller<T> a;
        public final T b;
        public volatile byte[] c;

        public g(BinaryStreamMarshaller<T> binaryStreamMarshaller, T t) {
            this.a = binaryStreamMarshaller;
            this.b = t;
        }

        public static <T> g<T> a(Key<T> key, T t) {
            return new g<>((BinaryStreamMarshaller) Preconditions.checkNotNull(b(key)), t);
        }

        @Nullable
        public static <T> BinaryStreamMarshaller<T> b(Key<T> key) {
            return (BinaryStreamMarshaller) key.c(BinaryStreamMarshaller.class);
        }

        public byte[] c() {
            if (this.c == null) {
                synchronized (this) {
                    if (this.c == null) {
                        this.c = Metadata.r(e());
                    }
                }
            }
            return this.c;
        }

        public <T2> T2 d(Key<T2> key) {
            BinaryStreamMarshaller b;
            return (!key.g() || (b = b(key)) == null) ? key.f(c()) : (T2) b.parseStream(e());
        }

        public InputStream e() {
            return this.a.toStream(this.b);
        }
    }

    public static final class h<T> extends Key<T> {
        public final i<T> f;

        public h(String str, boolean z, i iVar, a aVar) {
            this(str, z, iVar);
        }

        @Override
        public T f(byte[] bArr) {
            return this.f.parseAsciiString(bArr);
        }

        @Override
        public byte[] h(T t) {
            return this.f.toAsciiString(t);
        }

        public h(String str, boolean z, i<T> iVar) {
            super(str, z, iVar, null);
            Preconditions.checkArgument(!str.endsWith(Metadata.BINARY_HEADER_SUFFIX), "ASCII header is named %s.  Only binary headers may end with %s", str, Metadata.BINARY_HEADER_SUFFIX);
            this.f = (i) Preconditions.checkNotNull(iVar, "marshaller");
        }
    }

    @Immutable
    public interface i<T> {
        T parseAsciiString(byte[] bArr);

        byte[] toAsciiString(T t);
    }

    public Metadata(byte[]... bArr) {
        this(bArr.length / 2, bArr);
    }

    public static byte[] r(InputStream inputStream) {
        try {
            return ByteStreams.toByteArray(inputStream);
        } catch (IOException e2) {
            throw new RuntimeException("failure reading serialized stream", e2);
        }
    }

    public boolean containsKey(Key<?> key) {
        for (int i2 = 0; i2 < this.b; i2++) {
            if (g(key.a(), o(i2))) {
                return true;
            }
        }
        return false;
    }

    @ExperimentalApi("https://github.com/grpc/grpc-java/issues/4691")
    public <T> void discardAll(Key<T> key) {
        if (k()) {
            return;
        }
        int i2 = 0;
        for (int i3 = 0; i3 < this.b; i3++) {
            if (!g(key.a(), o(i3))) {
                n(i2, o(i3));
                t(i2, s(i3));
                i2++;
            }
        }
        Arrays.fill(this.a, i2 * 2, l(), (Object) null);
        this.b = i2;
    }

    public final boolean g(byte[] bArr, byte[] bArr2) {
        return Arrays.equals(bArr, bArr2);
    }

    @Nullable
    public <T> T get(Key<T> key) {
        for (int i2 = this.b - 1; i2 >= 0; i2--) {
            if (g(key.a(), o(i2))) {
                return (T) x(i2, key);
            }
        }
        return null;
    }

    @Nullable
    public <T> Iterable<T> getAll(Key<T> key) {
        int i2 = 0;
        while (true) {
            a aVar = null;
            if (i2 >= this.b) {
                return null;
            }
            if (g(key.a(), o(i2))) {
                return new e(this, key, i2, aVar);
            }
            i2++;
        }
    }

    public final int h() {
        Object[] objArr = this.a;
        if (objArr != null) {
            return objArr.length;
        }
        return 0;
    }

    public final void i(int i2) {
        Object[] objArr = new Object[i2];
        if (!k()) {
            System.arraycopy(this.a, 0, objArr, 0, l());
        }
        this.a = objArr;
    }

    public int j() {
        return this.b;
    }

    public final boolean k() {
        return this.b == 0;
    }

    public Set<String> keys() {
        if (k()) {
            return Collections.emptySet();
        }
        HashSet hashSet = new HashSet(this.b);
        for (int i2 = 0; i2 < this.b; i2++) {
            hashSet.add(new String(o(i2), 0));
        }
        return Collections.unmodifiableSet(hashSet);
    }

    public final int l() {
        return this.b * 2;
    }

    public final void m() {
        if (l() == 0 || l() == h()) {
            i(Math.max(l() * 2, 8));
        }
    }

    public void merge(Metadata metadata) {
        if (metadata.k()) {
            return;
        }
        int h2 = h() - l();
        if (k() || h2 < metadata.l()) {
            i(l() + metadata.l());
        }
        System.arraycopy(metadata.a, 0, this.a, l(), metadata.l());
        this.b += metadata.b;
    }

    public final void n(int i2, byte[] bArr) {
        this.a[i2 * 2] = bArr;
    }

    public final byte[] o(int i2) {
        return (byte[]) this.a[i2 * 2];
    }

    @Nullable
    public byte[][] p() {
        byte[][] bArr = new byte[l()][];
        Object[] objArr = this.a;
        if (objArr instanceof byte[][]) {
            System.arraycopy(objArr, 0, bArr, 0, l());
        } else {
            for (int i2 = 0; i2 < this.b; i2++) {
                int i3 = i2 * 2;
                bArr[i3] = o(i2);
                bArr[i3 + 1] = v(i2);
            }
        }
        return bArr;
    }

    public <T> void put(Key<T> key, T t) {
        Preconditions.checkNotNull(key, SDKConstants.PARAM_KEY);
        Preconditions.checkNotNull(t, "value");
        m();
        n(this.b, key.a());
        if (key.g()) {
            t(this.b, g.a(key, t));
        } else {
            u(this.b, key.h(t));
        }
        this.b++;
    }

    @Nullable
    public Object[] q() {
        Object[] objArr = new Object[l()];
        for (int i2 = 0; i2 < this.b; i2++) {
            int i3 = i2 * 2;
            objArr[i3] = o(i2);
            objArr[i3 + 1] = w(i2);
        }
        return objArr;
    }

    public <T> boolean remove(Key<T> key, T t) {
        Preconditions.checkNotNull(key, SDKConstants.PARAM_KEY);
        Preconditions.checkNotNull(t, "value");
        for (int i2 = 0; i2 < this.b; i2++) {
            if (g(key.a(), o(i2)) && t.equals(x(i2, key))) {
                int i3 = i2 * 2;
                int i4 = (i2 + 1) * 2;
                int l = l() - i4;
                Object[] objArr = this.a;
                System.arraycopy(objArr, i4, objArr, i3, l);
                int i5 = this.b - 1;
                this.b = i5;
                n(i5, null);
                u(this.b, null);
                return true;
            }
        }
        return false;
    }

    public <T> Iterable<T> removeAll(Key<T> key) {
        if (k()) {
            return null;
        }
        int i2 = 0;
        ArrayList arrayList = null;
        for (int i3 = 0; i3 < this.b; i3++) {
            if (g(key.a(), o(i3))) {
                if (arrayList == null) {
                    arrayList = new ArrayList();
                }
                arrayList.add(x(i3, key));
            } else {
                n(i2, o(i3));
                t(i2, s(i3));
                i2++;
            }
        }
        Arrays.fill(this.a, i2 * 2, l(), (Object) null);
        this.b = i2;
        return arrayList;
    }

    public final Object s(int i2) {
        return this.a[(i2 * 2) + 1];
    }

    public final void t(int i2, Object obj) {
        if (this.a instanceof byte[][]) {
            i(h());
        }
        this.a[(i2 * 2) + 1] = obj;
    }

    public String toString() {
        StringBuilder sb = new StringBuilder("Metadata(");
        for (int i2 = 0; i2 < this.b; i2++) {
            if (i2 != 0) {
                sb.append(',');
            }
            byte[] o = o(i2);
            Charset charset = Charsets.US_ASCII;
            String str = new String(o, charset);
            sb.append(str);
            sb.append('=');
            if (str.endsWith(BINARY_HEADER_SUFFIX)) {
                sb.append(d.encode(v(i2)));
            } else {
                sb.append(new String(v(i2), charset));
            }
        }
        sb.append(')');
        return sb.toString();
    }

    public final void u(int i2, byte[] bArr) {
        this.a[(i2 * 2) + 1] = bArr;
    }

    public final byte[] v(int i2) {
        Object s = s(i2);
        return s instanceof byte[] ? (byte[]) s : ((g) s).c();
    }

    public final Object w(int i2) {
        Object s = s(i2);
        return s instanceof byte[] ? s : ((g) s).e();
    }

    public final <T> T x(int i2, Key<T> key) {
        Object s = s(i2);
        return s instanceof byte[] ? key.f((byte[]) s) : (T) ((g) s).d(key);
    }

    public Metadata(int i2, byte[]... bArr) {
        this(i2, (Object[]) bArr);
    }

    public Metadata(int i2, Object[] objArr) {
        this.b = i2;
        this.a = objArr;
    }

    public Metadata() {
    }

    public void merge(Metadata metadata, Set<Key<?>> set) {
        Preconditions.checkNotNull(metadata, "other");
        HashMap hashMap = new HashMap(set.size());
        for (Key<?> key : set) {
            hashMap.put(ByteBuffer.wrap(key.a()), key);
        }
        for (int i2 = 0; i2 < metadata.b; i2++) {
            if (hashMap.containsKey(ByteBuffer.wrap(metadata.o(i2)))) {
                m();
                n(this.b, metadata.o(i2));
                t(this.b, metadata.s(i2));
                this.b++;
            }
        }
    }
}