SpeedCash v6.5.1482 - ServerInterceptors.java 源代码

package io.grpc;

import com.google.common.base.Preconditions;
import defpackage.tn3;
import io.grpc.MethodDescriptor;
import io.grpc.ServerCall;
import io.grpc.ServerServiceDefinition;
import io.grpc.ServiceDescriptor;
import java.io.BufferedInputStream;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;

public final class ServerInterceptors {

    public class a implements MethodDescriptor.Marshaller<InputStream> {
        @Override
        public InputStream parse(InputStream inputStream) {
            return inputStream.markSupported() ? inputStream : inputStream instanceof KnownLength ? new d(inputStream) : new BufferedInputStream(inputStream);
        }

        @Override
        public InputStream stream(InputStream inputStream) {
            return inputStream;
        }
    }

    public class b<WReqT, WRespT> implements ServerCallHandler<WReqT, WRespT> {
        public final MethodDescriptor a;
        public final MethodDescriptor b;
        public final ServerCallHandler c;

        public class a<OReqT, ORespT> extends tn3<OReqT, ORespT> {
            public final ServerCall a;

            public a(ServerCall serverCall) {
                this.a = serverCall;
            }

            @Override
            public ServerCall<WReqT, WRespT> delegate() {
                return this.a;
            }

            @Override
            public MethodDescriptor<OReqT, ORespT> getMethodDescriptor() {
                return b.this.a;
            }

            @Override
            public void sendMessage(ORespT orespt) {
                delegate().sendMessage(b.this.b.parseResponse(b.this.a.streamResponse(orespt)));
            }
        }

        public class C0043b extends io.grpc.c<WReqT> {
            public final ServerCall.Listener a;

            public C0043b(ServerCall.Listener listener) {
                this.a = listener;
            }

            @Override
            public ServerCall.Listener<OReqT> delegate() {
                return this.a;
            }

            @Override
            public void onMessage(WReqT wreqt) {
                delegate().onMessage(b.this.a.parseRequest(b.this.b.streamRequest(wreqt)));
            }
        }

        public b(MethodDescriptor methodDescriptor, MethodDescriptor methodDescriptor2, ServerCallHandler serverCallHandler) {
            this.a = methodDescriptor;
            this.b = methodDescriptor2;
            this.c = serverCallHandler;
        }

        @Override
        public ServerCall.Listener<WReqT> startCall(ServerCall<WReqT, WRespT> serverCall, Metadata metadata) {
            return new C0043b(this.c.startCall(new a(serverCall), metadata));
        }
    }

    public static final class c<ReqT, RespT> implements ServerCallHandler<ReqT, RespT> {
        public final ServerInterceptor a;
        public final ServerCallHandler<ReqT, RespT> b;

        public c(ServerInterceptor serverInterceptor, ServerCallHandler<ReqT, RespT> serverCallHandler) {
            this.a = (ServerInterceptor) Preconditions.checkNotNull(serverInterceptor, "interceptor");
            this.b = serverCallHandler;
        }

        public static <ReqT, RespT> c<ReqT, RespT> a(ServerInterceptor serverInterceptor, ServerCallHandler<ReqT, RespT> serverCallHandler) {
            return new c<>(serverInterceptor, serverCallHandler);
        }

        @Override
        public ServerCall.Listener<ReqT> startCall(ServerCall<ReqT, RespT> serverCall, Metadata metadata) {
            return this.a.interceptCall(serverCall, metadata, this.b);
        }
    }

    public static final class d extends BufferedInputStream implements KnownLength {
        public d(InputStream inputStream) {
            super(inputStream);
        }
    }

    public static <ReqT, RespT> void a(ServerServiceDefinition.Builder builder, ServerMethodDefinition<ReqT, RespT> serverMethodDefinition, List<? extends ServerInterceptor> list) {
        ServerCallHandler<ReqT, RespT> serverCallHandler = serverMethodDefinition.getServerCallHandler();
        Iterator<? extends ServerInterceptor> it = list.iterator();
        while (it.hasNext()) {
            serverCallHandler = c.a(it.next(), serverCallHandler);
        }
        builder.addMethod(serverMethodDefinition.withServerCallHandler(serverCallHandler));
    }

    public static <OReqT, ORespT, WReqT, WRespT> ServerCallHandler<WReqT, WRespT> b(ServerCallHandler<OReqT, ORespT> serverCallHandler, MethodDescriptor<OReqT, ORespT> methodDescriptor, MethodDescriptor<WReqT, WRespT> methodDescriptor2) {
        return new b(methodDescriptor, methodDescriptor2, serverCallHandler);
    }

    public static <OReqT, ORespT, WReqT, WRespT> ServerMethodDefinition<WReqT, WRespT> c(ServerMethodDefinition<OReqT, ORespT> serverMethodDefinition, MethodDescriptor<WReqT, WRespT> methodDescriptor) {
        return ServerMethodDefinition.create(methodDescriptor, b(serverMethodDefinition.getServerCallHandler(), serverMethodDefinition.getMethodDescriptor(), methodDescriptor));
    }

    public static ServerServiceDefinition intercept(ServerServiceDefinition serverServiceDefinition, ServerInterceptor... serverInterceptorArr) {
        return intercept(serverServiceDefinition, (List<? extends ServerInterceptor>) Arrays.asList(serverInterceptorArr));
    }

    public static ServerServiceDefinition interceptForward(ServerServiceDefinition serverServiceDefinition, ServerInterceptor... serverInterceptorArr) {
        return interceptForward(serverServiceDefinition, (List<? extends ServerInterceptor>) Arrays.asList(serverInterceptorArr));
    }

    @ExperimentalApi("https://github.com/grpc/grpc-java/issues/1712")
    public static ServerServiceDefinition useInputStreamMessages(ServerServiceDefinition serverServiceDefinition) {
        return useMarshalledMessages(serverServiceDefinition, new a());
    }

    @ExperimentalApi("https://github.com/grpc/grpc-java/issues/1712")
    public static <T> ServerServiceDefinition useMarshalledMessages(ServerServiceDefinition serverServiceDefinition, MethodDescriptor.Marshaller<T> marshaller) {
        ArrayList arrayList = new ArrayList();
        ArrayList arrayList2 = new ArrayList();
        for (ServerMethodDefinition<?, ?> serverMethodDefinition : serverServiceDefinition.getMethods()) {
            MethodDescriptor build = serverMethodDefinition.getMethodDescriptor().toBuilder(marshaller, marshaller).build();
            arrayList2.add(build);
            arrayList.add(c(serverMethodDefinition, build));
        }
        ServiceDescriptor.Builder schemaDescriptor = ServiceDescriptor.newBuilder(serverServiceDefinition.getServiceDescriptor().getName()).setSchemaDescriptor(serverServiceDefinition.getServiceDescriptor().getSchemaDescriptor());
        Iterator it = arrayList2.iterator();
        while (it.hasNext()) {
            schemaDescriptor.addMethod((MethodDescriptor) it.next());
        }
        ServerServiceDefinition.Builder builder = ServerServiceDefinition.builder(schemaDescriptor.build());
        Iterator it2 = arrayList.iterator();
        while (it2.hasNext()) {
            builder.addMethod((ServerMethodDefinition) it2.next());
        }
        return builder.build();
    }

    public static ServerServiceDefinition intercept(BindableService bindableService, ServerInterceptor... serverInterceptorArr) {
        Preconditions.checkNotNull(bindableService, "bindableService");
        return intercept(bindableService.bindService(), (List<? extends ServerInterceptor>) Arrays.asList(serverInterceptorArr));
    }

    public static ServerServiceDefinition interceptForward(BindableService bindableService, ServerInterceptor... serverInterceptorArr) {
        return interceptForward(bindableService.bindService(), (List<? extends ServerInterceptor>) Arrays.asList(serverInterceptorArr));
    }

    public static ServerServiceDefinition interceptForward(ServerServiceDefinition serverServiceDefinition, List<? extends ServerInterceptor> list) {
        ArrayList arrayList = new ArrayList(list);
        Collections.reverse(arrayList);
        return intercept(serverServiceDefinition, arrayList);
    }

    public static ServerServiceDefinition intercept(ServerServiceDefinition serverServiceDefinition, List<? extends ServerInterceptor> list) {
        Preconditions.checkNotNull(serverServiceDefinition, "serviceDef");
        if (list.isEmpty()) {
            return serverServiceDefinition;
        }
        ServerServiceDefinition.Builder builder = ServerServiceDefinition.builder(serverServiceDefinition.getServiceDescriptor());
        Iterator<ServerMethodDefinition<?, ?>> it = serverServiceDefinition.getMethods().iterator();
        while (it.hasNext()) {
            a(builder, it.next(), list);
        }
        return builder.build();
    }

    public static ServerServiceDefinition interceptForward(BindableService bindableService, List<? extends ServerInterceptor> list) {
        return interceptForward(bindableService.bindService(), list);
    }

    public static ServerServiceDefinition intercept(BindableService bindableService, List<? extends ServerInterceptor> list) {
        Preconditions.checkNotNull(bindableService, "bindableService");
        return intercept(bindableService.bindService(), list);
    }
}