package io.grpc.testing.compiler;
import static io.grpc.MethodDescriptor.generateFullMethodName;
import static io.grpc.stub.ClientCalls.asyncBidiStreamingCall;
import static io.grpc.stub.ClientCalls.asyncClientStreamingCall;
import static io.grpc.stub.ClientCalls.asyncServerStreamingCall;
import static io.grpc.stub.ClientCalls.asyncUnaryCall;
import static io.grpc.stub.ClientCalls.blockingServerStreamingCall;
import static io.grpc.stub.ClientCalls.blockingUnaryCall;
import static io.grpc.stub.ClientCalls.futureUnaryCall;
import static io.grpc.stub.ServerCalls.asyncBidiStreamingCall;
import static io.grpc.stub.ServerCalls.asyncClientStreamingCall;
import static io.grpc.stub.ServerCalls.asyncServerStreamingCall;
import static io.grpc.stub.ServerCalls.asyncUnaryCall;
import static io.grpc.stub.ServerCalls.asyncUnimplementedStreamingCall;
import static io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall;
/**
*
* Test service that supports all call types.
*
*/
@javax.annotation.Generated(
value = "by gRPC proto compiler (version 1.16.1)",
comments = "Source: grpc/testing/compiler/test.proto")
public final class TestServiceGrpc {
private TestServiceGrpc() {}
public static final String SERVICE_NAME = "grpc.testing.compiler.TestService";
// Static method descriptors that strictly reflect the proto.
private static volatile io.grpc.MethodDescriptor getUnaryCallMethod;
@io.grpc.stub.annotations.RpcMethod(
fullMethodName = SERVICE_NAME + '/' + "UnaryCall",
requestType = io.grpc.testing.compiler.Test.SimpleRequest.class,
responseType = io.grpc.testing.compiler.Test.SimpleResponse.class,
methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
public static io.grpc.MethodDescriptor getUnaryCallMethod() {
io.grpc.MethodDescriptor getUnaryCallMethod;
if ((getUnaryCallMethod = TestServiceGrpc.getUnaryCallMethod) == null) {
synchronized (TestServiceGrpc.class) {
if ((getUnaryCallMethod = TestServiceGrpc.getUnaryCallMethod) == null) {
TestServiceGrpc.getUnaryCallMethod = getUnaryCallMethod =
io.grpc.MethodDescriptor.newBuilder()
.setType(io.grpc.MethodDescriptor.MethodType.UNARY)
.setFullMethodName(generateFullMethodName(
"grpc.testing.compiler.TestService", "UnaryCall"))
.setSampledToLocalTracing(true)
.setRequestMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller(
io.grpc.testing.compiler.Test.SimpleRequest.getDefaultInstance()))
.setResponseMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller(
io.grpc.testing.compiler.Test.SimpleResponse.getDefaultInstance()))
.build();
}
}
}
return getUnaryCallMethod;
}
private static volatile io.grpc.MethodDescriptor getStreamingOutputCallMethod;
@io.grpc.stub.annotations.RpcMethod(
fullMethodName = SERVICE_NAME + '/' + "StreamingOutputCall",
requestType = io.grpc.testing.compiler.Test.StreamingOutputCallRequest.class,
responseType = io.grpc.testing.compiler.Test.StreamingOutputCallResponse.class,
methodType = io.grpc.MethodDescriptor.MethodType.SERVER_STREAMING)
public static io.grpc.MethodDescriptor getStreamingOutputCallMethod() {
io.grpc.MethodDescriptor getStreamingOutputCallMethod;
if ((getStreamingOutputCallMethod = TestServiceGrpc.getStreamingOutputCallMethod) == null) {
synchronized (TestServiceGrpc.class) {
if ((getStreamingOutputCallMethod = TestServiceGrpc.getStreamingOutputCallMethod) == null) {
TestServiceGrpc.getStreamingOutputCallMethod = getStreamingOutputCallMethod =
io.grpc.MethodDescriptor.newBuilder()
.setType(io.grpc.MethodDescriptor.MethodType.SERVER_STREAMING)
.setFullMethodName(generateFullMethodName(
"grpc.testing.compiler.TestService", "StreamingOutputCall"))
.setSampledToLocalTracing(true)
.setRequestMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller(
io.grpc.testing.compiler.Test.StreamingOutputCallRequest.getDefaultInstance()))
.setResponseMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller(
io.grpc.testing.compiler.Test.StreamingOutputCallResponse.getDefaultInstance()))
.build();
}
}
}
return getStreamingOutputCallMethod;
}
private static volatile io.grpc.MethodDescriptor getStreamingInputCallMethod;
@io.grpc.stub.annotations.RpcMethod(
fullMethodName = SERVICE_NAME + '/' + "StreamingInputCall",
requestType = io.grpc.testing.compiler.Test.StreamingInputCallRequest.class,
responseType = io.grpc.testing.compiler.Test.StreamingInputCallResponse.class,
methodType = io.grpc.MethodDescriptor.MethodType.CLIENT_STREAMING)
public static io.grpc.MethodDescriptor getStreamingInputCallMethod() {
io.grpc.MethodDescriptor getStreamingInputCallMethod;
if ((getStreamingInputCallMethod = TestServiceGrpc.getStreamingInputCallMethod) == null) {
synchronized (TestServiceGrpc.class) {
if ((getStreamingInputCallMethod = TestServiceGrpc.getStreamingInputCallMethod) == null) {
TestServiceGrpc.getStreamingInputCallMethod = getStreamingInputCallMethod =
io.grpc.MethodDescriptor.newBuilder()
.setType(io.grpc.MethodDescriptor.MethodType.CLIENT_STREAMING)
.setFullMethodName(generateFullMethodName(
"grpc.testing.compiler.TestService", "StreamingInputCall"))
.setSampledToLocalTracing(true)
.setRequestMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller(
io.grpc.testing.compiler.Test.StreamingInputCallRequest.getDefaultInstance()))
.setResponseMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller(
io.grpc.testing.compiler.Test.StreamingInputCallResponse.getDefaultInstance()))
.build();
}
}
}
return getStreamingInputCallMethod;
}
private static volatile io.grpc.MethodDescriptor getFullBidiCallMethod;
@io.grpc.stub.annotations.RpcMethod(
fullMethodName = SERVICE_NAME + '/' + "FullBidiCall",
requestType = io.grpc.testing.compiler.Test.StreamingOutputCallRequest.class,
responseType = io.grpc.testing.compiler.Test.StreamingOutputCallResponse.class,
methodType = io.grpc.MethodDescriptor.MethodType.BIDI_STREAMING)
public static io.grpc.MethodDescriptor getFullBidiCallMethod() {
io.grpc.MethodDescriptor getFullBidiCallMethod;
if ((getFullBidiCallMethod = TestServiceGrpc.getFullBidiCallMethod) == null) {
synchronized (TestServiceGrpc.class) {
if ((getFullBidiCallMethod = TestServiceGrpc.getFullBidiCallMethod) == null) {
TestServiceGrpc.getFullBidiCallMethod = getFullBidiCallMethod =
io.grpc.MethodDescriptor.newBuilder()
.setType(io.grpc.MethodDescriptor.MethodType.BIDI_STREAMING)
.setFullMethodName(generateFullMethodName(
"grpc.testing.compiler.TestService", "FullBidiCall"))
.setSampledToLocalTracing(true)
.setRequestMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller(
io.grpc.testing.compiler.Test.StreamingOutputCallRequest.getDefaultInstance()))
.setResponseMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller(
io.grpc.testing.compiler.Test.StreamingOutputCallResponse.getDefaultInstance()))
.build();
}
}
}
return getFullBidiCallMethod;
}
private static volatile io.grpc.MethodDescriptor getHalfBidiCallMethod;
@io.grpc.stub.annotations.RpcMethod(
fullMethodName = SERVICE_NAME + '/' + "HalfBidiCall",
requestType = io.grpc.testing.compiler.Test.StreamingOutputCallRequest.class,
responseType = io.grpc.testing.compiler.Test.StreamingOutputCallResponse.class,
methodType = io.grpc.MethodDescriptor.MethodType.BIDI_STREAMING)
public static io.grpc.MethodDescriptor getHalfBidiCallMethod() {
io.grpc.MethodDescriptor getHalfBidiCallMethod;
if ((getHalfBidiCallMethod = TestServiceGrpc.getHalfBidiCallMethod) == null) {
synchronized (TestServiceGrpc.class) {
if ((getHalfBidiCallMethod = TestServiceGrpc.getHalfBidiCallMethod) == null) {
TestServiceGrpc.getHalfBidiCallMethod = getHalfBidiCallMethod =
io.grpc.MethodDescriptor.newBuilder()
.setType(io.grpc.MethodDescriptor.MethodType.BIDI_STREAMING)
.setFullMethodName(generateFullMethodName(
"grpc.testing.compiler.TestService", "HalfBidiCall"))
.setSampledToLocalTracing(true)
.setRequestMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller(
io.grpc.testing.compiler.Test.StreamingOutputCallRequest.getDefaultInstance()))
.setResponseMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller(
io.grpc.testing.compiler.Test.StreamingOutputCallResponse.getDefaultInstance()))
.build();
}
}
}
return getHalfBidiCallMethod;
}
private static volatile io.grpc.MethodDescriptor getImportMethod;
@io.grpc.stub.annotations.RpcMethod(
fullMethodName = SERVICE_NAME + '/' + "Import",
requestType = io.grpc.testing.compiler.Test.StreamingInputCallRequest.class,
responseType = io.grpc.testing.compiler.Test.StreamingInputCallResponse.class,
methodType = io.grpc.MethodDescriptor.MethodType.BIDI_STREAMING)
public static io.grpc.MethodDescriptor getImportMethod() {
io.grpc.MethodDescriptor getImportMethod;
if ((getImportMethod = TestServiceGrpc.getImportMethod) == null) {
synchronized (TestServiceGrpc.class) {
if ((getImportMethod = TestServiceGrpc.getImportMethod) == null) {
TestServiceGrpc.getImportMethod = getImportMethod =
io.grpc.MethodDescriptor.newBuilder()
.setType(io.grpc.MethodDescriptor.MethodType.BIDI_STREAMING)
.setFullMethodName(generateFullMethodName(
"grpc.testing.compiler.TestService", "Import"))
.setSampledToLocalTracing(true)
.setRequestMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller(
io.grpc.testing.compiler.Test.StreamingInputCallRequest.getDefaultInstance()))
.setResponseMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller(
io.grpc.testing.compiler.Test.StreamingInputCallResponse.getDefaultInstance()))
.build();
}
}
}
return getImportMethod;
}
/**
* Creates a new async stub that supports all call types for the service
*/
public static TestServiceStub newStub(io.grpc.Channel channel) {
return new TestServiceStub(channel);
}
/**
* Creates a new blocking-style stub that supports unary and streaming output calls on the service
*/
public static TestServiceBlockingStub newBlockingStub(
io.grpc.Channel channel) {
return new TestServiceBlockingStub(channel);
}
/**
* Creates a new ListenableFuture-style stub that supports unary calls on the service
*/
public static TestServiceFutureStub newFutureStub(
io.grpc.Channel channel) {
return new TestServiceFutureStub(channel);
}
/**
*
* Test service that supports all call types.
*
*/
public static abstract class TestServiceImplBase implements io.grpc.BindableService {
/**
*
* One request followed by one response.
* The server returns the client payload as-is.
*
*/
public void unaryCall(io.grpc.testing.compiler.Test.SimpleRequest request,
io.grpc.stub.StreamObserver responseObserver) {
asyncUnimplementedUnaryCall(getUnaryCallMethod(), responseObserver);
}
/**
*
* One request followed by a sequence of responses (streamed download).
* The server returns the payload with client desired type and sizes.
*
*/
public void streamingOutputCall(io.grpc.testing.compiler.Test.StreamingOutputCallRequest request,
io.grpc.stub.StreamObserver responseObserver) {
asyncUnimplementedUnaryCall(getStreamingOutputCallMethod(), responseObserver);
}
/**
*
* A sequence of requests followed by one response (streamed upload).
* The server returns the aggregated size of client payload as the result.
*
*/
public io.grpc.stub.StreamObserver streamingInputCall(
io.grpc.stub.StreamObserver responseObserver) {
return asyncUnimplementedStreamingCall(getStreamingInputCallMethod(), responseObserver);
}
/**
*
* A sequence of requests with each request served by the server immediately.
* As one request could lead to multiple responses, this interface
* demonstrates the idea of full bidirectionality.
*
*/
public io.grpc.stub.StreamObserver fullBidiCall(
io.grpc.stub.StreamObserver responseObserver) {
return asyncUnimplementedStreamingCall(getFullBidiCallMethod(), responseObserver);
}
/**
*
* A sequence of requests followed by a sequence of responses.
* The server buffers all the client requests and then serves them in order. A
* stream of responses are returned to the client when the server starts with
* first request.
*
*/
public io.grpc.stub.StreamObserver halfBidiCall(
io.grpc.stub.StreamObserver responseObserver) {
return asyncUnimplementedStreamingCall(getHalfBidiCallMethod(), responseObserver);
}
/**
*
* An RPC method whose Java name collides with a keyword, and whose generated
* method should have a '_' appended.
*
*/
public io.grpc.stub.StreamObserver import_(
io.grpc.stub.StreamObserver responseObserver) {
return asyncUnimplementedStreamingCall(getImportMethod(), responseObserver);
}
@java.lang.Override public final io.grpc.ServerServiceDefinition bindService() {
return io.grpc.ServerServiceDefinition.builder(getServiceDescriptor())
.addMethod(
getUnaryCallMethod(),
asyncUnaryCall(
new MethodHandlers<
io.grpc.testing.compiler.Test.SimpleRequest,
io.grpc.testing.compiler.Test.SimpleResponse>(
this, METHODID_UNARY_CALL)))
.addMethod(
getStreamingOutputCallMethod(),
asyncServerStreamingCall(
new MethodHandlers<
io.grpc.testing.compiler.Test.StreamingOutputCallRequest,
io.grpc.testing.compiler.Test.StreamingOutputCallResponse>(
this, METHODID_STREAMING_OUTPUT_CALL)))
.addMethod(
getStreamingInputCallMethod(),
asyncClientStreamingCall(
new MethodHandlers<
io.grpc.testing.compiler.Test.StreamingInputCallRequest,
io.grpc.testing.compiler.Test.StreamingInputCallResponse>(
this, METHODID_STREAMING_INPUT_CALL)))
.addMethod(
getFullBidiCallMethod(),
asyncBidiStreamingCall(
new MethodHandlers<
io.grpc.testing.compiler.Test.StreamingOutputCallRequest,
io.grpc.testing.compiler.Test.StreamingOutputCallResponse>(
this, METHODID_FULL_BIDI_CALL)))
.addMethod(
getHalfBidiCallMethod(),
asyncBidiStreamingCall(
new MethodHandlers<
io.grpc.testing.compiler.Test.StreamingOutputCallRequest,
io.grpc.testing.compiler.Test.StreamingOutputCallResponse>(
this, METHODID_HALF_BIDI_CALL)))
.addMethod(
getImportMethod(),
asyncBidiStreamingCall(
new MethodHandlers<
io.grpc.testing.compiler.Test.StreamingInputCallRequest,
io.grpc.testing.compiler.Test.StreamingInputCallResponse>(
this, METHODID_IMPORT)))
.build();
}
}
/**
*
* Test service that supports all call types.
*
*/
public static final class TestServiceStub extends io.grpc.stub.AbstractStub {
private TestServiceStub(io.grpc.Channel channel) {
super(channel);
}
private TestServiceStub(io.grpc.Channel channel,
io.grpc.CallOptions callOptions) {
super(channel, callOptions);
}
@java.lang.Override
protected TestServiceStub build(io.grpc.Channel channel,
io.grpc.CallOptions callOptions) {
return new TestServiceStub(channel, callOptions);
}
/**
*
* One request followed by one response.
* The server returns the client payload as-is.
*
*/
public void unaryCall(io.grpc.testing.compiler.Test.SimpleRequest request,
io.grpc.stub.StreamObserver responseObserver) {
asyncUnaryCall(
getChannel().newCall(getUnaryCallMethod(), getCallOptions()), request, responseObserver);
}
/**
*
* One request followed by a sequence of responses (streamed download).
* The server returns the payload with client desired type and sizes.
*
*/
public void streamingOutputCall(io.grpc.testing.compiler.Test.StreamingOutputCallRequest request,
io.grpc.stub.StreamObserver responseObserver) {
asyncServerStreamingCall(
getChannel().newCall(getStreamingOutputCallMethod(), getCallOptions()), request, responseObserver);
}
/**
*
* A sequence of requests followed by one response (streamed upload).
* The server returns the aggregated size of client payload as the result.
*
*/
public io.grpc.stub.StreamObserver streamingInputCall(
io.grpc.stub.StreamObserver responseObserver) {
return asyncClientStreamingCall(
getChannel().newCall(getStreamingInputCallMethod(), getCallOptions()), responseObserver);
}
/**
*
* A sequence of requests with each request served by the server immediately.
* As one request could lead to multiple responses, this interface
* demonstrates the idea of full bidirectionality.
*
*/
public io.grpc.stub.StreamObserver fullBidiCall(
io.grpc.stub.StreamObserver responseObserver) {
return asyncBidiStreamingCall(
getChannel().newCall(getFullBidiCallMethod(), getCallOptions()), responseObserver);
}
/**
*
* A sequence of requests followed by a sequence of responses.
* The server buffers all the client requests and then serves them in order. A
* stream of responses are returned to the client when the server starts with
* first request.
*
*/
public io.grpc.stub.StreamObserver halfBidiCall(
io.grpc.stub.StreamObserver responseObserver) {
return asyncBidiStreamingCall(
getChannel().newCall(getHalfBidiCallMethod(), getCallOptions()), responseObserver);
}
/**
*
* An RPC method whose Java name collides with a keyword, and whose generated
* method should have a '_' appended.
*
*/
public io.grpc.stub.StreamObserver import_(
io.grpc.stub.StreamObserver responseObserver) {
return asyncBidiStreamingCall(
getChannel().newCall(getImportMethod(), getCallOptions()), responseObserver);
}
}
/**
*
* Test service that supports all call types.
*
*/
public static final class TestServiceBlockingStub extends io.grpc.stub.AbstractStub {
private TestServiceBlockingStub(io.grpc.Channel channel) {
super(channel);
}
private TestServiceBlockingStub(io.grpc.Channel channel,
io.grpc.CallOptions callOptions) {
super(channel, callOptions);
}
@java.lang.Override
protected TestServiceBlockingStub build(io.grpc.Channel channel,
io.grpc.CallOptions callOptions) {
return new TestServiceBlockingStub(channel, callOptions);
}
/**
*
* One request followed by one response.
* The server returns the client payload as-is.
*
*/
public io.grpc.testing.compiler.Test.SimpleResponse unaryCall(io.grpc.testing.compiler.Test.SimpleRequest request) {
return blockingUnaryCall(
getChannel(), getUnaryCallMethod(), getCallOptions(), request);
}
/**
*
* One request followed by a sequence of responses (streamed download).
* The server returns the payload with client desired type and sizes.
*
*/
public java.util.Iterator streamingOutputCall(
io.grpc.testing.compiler.Test.StreamingOutputCallRequest request) {
return blockingServerStreamingCall(
getChannel(), getStreamingOutputCallMethod(), getCallOptions(), request);
}
}
/**
*
* Test service that supports all call types.
*
*/
public static final class TestServiceFutureStub extends io.grpc.stub.AbstractStub {
private TestServiceFutureStub(io.grpc.Channel channel) {
super(channel);
}
private TestServiceFutureStub(io.grpc.Channel channel,
io.grpc.CallOptions callOptions) {
super(channel, callOptions);
}
@java.lang.Override
protected TestServiceFutureStub build(io.grpc.Channel channel,
io.grpc.CallOptions callOptions) {
return new TestServiceFutureStub(channel, callOptions);
}
/**
*
* One request followed by one response.
* The server returns the client payload as-is.
*
*/
public com.google.common.util.concurrent.ListenableFuture unaryCall(
io.grpc.testing.compiler.Test.SimpleRequest request) {
return futureUnaryCall(
getChannel().newCall(getUnaryCallMethod(), getCallOptions()), request);
}
}
private static final int METHODID_UNARY_CALL = 0;
private static final int METHODID_STREAMING_OUTPUT_CALL = 1;
private static final int METHODID_STREAMING_INPUT_CALL = 2;
private static final int METHODID_FULL_BIDI_CALL = 3;
private static final int METHODID_HALF_BIDI_CALL = 4;
private static final int METHODID_IMPORT = 5;
private static final class MethodHandlers implements
io.grpc.stub.ServerCalls.UnaryMethod,
io.grpc.stub.ServerCalls.ServerStreamingMethod,
io.grpc.stub.ServerCalls.ClientStreamingMethod,
io.grpc.stub.ServerCalls.BidiStreamingMethod {
private final TestServiceImplBase serviceImpl;
private final int methodId;
MethodHandlers(TestServiceImplBase serviceImpl, int methodId) {
this.serviceImpl = serviceImpl;
this.methodId = methodId;
}
@java.lang.Override
@java.lang.SuppressWarnings("unchecked")
public void invoke(Req request, io.grpc.stub.StreamObserver responseObserver) {
switch (methodId) {
case METHODID_UNARY_CALL:
serviceImpl.unaryCall((io.grpc.testing.compiler.Test.SimpleRequest) request,
(io.grpc.stub.StreamObserver) responseObserver);
break;
case METHODID_STREAMING_OUTPUT_CALL:
serviceImpl.streamingOutputCall((io.grpc.testing.compiler.Test.StreamingOutputCallRequest) request,
(io.grpc.stub.StreamObserver) responseObserver);
break;
default:
throw new AssertionError();
}
}
@java.lang.Override
@java.lang.SuppressWarnings("unchecked")
public io.grpc.stub.StreamObserver invoke(
io.grpc.stub.StreamObserver responseObserver) {
switch (methodId) {
case METHODID_STREAMING_INPUT_CALL:
return (io.grpc.stub.StreamObserver) serviceImpl.streamingInputCall(
(io.grpc.stub.StreamObserver) responseObserver);
case METHODID_FULL_BIDI_CALL:
return (io.grpc.stub.StreamObserver) serviceImpl.fullBidiCall(
(io.grpc.stub.StreamObserver) responseObserver);
case METHODID_HALF_BIDI_CALL:
return (io.grpc.stub.StreamObserver) serviceImpl.halfBidiCall(
(io.grpc.stub.StreamObserver) responseObserver);
case METHODID_IMPORT:
return (io.grpc.stub.StreamObserver) serviceImpl.import_(
(io.grpc.stub.StreamObserver) responseObserver);
default:
throw new AssertionError();
}
}
}
private static volatile io.grpc.ServiceDescriptor serviceDescriptor;
public static io.grpc.ServiceDescriptor getServiceDescriptor() {
io.grpc.ServiceDescriptor result = serviceDescriptor;
if (result == null) {
synchronized (TestServiceGrpc.class) {
result = serviceDescriptor;
if (result == null) {
serviceDescriptor = result = io.grpc.ServiceDescriptor.newBuilder(SERVICE_NAME)
.addMethod(getUnaryCallMethod())
.addMethod(getStreamingOutputCallMethod())
.addMethod(getStreamingInputCallMethod())
.addMethod(getFullBidiCallMethod())
.addMethod(getHalfBidiCallMethod())
.addMethod(getImportMethod())
.build();
}
}
}
return result;
}
}