games.mythical.saga.sdk.proto.api.currency.CurrencyServiceGrpc Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of saga-sdk-proto Show documentation
Show all versions of saga-sdk-proto Show documentation
Saga SDK for Java game servers
package games.mythical.saga.sdk.proto.api.currency;
import static io.grpc.MethodDescriptor.generateFullMethodName;
/**
*/
@javax.annotation.Generated(
value = "by gRPC proto compiler (version 1.49.2)",
comments = "Source: api/currency/rpc.proto")
@io.grpc.stub.annotations.GrpcGenerated
public final class CurrencyServiceGrpc {
private CurrencyServiceGrpc() {}
public static final String SERVICE_NAME = "saga.api.currency.CurrencyService";
// Static method descriptors that strictly reflect the proto.
private static volatile io.grpc.MethodDescriptor getIssueCurrencyMethod;
@io.grpc.stub.annotations.RpcMethod(
fullMethodName = SERVICE_NAME + '/' + "IssueCurrency",
requestType = games.mythical.saga.sdk.proto.api.currency.IssueCurrencyRequest.class,
responseType = games.mythical.saga.sdk.proto.common.ReceivedResponse.class,
methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
public static io.grpc.MethodDescriptor getIssueCurrencyMethod() {
io.grpc.MethodDescriptor getIssueCurrencyMethod;
if ((getIssueCurrencyMethod = CurrencyServiceGrpc.getIssueCurrencyMethod) == null) {
synchronized (CurrencyServiceGrpc.class) {
if ((getIssueCurrencyMethod = CurrencyServiceGrpc.getIssueCurrencyMethod) == null) {
CurrencyServiceGrpc.getIssueCurrencyMethod = getIssueCurrencyMethod =
io.grpc.MethodDescriptor.newBuilder()
.setType(io.grpc.MethodDescriptor.MethodType.UNARY)
.setFullMethodName(generateFullMethodName(SERVICE_NAME, "IssueCurrency"))
.setSampledToLocalTracing(true)
.setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
games.mythical.saga.sdk.proto.api.currency.IssueCurrencyRequest.getDefaultInstance()))
.setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
games.mythical.saga.sdk.proto.common.ReceivedResponse.getDefaultInstance()))
.setSchemaDescriptor(new CurrencyServiceMethodDescriptorSupplier("IssueCurrency"))
.build();
}
}
}
return getIssueCurrencyMethod;
}
private static volatile io.grpc.MethodDescriptor getTransferCurrencyMethod;
@io.grpc.stub.annotations.RpcMethod(
fullMethodName = SERVICE_NAME + '/' + "TransferCurrency",
requestType = games.mythical.saga.sdk.proto.api.currency.TransferCurrencyRequest.class,
responseType = games.mythical.saga.sdk.proto.common.ReceivedResponse.class,
methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
public static io.grpc.MethodDescriptor getTransferCurrencyMethod() {
io.grpc.MethodDescriptor getTransferCurrencyMethod;
if ((getTransferCurrencyMethod = CurrencyServiceGrpc.getTransferCurrencyMethod) == null) {
synchronized (CurrencyServiceGrpc.class) {
if ((getTransferCurrencyMethod = CurrencyServiceGrpc.getTransferCurrencyMethod) == null) {
CurrencyServiceGrpc.getTransferCurrencyMethod = getTransferCurrencyMethod =
io.grpc.MethodDescriptor.newBuilder()
.setType(io.grpc.MethodDescriptor.MethodType.UNARY)
.setFullMethodName(generateFullMethodName(SERVICE_NAME, "TransferCurrency"))
.setSampledToLocalTracing(true)
.setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
games.mythical.saga.sdk.proto.api.currency.TransferCurrencyRequest.getDefaultInstance()))
.setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
games.mythical.saga.sdk.proto.common.ReceivedResponse.getDefaultInstance()))
.setSchemaDescriptor(new CurrencyServiceMethodDescriptorSupplier("TransferCurrency"))
.build();
}
}
}
return getTransferCurrencyMethod;
}
private static volatile io.grpc.MethodDescriptor getBurnCurrencyMethod;
@io.grpc.stub.annotations.RpcMethod(
fullMethodName = SERVICE_NAME + '/' + "BurnCurrency",
requestType = games.mythical.saga.sdk.proto.api.currency.BurnCurrencyRequest.class,
responseType = games.mythical.saga.sdk.proto.common.ReceivedResponse.class,
methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
public static io.grpc.MethodDescriptor getBurnCurrencyMethod() {
io.grpc.MethodDescriptor getBurnCurrencyMethod;
if ((getBurnCurrencyMethod = CurrencyServiceGrpc.getBurnCurrencyMethod) == null) {
synchronized (CurrencyServiceGrpc.class) {
if ((getBurnCurrencyMethod = CurrencyServiceGrpc.getBurnCurrencyMethod) == null) {
CurrencyServiceGrpc.getBurnCurrencyMethod = getBurnCurrencyMethod =
io.grpc.MethodDescriptor.newBuilder()
.setType(io.grpc.MethodDescriptor.MethodType.UNARY)
.setFullMethodName(generateFullMethodName(SERVICE_NAME, "BurnCurrency"))
.setSampledToLocalTracing(true)
.setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
games.mythical.saga.sdk.proto.api.currency.BurnCurrencyRequest.getDefaultInstance()))
.setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
games.mythical.saga.sdk.proto.common.ReceivedResponse.getDefaultInstance()))
.setSchemaDescriptor(new CurrencyServiceMethodDescriptorSupplier("BurnCurrency"))
.build();
}
}
}
return getBurnCurrencyMethod;
}
private static volatile io.grpc.MethodDescriptor getGetBalanceOfPlayerMethod;
@io.grpc.stub.annotations.RpcMethod(
fullMethodName = SERVICE_NAME + '/' + "GetBalanceOfPlayer",
requestType = games.mythical.saga.sdk.proto.api.currency.GetBalanceOfPlayerRequest.class,
responseType = games.mythical.saga.sdk.proto.api.currency.BalanceOfPlayerProto.class,
methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
public static io.grpc.MethodDescriptor getGetBalanceOfPlayerMethod() {
io.grpc.MethodDescriptor getGetBalanceOfPlayerMethod;
if ((getGetBalanceOfPlayerMethod = CurrencyServiceGrpc.getGetBalanceOfPlayerMethod) == null) {
synchronized (CurrencyServiceGrpc.class) {
if ((getGetBalanceOfPlayerMethod = CurrencyServiceGrpc.getGetBalanceOfPlayerMethod) == null) {
CurrencyServiceGrpc.getGetBalanceOfPlayerMethod = getGetBalanceOfPlayerMethod =
io.grpc.MethodDescriptor.newBuilder()
.setType(io.grpc.MethodDescriptor.MethodType.UNARY)
.setFullMethodName(generateFullMethodName(SERVICE_NAME, "GetBalanceOfPlayer"))
.setSampledToLocalTracing(true)
.setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
games.mythical.saga.sdk.proto.api.currency.GetBalanceOfPlayerRequest.getDefaultInstance()))
.setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
games.mythical.saga.sdk.proto.api.currency.BalanceOfPlayerProto.getDefaultInstance()))
.setSchemaDescriptor(new CurrencyServiceMethodDescriptorSupplier("GetBalanceOfPlayer"))
.build();
}
}
}
return getGetBalanceOfPlayerMethod;
}
private static volatile io.grpc.MethodDescriptor getGetBalancesOfPlayerMethod;
@io.grpc.stub.annotations.RpcMethod(
fullMethodName = SERVICE_NAME + '/' + "GetBalancesOfPlayer",
requestType = games.mythical.saga.sdk.proto.api.currency.GetBalancesOfPlayerRequest.class,
responseType = games.mythical.saga.sdk.proto.api.currency.BalancesOfPlayerProto.class,
methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
public static io.grpc.MethodDescriptor getGetBalancesOfPlayerMethod() {
io.grpc.MethodDescriptor getGetBalancesOfPlayerMethod;
if ((getGetBalancesOfPlayerMethod = CurrencyServiceGrpc.getGetBalancesOfPlayerMethod) == null) {
synchronized (CurrencyServiceGrpc.class) {
if ((getGetBalancesOfPlayerMethod = CurrencyServiceGrpc.getGetBalancesOfPlayerMethod) == null) {
CurrencyServiceGrpc.getGetBalancesOfPlayerMethod = getGetBalancesOfPlayerMethod =
io.grpc.MethodDescriptor.newBuilder()
.setType(io.grpc.MethodDescriptor.MethodType.UNARY)
.setFullMethodName(generateFullMethodName(SERVICE_NAME, "GetBalancesOfPlayer"))
.setSampledToLocalTracing(true)
.setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
games.mythical.saga.sdk.proto.api.currency.GetBalancesOfPlayerRequest.getDefaultInstance()))
.setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
games.mythical.saga.sdk.proto.api.currency.BalancesOfPlayerProto.getDefaultInstance()))
.setSchemaDescriptor(new CurrencyServiceMethodDescriptorSupplier("GetBalancesOfPlayer"))
.build();
}
}
}
return getGetBalancesOfPlayerMethod;
}
/**
* Creates a new async stub that supports all call types for the service
*/
public static CurrencyServiceStub newStub(io.grpc.Channel channel) {
io.grpc.stub.AbstractStub.StubFactory factory =
new io.grpc.stub.AbstractStub.StubFactory() {
@java.lang.Override
public CurrencyServiceStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
return new CurrencyServiceStub(channel, callOptions);
}
};
return CurrencyServiceStub.newStub(factory, channel);
}
/**
* Creates a new blocking-style stub that supports unary and streaming output calls on the service
*/
public static CurrencyServiceBlockingStub newBlockingStub(
io.grpc.Channel channel) {
io.grpc.stub.AbstractStub.StubFactory factory =
new io.grpc.stub.AbstractStub.StubFactory() {
@java.lang.Override
public CurrencyServiceBlockingStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
return new CurrencyServiceBlockingStub(channel, callOptions);
}
};
return CurrencyServiceBlockingStub.newStub(factory, channel);
}
/**
* Creates a new ListenableFuture-style stub that supports unary calls on the service
*/
public static CurrencyServiceFutureStub newFutureStub(
io.grpc.Channel channel) {
io.grpc.stub.AbstractStub.StubFactory factory =
new io.grpc.stub.AbstractStub.StubFactory() {
@java.lang.Override
public CurrencyServiceFutureStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
return new CurrencyServiceFutureStub(channel, callOptions);
}
};
return CurrencyServiceFutureStub.newStub(factory, channel);
}
/**
*/
public static abstract class CurrencyServiceImplBase implements io.grpc.BindableService {
/**
*
* Issue currency to a user
*
*/
public void issueCurrency(games.mythical.saga.sdk.proto.api.currency.IssueCurrencyRequest request,
io.grpc.stub.StreamObserver responseObserver) {
io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getIssueCurrencyMethod(), responseObserver);
}
/**
*
* Transfer currency between users
*
*/
public void transferCurrency(games.mythical.saga.sdk.proto.api.currency.TransferCurrencyRequest request,
io.grpc.stub.StreamObserver responseObserver) {
io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getTransferCurrencyMethod(), responseObserver);
}
/**
*
* Burn currency for a user
*
*/
public void burnCurrency(games.mythical.saga.sdk.proto.api.currency.BurnCurrencyRequest request,
io.grpc.stub.StreamObserver responseObserver) {
io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getBurnCurrencyMethod(), responseObserver);
}
/**
*
* Get Balance of a player
*
*/
public void getBalanceOfPlayer(games.mythical.saga.sdk.proto.api.currency.GetBalanceOfPlayerRequest request,
io.grpc.stub.StreamObserver responseObserver) {
io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getGetBalanceOfPlayerMethod(), responseObserver);
}
/**
*
* Get Balances of a player
*
*/
public void getBalancesOfPlayer(games.mythical.saga.sdk.proto.api.currency.GetBalancesOfPlayerRequest request,
io.grpc.stub.StreamObserver responseObserver) {
io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getGetBalancesOfPlayerMethod(), responseObserver);
}
@java.lang.Override public final io.grpc.ServerServiceDefinition bindService() {
return io.grpc.ServerServiceDefinition.builder(getServiceDescriptor())
.addMethod(
getIssueCurrencyMethod(),
io.grpc.stub.ServerCalls.asyncUnaryCall(
new MethodHandlers<
games.mythical.saga.sdk.proto.api.currency.IssueCurrencyRequest,
games.mythical.saga.sdk.proto.common.ReceivedResponse>(
this, METHODID_ISSUE_CURRENCY)))
.addMethod(
getTransferCurrencyMethod(),
io.grpc.stub.ServerCalls.asyncUnaryCall(
new MethodHandlers<
games.mythical.saga.sdk.proto.api.currency.TransferCurrencyRequest,
games.mythical.saga.sdk.proto.common.ReceivedResponse>(
this, METHODID_TRANSFER_CURRENCY)))
.addMethod(
getBurnCurrencyMethod(),
io.grpc.stub.ServerCalls.asyncUnaryCall(
new MethodHandlers<
games.mythical.saga.sdk.proto.api.currency.BurnCurrencyRequest,
games.mythical.saga.sdk.proto.common.ReceivedResponse>(
this, METHODID_BURN_CURRENCY)))
.addMethod(
getGetBalanceOfPlayerMethod(),
io.grpc.stub.ServerCalls.asyncUnaryCall(
new MethodHandlers<
games.mythical.saga.sdk.proto.api.currency.GetBalanceOfPlayerRequest,
games.mythical.saga.sdk.proto.api.currency.BalanceOfPlayerProto>(
this, METHODID_GET_BALANCE_OF_PLAYER)))
.addMethod(
getGetBalancesOfPlayerMethod(),
io.grpc.stub.ServerCalls.asyncUnaryCall(
new MethodHandlers<
games.mythical.saga.sdk.proto.api.currency.GetBalancesOfPlayerRequest,
games.mythical.saga.sdk.proto.api.currency.BalancesOfPlayerProto>(
this, METHODID_GET_BALANCES_OF_PLAYER)))
.build();
}
}
/**
*/
public static final class CurrencyServiceStub extends io.grpc.stub.AbstractAsyncStub {
private CurrencyServiceStub(
io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
super(channel, callOptions);
}
@java.lang.Override
protected CurrencyServiceStub build(
io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
return new CurrencyServiceStub(channel, callOptions);
}
/**
*
* Issue currency to a user
*
*/
public void issueCurrency(games.mythical.saga.sdk.proto.api.currency.IssueCurrencyRequest request,
io.grpc.stub.StreamObserver responseObserver) {
io.grpc.stub.ClientCalls.asyncUnaryCall(
getChannel().newCall(getIssueCurrencyMethod(), getCallOptions()), request, responseObserver);
}
/**
*
* Transfer currency between users
*
*/
public void transferCurrency(games.mythical.saga.sdk.proto.api.currency.TransferCurrencyRequest request,
io.grpc.stub.StreamObserver responseObserver) {
io.grpc.stub.ClientCalls.asyncUnaryCall(
getChannel().newCall(getTransferCurrencyMethod(), getCallOptions()), request, responseObserver);
}
/**
*
* Burn currency for a user
*
*/
public void burnCurrency(games.mythical.saga.sdk.proto.api.currency.BurnCurrencyRequest request,
io.grpc.stub.StreamObserver responseObserver) {
io.grpc.stub.ClientCalls.asyncUnaryCall(
getChannel().newCall(getBurnCurrencyMethod(), getCallOptions()), request, responseObserver);
}
/**
*
* Get Balance of a player
*
*/
public void getBalanceOfPlayer(games.mythical.saga.sdk.proto.api.currency.GetBalanceOfPlayerRequest request,
io.grpc.stub.StreamObserver responseObserver) {
io.grpc.stub.ClientCalls.asyncUnaryCall(
getChannel().newCall(getGetBalanceOfPlayerMethod(), getCallOptions()), request, responseObserver);
}
/**
*
* Get Balances of a player
*
*/
public void getBalancesOfPlayer(games.mythical.saga.sdk.proto.api.currency.GetBalancesOfPlayerRequest request,
io.grpc.stub.StreamObserver responseObserver) {
io.grpc.stub.ClientCalls.asyncUnaryCall(
getChannel().newCall(getGetBalancesOfPlayerMethod(), getCallOptions()), request, responseObserver);
}
}
/**
*/
public static final class CurrencyServiceBlockingStub extends io.grpc.stub.AbstractBlockingStub {
private CurrencyServiceBlockingStub(
io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
super(channel, callOptions);
}
@java.lang.Override
protected CurrencyServiceBlockingStub build(
io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
return new CurrencyServiceBlockingStub(channel, callOptions);
}
/**
*
* Issue currency to a user
*
*/
public games.mythical.saga.sdk.proto.common.ReceivedResponse issueCurrency(games.mythical.saga.sdk.proto.api.currency.IssueCurrencyRequest request) {
return io.grpc.stub.ClientCalls.blockingUnaryCall(
getChannel(), getIssueCurrencyMethod(), getCallOptions(), request);
}
/**
*
* Transfer currency between users
*
*/
public games.mythical.saga.sdk.proto.common.ReceivedResponse transferCurrency(games.mythical.saga.sdk.proto.api.currency.TransferCurrencyRequest request) {
return io.grpc.stub.ClientCalls.blockingUnaryCall(
getChannel(), getTransferCurrencyMethod(), getCallOptions(), request);
}
/**
*
* Burn currency for a user
*
*/
public games.mythical.saga.sdk.proto.common.ReceivedResponse burnCurrency(games.mythical.saga.sdk.proto.api.currency.BurnCurrencyRequest request) {
return io.grpc.stub.ClientCalls.blockingUnaryCall(
getChannel(), getBurnCurrencyMethod(), getCallOptions(), request);
}
/**
*
* Get Balance of a player
*
*/
public games.mythical.saga.sdk.proto.api.currency.BalanceOfPlayerProto getBalanceOfPlayer(games.mythical.saga.sdk.proto.api.currency.GetBalanceOfPlayerRequest request) {
return io.grpc.stub.ClientCalls.blockingUnaryCall(
getChannel(), getGetBalanceOfPlayerMethod(), getCallOptions(), request);
}
/**
*
* Get Balances of a player
*
*/
public games.mythical.saga.sdk.proto.api.currency.BalancesOfPlayerProto getBalancesOfPlayer(games.mythical.saga.sdk.proto.api.currency.GetBalancesOfPlayerRequest request) {
return io.grpc.stub.ClientCalls.blockingUnaryCall(
getChannel(), getGetBalancesOfPlayerMethod(), getCallOptions(), request);
}
}
/**
*/
public static final class CurrencyServiceFutureStub extends io.grpc.stub.AbstractFutureStub {
private CurrencyServiceFutureStub(
io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
super(channel, callOptions);
}
@java.lang.Override
protected CurrencyServiceFutureStub build(
io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
return new CurrencyServiceFutureStub(channel, callOptions);
}
/**
*
* Issue currency to a user
*
*/
public com.google.common.util.concurrent.ListenableFuture issueCurrency(
games.mythical.saga.sdk.proto.api.currency.IssueCurrencyRequest request) {
return io.grpc.stub.ClientCalls.futureUnaryCall(
getChannel().newCall(getIssueCurrencyMethod(), getCallOptions()), request);
}
/**
*
* Transfer currency between users
*
*/
public com.google.common.util.concurrent.ListenableFuture transferCurrency(
games.mythical.saga.sdk.proto.api.currency.TransferCurrencyRequest request) {
return io.grpc.stub.ClientCalls.futureUnaryCall(
getChannel().newCall(getTransferCurrencyMethod(), getCallOptions()), request);
}
/**
*
* Burn currency for a user
*
*/
public com.google.common.util.concurrent.ListenableFuture burnCurrency(
games.mythical.saga.sdk.proto.api.currency.BurnCurrencyRequest request) {
return io.grpc.stub.ClientCalls.futureUnaryCall(
getChannel().newCall(getBurnCurrencyMethod(), getCallOptions()), request);
}
/**
*
* Get Balance of a player
*
*/
public com.google.common.util.concurrent.ListenableFuture getBalanceOfPlayer(
games.mythical.saga.sdk.proto.api.currency.GetBalanceOfPlayerRequest request) {
return io.grpc.stub.ClientCalls.futureUnaryCall(
getChannel().newCall(getGetBalanceOfPlayerMethod(), getCallOptions()), request);
}
/**
*
* Get Balances of a player
*
*/
public com.google.common.util.concurrent.ListenableFuture getBalancesOfPlayer(
games.mythical.saga.sdk.proto.api.currency.GetBalancesOfPlayerRequest request) {
return io.grpc.stub.ClientCalls.futureUnaryCall(
getChannel().newCall(getGetBalancesOfPlayerMethod(), getCallOptions()), request);
}
}
private static final int METHODID_ISSUE_CURRENCY = 0;
private static final int METHODID_TRANSFER_CURRENCY = 1;
private static final int METHODID_BURN_CURRENCY = 2;
private static final int METHODID_GET_BALANCE_OF_PLAYER = 3;
private static final int METHODID_GET_BALANCES_OF_PLAYER = 4;
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 CurrencyServiceImplBase serviceImpl;
private final int methodId;
MethodHandlers(CurrencyServiceImplBase 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_ISSUE_CURRENCY:
serviceImpl.issueCurrency((games.mythical.saga.sdk.proto.api.currency.IssueCurrencyRequest) request,
(io.grpc.stub.StreamObserver) responseObserver);
break;
case METHODID_TRANSFER_CURRENCY:
serviceImpl.transferCurrency((games.mythical.saga.sdk.proto.api.currency.TransferCurrencyRequest) request,
(io.grpc.stub.StreamObserver) responseObserver);
break;
case METHODID_BURN_CURRENCY:
serviceImpl.burnCurrency((games.mythical.saga.sdk.proto.api.currency.BurnCurrencyRequest) request,
(io.grpc.stub.StreamObserver) responseObserver);
break;
case METHODID_GET_BALANCE_OF_PLAYER:
serviceImpl.getBalanceOfPlayer((games.mythical.saga.sdk.proto.api.currency.GetBalanceOfPlayerRequest) request,
(io.grpc.stub.StreamObserver) responseObserver);
break;
case METHODID_GET_BALANCES_OF_PLAYER:
serviceImpl.getBalancesOfPlayer((games.mythical.saga.sdk.proto.api.currency.GetBalancesOfPlayerRequest) 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) {
default:
throw new AssertionError();
}
}
}
private static abstract class CurrencyServiceBaseDescriptorSupplier
implements io.grpc.protobuf.ProtoFileDescriptorSupplier, io.grpc.protobuf.ProtoServiceDescriptorSupplier {
CurrencyServiceBaseDescriptorSupplier() {}
@java.lang.Override
public com.google.protobuf.Descriptors.FileDescriptor getFileDescriptor() {
return games.mythical.saga.sdk.proto.api.currency.Rpc.getDescriptor();
}
@java.lang.Override
public com.google.protobuf.Descriptors.ServiceDescriptor getServiceDescriptor() {
return getFileDescriptor().findServiceByName("CurrencyService");
}
}
private static final class CurrencyServiceFileDescriptorSupplier
extends CurrencyServiceBaseDescriptorSupplier {
CurrencyServiceFileDescriptorSupplier() {}
}
private static final class CurrencyServiceMethodDescriptorSupplier
extends CurrencyServiceBaseDescriptorSupplier
implements io.grpc.protobuf.ProtoMethodDescriptorSupplier {
private final String methodName;
CurrencyServiceMethodDescriptorSupplier(String methodName) {
this.methodName = methodName;
}
@java.lang.Override
public com.google.protobuf.Descriptors.MethodDescriptor getMethodDescriptor() {
return getServiceDescriptor().findMethodByName(methodName);
}
}
private static volatile io.grpc.ServiceDescriptor serviceDescriptor;
public static io.grpc.ServiceDescriptor getServiceDescriptor() {
io.grpc.ServiceDescriptor result = serviceDescriptor;
if (result == null) {
synchronized (CurrencyServiceGrpc.class) {
result = serviceDescriptor;
if (result == null) {
serviceDescriptor = result = io.grpc.ServiceDescriptor.newBuilder(SERVICE_NAME)
.setSchemaDescriptor(new CurrencyServiceFileDescriptorSupplier())
.addMethod(getIssueCurrencyMethod())
.addMethod(getTransferCurrencyMethod())
.addMethod(getBurnCurrencyMethod())
.addMethod(getGetBalanceOfPlayerMethod())
.addMethod(getGetBalancesOfPlayerMethod())
.build();
}
}
}
return result;
}
}