github.com/craicoverflow/tyk@v2.9.6-rc3+incompatible/coprocess/bindings/java/DispatcherGrpc.java (about)

     1  package coprocess;
     2  
     3  import static io.grpc.stub.ClientCalls.asyncUnaryCall;
     4  import static io.grpc.stub.ClientCalls.asyncServerStreamingCall;
     5  import static io.grpc.stub.ClientCalls.asyncClientStreamingCall;
     6  import static io.grpc.stub.ClientCalls.asyncBidiStreamingCall;
     7  import static io.grpc.stub.ClientCalls.blockingUnaryCall;
     8  import static io.grpc.stub.ClientCalls.blockingServerStreamingCall;
     9  import static io.grpc.stub.ClientCalls.futureUnaryCall;
    10  import static io.grpc.MethodDescriptor.generateFullMethodName;
    11  import static io.grpc.stub.ServerCalls.asyncUnaryCall;
    12  import static io.grpc.stub.ServerCalls.asyncServerStreamingCall;
    13  import static io.grpc.stub.ServerCalls.asyncClientStreamingCall;
    14  import static io.grpc.stub.ServerCalls.asyncBidiStreamingCall;
    15  import static io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall;
    16  import static io.grpc.stub.ServerCalls.asyncUnimplementedStreamingCall;
    17  
    18  /**
    19   */
    20  @javax.annotation.Generated(
    21      value = "by gRPC proto compiler (version 1.0.3)",
    22      comments = "Source: coprocess_object.proto")
    23  public class DispatcherGrpc {
    24  
    25    private DispatcherGrpc() {}
    26  
    27    public static final String SERVICE_NAME = "coprocess.Dispatcher";
    28  
    29    // Static method descriptors that strictly reflect the proto.
    30    @io.grpc.ExperimentalApi("https://github.com/grpc/grpc-java/issues/1901")
    31    public static final io.grpc.MethodDescriptor<coprocess.CoprocessObject.Object,
    32        coprocess.CoprocessObject.Object> METHOD_DISPATCH =
    33        io.grpc.MethodDescriptor.create(
    34            io.grpc.MethodDescriptor.MethodType.UNARY,
    35            generateFullMethodName(
    36                "coprocess.Dispatcher", "Dispatch"),
    37            io.grpc.protobuf.ProtoUtils.marshaller(coprocess.CoprocessObject.Object.getDefaultInstance()),
    38            io.grpc.protobuf.ProtoUtils.marshaller(coprocess.CoprocessObject.Object.getDefaultInstance()));
    39    @io.grpc.ExperimentalApi("https://github.com/grpc/grpc-java/issues/1901")
    40    public static final io.grpc.MethodDescriptor<coprocess.CoprocessObject.Event,
    41        coprocess.CoprocessObject.EventReply> METHOD_DISPATCH_EVENT =
    42        io.grpc.MethodDescriptor.create(
    43            io.grpc.MethodDescriptor.MethodType.UNARY,
    44            generateFullMethodName(
    45                "coprocess.Dispatcher", "DispatchEvent"),
    46            io.grpc.protobuf.ProtoUtils.marshaller(coprocess.CoprocessObject.Event.getDefaultInstance()),
    47            io.grpc.protobuf.ProtoUtils.marshaller(coprocess.CoprocessObject.EventReply.getDefaultInstance()));
    48  
    49    /**
    50     * Creates a new async stub that supports all call types for the service
    51     */
    52    public static DispatcherStub newStub(io.grpc.Channel channel) {
    53      return new DispatcherStub(channel);
    54    }
    55  
    56    /**
    57     * Creates a new blocking-style stub that supports unary and streaming output calls on the service
    58     */
    59    public static DispatcherBlockingStub newBlockingStub(
    60        io.grpc.Channel channel) {
    61      return new DispatcherBlockingStub(channel);
    62    }
    63  
    64    /**
    65     * Creates a new ListenableFuture-style stub that supports unary and streaming output calls on the service
    66     */
    67    public static DispatcherFutureStub newFutureStub(
    68        io.grpc.Channel channel) {
    69      return new DispatcherFutureStub(channel);
    70    }
    71  
    72    /**
    73     */
    74    public static abstract class DispatcherImplBase implements io.grpc.BindableService {
    75  
    76      /**
    77       */
    78      public void dispatch(coprocess.CoprocessObject.Object request,
    79          io.grpc.stub.StreamObserver<coprocess.CoprocessObject.Object> responseObserver) {
    80        asyncUnimplementedUnaryCall(METHOD_DISPATCH, responseObserver);
    81      }
    82  
    83      /**
    84       */
    85      public void dispatchEvent(coprocess.CoprocessObject.Event request,
    86          io.grpc.stub.StreamObserver<coprocess.CoprocessObject.EventReply> responseObserver) {
    87        asyncUnimplementedUnaryCall(METHOD_DISPATCH_EVENT, responseObserver);
    88      }
    89  
    90      @java.lang.Override public io.grpc.ServerServiceDefinition bindService() {
    91        return io.grpc.ServerServiceDefinition.builder(getServiceDescriptor())
    92            .addMethod(
    93              METHOD_DISPATCH,
    94              asyncUnaryCall(
    95                new MethodHandlers<
    96                  coprocess.CoprocessObject.Object,
    97                  coprocess.CoprocessObject.Object>(
    98                    this, METHODID_DISPATCH)))
    99            .addMethod(
   100              METHOD_DISPATCH_EVENT,
   101              asyncUnaryCall(
   102                new MethodHandlers<
   103                  coprocess.CoprocessObject.Event,
   104                  coprocess.CoprocessObject.EventReply>(
   105                    this, METHODID_DISPATCH_EVENT)))
   106            .build();
   107      }
   108    }
   109  
   110    /**
   111     */
   112    public static final class DispatcherStub extends io.grpc.stub.AbstractStub<DispatcherStub> {
   113      private DispatcherStub(io.grpc.Channel channel) {
   114        super(channel);
   115      }
   116  
   117      private DispatcherStub(io.grpc.Channel channel,
   118          io.grpc.CallOptions callOptions) {
   119        super(channel, callOptions);
   120      }
   121  
   122      @java.lang.Override
   123      protected DispatcherStub build(io.grpc.Channel channel,
   124          io.grpc.CallOptions callOptions) {
   125        return new DispatcherStub(channel, callOptions);
   126      }
   127  
   128      /**
   129       */
   130      public void dispatch(coprocess.CoprocessObject.Object request,
   131          io.grpc.stub.StreamObserver<coprocess.CoprocessObject.Object> responseObserver) {
   132        asyncUnaryCall(
   133            getChannel().newCall(METHOD_DISPATCH, getCallOptions()), request, responseObserver);
   134      }
   135  
   136      /**
   137       */
   138      public void dispatchEvent(coprocess.CoprocessObject.Event request,
   139          io.grpc.stub.StreamObserver<coprocess.CoprocessObject.EventReply> responseObserver) {
   140        asyncUnaryCall(
   141            getChannel().newCall(METHOD_DISPATCH_EVENT, getCallOptions()), request, responseObserver);
   142      }
   143    }
   144  
   145    /**
   146     */
   147    public static final class DispatcherBlockingStub extends io.grpc.stub.AbstractStub<DispatcherBlockingStub> {
   148      private DispatcherBlockingStub(io.grpc.Channel channel) {
   149        super(channel);
   150      }
   151  
   152      private DispatcherBlockingStub(io.grpc.Channel channel,
   153          io.grpc.CallOptions callOptions) {
   154        super(channel, callOptions);
   155      }
   156  
   157      @java.lang.Override
   158      protected DispatcherBlockingStub build(io.grpc.Channel channel,
   159          io.grpc.CallOptions callOptions) {
   160        return new DispatcherBlockingStub(channel, callOptions);
   161      }
   162  
   163      /**
   164       */
   165      public coprocess.CoprocessObject.Object dispatch(coprocess.CoprocessObject.Object request) {
   166        return blockingUnaryCall(
   167            getChannel(), METHOD_DISPATCH, getCallOptions(), request);
   168      }
   169  
   170      /**
   171       */
   172      public coprocess.CoprocessObject.EventReply dispatchEvent(coprocess.CoprocessObject.Event request) {
   173        return blockingUnaryCall(
   174            getChannel(), METHOD_DISPATCH_EVENT, getCallOptions(), request);
   175      }
   176    }
   177  
   178    /**
   179     */
   180    public static final class DispatcherFutureStub extends io.grpc.stub.AbstractStub<DispatcherFutureStub> {
   181      private DispatcherFutureStub(io.grpc.Channel channel) {
   182        super(channel);
   183      }
   184  
   185      private DispatcherFutureStub(io.grpc.Channel channel,
   186          io.grpc.CallOptions callOptions) {
   187        super(channel, callOptions);
   188      }
   189  
   190      @java.lang.Override
   191      protected DispatcherFutureStub build(io.grpc.Channel channel,
   192          io.grpc.CallOptions callOptions) {
   193        return new DispatcherFutureStub(channel, callOptions);
   194      }
   195  
   196      /**
   197       */
   198      public com.google.common.util.concurrent.ListenableFuture<coprocess.CoprocessObject.Object> dispatch(
   199          coprocess.CoprocessObject.Object request) {
   200        return futureUnaryCall(
   201            getChannel().newCall(METHOD_DISPATCH, getCallOptions()), request);
   202      }
   203  
   204      /**
   205       */
   206      public com.google.common.util.concurrent.ListenableFuture<coprocess.CoprocessObject.EventReply> dispatchEvent(
   207          coprocess.CoprocessObject.Event request) {
   208        return futureUnaryCall(
   209            getChannel().newCall(METHOD_DISPATCH_EVENT, getCallOptions()), request);
   210      }
   211    }
   212  
   213    private static final int METHODID_DISPATCH = 0;
   214    private static final int METHODID_DISPATCH_EVENT = 1;
   215  
   216    private static class MethodHandlers<Req, Resp> implements
   217        io.grpc.stub.ServerCalls.UnaryMethod<Req, Resp>,
   218        io.grpc.stub.ServerCalls.ServerStreamingMethod<Req, Resp>,
   219        io.grpc.stub.ServerCalls.ClientStreamingMethod<Req, Resp>,
   220        io.grpc.stub.ServerCalls.BidiStreamingMethod<Req, Resp> {
   221      private final DispatcherImplBase serviceImpl;
   222      private final int methodId;
   223  
   224      public MethodHandlers(DispatcherImplBase serviceImpl, int methodId) {
   225        this.serviceImpl = serviceImpl;
   226        this.methodId = methodId;
   227      }
   228  
   229      @java.lang.Override
   230      @java.lang.SuppressWarnings("unchecked")
   231      public void invoke(Req request, io.grpc.stub.StreamObserver<Resp> responseObserver) {
   232        switch (methodId) {
   233          case METHODID_DISPATCH:
   234            serviceImpl.dispatch((coprocess.CoprocessObject.Object) request,
   235                (io.grpc.stub.StreamObserver<coprocess.CoprocessObject.Object>) responseObserver);
   236            break;
   237          case METHODID_DISPATCH_EVENT:
   238            serviceImpl.dispatchEvent((coprocess.CoprocessObject.Event) request,
   239                (io.grpc.stub.StreamObserver<coprocess.CoprocessObject.EventReply>) responseObserver);
   240            break;
   241          default:
   242            throw new AssertionError();
   243        }
   244      }
   245  
   246      @java.lang.Override
   247      @java.lang.SuppressWarnings("unchecked")
   248      public io.grpc.stub.StreamObserver<Req> invoke(
   249          io.grpc.stub.StreamObserver<Resp> responseObserver) {
   250        switch (methodId) {
   251          default:
   252            throw new AssertionError();
   253        }
   254      }
   255    }
   256  
   257    public static io.grpc.ServiceDescriptor getServiceDescriptor() {
   258      return new io.grpc.ServiceDescriptor(SERVICE_NAME,
   259          METHOD_DISPATCH,
   260          METHOD_DISPATCH_EVENT);
   261    }
   262  
   263  }