com.redhat.mercury.accountreconciliation.v10.api.craccountreconciliationprocedureservice.MutinyCRAccountReconciliationProcedureServiceGrpc Maven / Gradle / Ivy

Go to download
package com.redhat.mercury.accountreconciliation.v10.api.craccountreconciliationprocedureservice;

import static com.redhat.mercury.accountreconciliation.v10.api.craccountreconciliationprocedureservice.CRAccountReconciliationProcedureServiceGrpc.getServiceDescriptor;
import static io.grpc.stub.ServerCalls.asyncUnaryCall;
import static io.grpc.stub.ServerCalls.asyncServerStreamingCall;
import static io.grpc.stub.ServerCalls.asyncClientStreamingCall;
import static io.grpc.stub.ServerCalls.asyncBidiStreamingCall;

@javax.annotation.Generated(
value = "by Mutiny Grpc generator",
comments = "Source: v10/api/cr_account_reconciliation_procedure_service.proto")
public final class MutinyCRAccountReconciliationProcedureServiceGrpc implements io.quarkus.grpc.runtime.MutinyGrpc {
    private MutinyCRAccountReconciliationProcedureServiceGrpc() {}

    public static MutinyCRAccountReconciliationProcedureServiceStub newMutinyStub(io.grpc.Channel channel) {
        return new MutinyCRAccountReconciliationProcedureServiceStub(channel);
    }

    
    public static final class MutinyCRAccountReconciliationProcedureServiceStub extends io.grpc.stub.AbstractStub implements io.quarkus.grpc.runtime.MutinyStub {
        private CRAccountReconciliationProcedureServiceGrpc.CRAccountReconciliationProcedureServiceStub delegateStub;

        private MutinyCRAccountReconciliationProcedureServiceStub(io.grpc.Channel channel) {
            super(channel);
            delegateStub = CRAccountReconciliationProcedureServiceGrpc.newStub(channel);
        }

        private MutinyCRAccountReconciliationProcedureServiceStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
            super(channel, callOptions);
            delegateStub = CRAccountReconciliationProcedureServiceGrpc.newStub(channel).build(channel, callOptions);
        }

        @Override
        protected MutinyCRAccountReconciliationProcedureServiceStub build(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
            return new MutinyCRAccountReconciliationProcedureServiceStub(channel, callOptions);
        }

        
        public io.smallrye.mutiny.Uni control(com.redhat.mercury.accountreconciliation.v10.api.craccountreconciliationprocedureservice.CrAccountReconciliationProcedureService.ControlRequest request) {
            return io.quarkus.grpc.runtime.ClientCalls.oneToOne(request, delegateStub::control);
        }

        
        public io.smallrye.mutiny.Uni exchange(com.redhat.mercury.accountreconciliation.v10.api.craccountreconciliationprocedureservice.CrAccountReconciliationProcedureService.ExchangeRequest request) {
            return io.quarkus.grpc.runtime.ClientCalls.oneToOne(request, delegateStub::exchange);
        }

        
        public io.smallrye.mutiny.Uni execute(com.redhat.mercury.accountreconciliation.v10.api.craccountreconciliationprocedureservice.CrAccountReconciliationProcedureService.ExecuteRequest request) {
            return io.quarkus.grpc.runtime.ClientCalls.oneToOne(request, delegateStub::execute);
        }

        
        public io.smallrye.mutiny.Uni initiate(com.redhat.mercury.accountreconciliation.v10.api.craccountreconciliationprocedureservice.CrAccountReconciliationProcedureService.InitiateRequest request) {
            return io.quarkus.grpc.runtime.ClientCalls.oneToOne(request, delegateStub::initiate);
        }

        
        public io.smallrye.mutiny.Uni notify(com.redhat.mercury.accountreconciliation.v10.api.craccountreconciliationprocedureservice.CrAccountReconciliationProcedureService.NotifyRequest request) {
            return io.quarkus.grpc.runtime.ClientCalls.oneToOne(request, delegateStub::notify);
        }

        
        public io.smallrye.mutiny.Uni request(com.redhat.mercury.accountreconciliation.v10.api.craccountreconciliationprocedureservice.CrAccountReconciliationProcedureService.RequestRequest request) {
            return io.quarkus.grpc.runtime.ClientCalls.oneToOne(request, delegateStub::request);
        }

        
        public io.smallrye.mutiny.Uni retrieve(com.redhat.mercury.accountreconciliation.v10.api.craccountreconciliationprocedureservice.CrAccountReconciliationProcedureService.RetrieveRequest request) {
            return io.quarkus.grpc.runtime.ClientCalls.oneToOne(request, delegateStub::retrieve);
        }

        
        public io.smallrye.mutiny.Uni update(com.redhat.mercury.accountreconciliation.v10.api.craccountreconciliationprocedureservice.CrAccountReconciliationProcedureService.UpdateRequest request) {
            return io.quarkus.grpc.runtime.ClientCalls.oneToOne(request, delegateStub::update);
        }

    }

    
    public static abstract class CRAccountReconciliationProcedureServiceImplBase implements io.grpc.BindableService {

        private String compression;
        /**
        * Set whether the server will try to use a compressed response.
        *
        * @param compression the compression, e.g {@code gzip}
        */
        public CRAccountReconciliationProcedureServiceImplBase withCompression(String compression) {
        this.compression = compression;
        return this;
        }


        
        public io.smallrye.mutiny.Uni control(com.redhat.mercury.accountreconciliation.v10.api.craccountreconciliationprocedureservice.CrAccountReconciliationProcedureService.ControlRequest request) {
            throw new io.grpc.StatusRuntimeException(io.grpc.Status.UNIMPLEMENTED);
        }

        
        public io.smallrye.mutiny.Uni exchange(com.redhat.mercury.accountreconciliation.v10.api.craccountreconciliationprocedureservice.CrAccountReconciliationProcedureService.ExchangeRequest request) {
            throw new io.grpc.StatusRuntimeException(io.grpc.Status.UNIMPLEMENTED);
        }

        
        public io.smallrye.mutiny.Uni execute(com.redhat.mercury.accountreconciliation.v10.api.craccountreconciliationprocedureservice.CrAccountReconciliationProcedureService.ExecuteRequest request) {
            throw new io.grpc.StatusRuntimeException(io.grpc.Status.UNIMPLEMENTED);
        }

        
        public io.smallrye.mutiny.Uni initiate(com.redhat.mercury.accountreconciliation.v10.api.craccountreconciliationprocedureservice.CrAccountReconciliationProcedureService.InitiateRequest request) {
            throw new io.grpc.StatusRuntimeException(io.grpc.Status.UNIMPLEMENTED);
        }

        
        public io.smallrye.mutiny.Uni notify(com.redhat.mercury.accountreconciliation.v10.api.craccountreconciliationprocedureservice.CrAccountReconciliationProcedureService.NotifyRequest request) {
            throw new io.grpc.StatusRuntimeException(io.grpc.Status.UNIMPLEMENTED);
        }

        
        public io.smallrye.mutiny.Uni request(com.redhat.mercury.accountreconciliation.v10.api.craccountreconciliationprocedureservice.CrAccountReconciliationProcedureService.RequestRequest request) {
            throw new io.grpc.StatusRuntimeException(io.grpc.Status.UNIMPLEMENTED);
        }

        
        public io.smallrye.mutiny.Uni retrieve(com.redhat.mercury.accountreconciliation.v10.api.craccountreconciliationprocedureservice.CrAccountReconciliationProcedureService.RetrieveRequest request) {
            throw new io.grpc.StatusRuntimeException(io.grpc.Status.UNIMPLEMENTED);
        }

        
        public io.smallrye.mutiny.Uni update(com.redhat.mercury.accountreconciliation.v10.api.craccountreconciliationprocedureservice.CrAccountReconciliationProcedureService.UpdateRequest request) {
            throw new io.grpc.StatusRuntimeException(io.grpc.Status.UNIMPLEMENTED);
        }

        @java.lang.Override public final io.grpc.ServerServiceDefinition bindService() {
            return io.grpc.ServerServiceDefinition.builder(getServiceDescriptor())
                    .addMethod(
                            com.redhat.mercury.accountreconciliation.v10.api.craccountreconciliationprocedureservice.CRAccountReconciliationProcedureServiceGrpc.getControlMethod(),
                            asyncUnaryCall(
                                    new MethodHandlers<
                                            com.redhat.mercury.accountreconciliation.v10.api.craccountreconciliationprocedureservice.CrAccountReconciliationProcedureService.ControlRequest,
                                            com.redhat.mercury.accountreconciliation.v10.ControlAccountReconciliationProcedureResponseOuterClass.ControlAccountReconciliationProcedureResponse>(
                                            this, METHODID_CONTROL, compression)))
                    .addMethod(
                            com.redhat.mercury.accountreconciliation.v10.api.craccountreconciliationprocedureservice.CRAccountReconciliationProcedureServiceGrpc.getExchangeMethod(),
                            asyncUnaryCall(
                                    new MethodHandlers<
                                            com.redhat.mercury.accountreconciliation.v10.api.craccountreconciliationprocedureservice.CrAccountReconciliationProcedureService.ExchangeRequest,
                                            com.redhat.mercury.accountreconciliation.v10.ExchangeAccountReconciliationProcedureResponseOuterClass.ExchangeAccountReconciliationProcedureResponse>(
                                            this, METHODID_EXCHANGE, compression)))
                    .addMethod(
                            com.redhat.mercury.accountreconciliation.v10.api.craccountreconciliationprocedureservice.CRAccountReconciliationProcedureServiceGrpc.getExecuteMethod(),
                            asyncUnaryCall(
                                    new MethodHandlers<
                                            com.redhat.mercury.accountreconciliation.v10.api.craccountreconciliationprocedureservice.CrAccountReconciliationProcedureService.ExecuteRequest,
                                            com.redhat.mercury.accountreconciliation.v10.ExecuteAccountReconciliationProcedureResponseOuterClass.ExecuteAccountReconciliationProcedureResponse>(
                                            this, METHODID_EXECUTE, compression)))
                    .addMethod(
                            com.redhat.mercury.accountreconciliation.v10.api.craccountreconciliationprocedureservice.CRAccountReconciliationProcedureServiceGrpc.getInitiateMethod(),
                            asyncUnaryCall(
                                    new MethodHandlers<
                                            com.redhat.mercury.accountreconciliation.v10.api.craccountreconciliationprocedureservice.CrAccountReconciliationProcedureService.InitiateRequest,
                                            com.redhat.mercury.accountreconciliation.v10.InitiateAccountReconciliationProcedureResponseOuterClass.InitiateAccountReconciliationProcedureResponse>(
                                            this, METHODID_INITIATE, compression)))
                    .addMethod(
                            com.redhat.mercury.accountreconciliation.v10.api.craccountreconciliationprocedureservice.CRAccountReconciliationProcedureServiceGrpc.getNotifyMethod(),
                            asyncUnaryCall(
                                    new MethodHandlers<
                                            com.redhat.mercury.accountreconciliation.v10.api.craccountreconciliationprocedureservice.CrAccountReconciliationProcedureService.NotifyRequest,
                                            com.redhat.mercury.accountreconciliation.v10.NotifyAccountReconciliationProcedureResponseOuterClass.NotifyAccountReconciliationProcedureResponse>(
                                            this, METHODID_NOTIFY, compression)))
                    .addMethod(
                            com.redhat.mercury.accountreconciliation.v10.api.craccountreconciliationprocedureservice.CRAccountReconciliationProcedureServiceGrpc.getRequestMethod(),
                            asyncUnaryCall(
                                    new MethodHandlers<
                                            com.redhat.mercury.accountreconciliation.v10.api.craccountreconciliationprocedureservice.CrAccountReconciliationProcedureService.RequestRequest,
                                            com.redhat.mercury.accountreconciliation.v10.RequestAccountReconciliationProcedureResponseOuterClass.RequestAccountReconciliationProcedureResponse>(
                                            this, METHODID_REQUEST, compression)))
                    .addMethod(
                            com.redhat.mercury.accountreconciliation.v10.api.craccountreconciliationprocedureservice.CRAccountReconciliationProcedureServiceGrpc.getRetrieveMethod(),
                            asyncUnaryCall(
                                    new MethodHandlers<
                                            com.redhat.mercury.accountreconciliation.v10.api.craccountreconciliationprocedureservice.CrAccountReconciliationProcedureService.RetrieveRequest,
                                            com.redhat.mercury.accountreconciliation.v10.RetrieveAccountReconciliationProcedureResponseOuterClass.RetrieveAccountReconciliationProcedureResponse>(
                                            this, METHODID_RETRIEVE, compression)))
                    .addMethod(
                            com.redhat.mercury.accountreconciliation.v10.api.craccountreconciliationprocedureservice.CRAccountReconciliationProcedureServiceGrpc.getUpdateMethod(),
                            asyncUnaryCall(
                                    new MethodHandlers<
                                            com.redhat.mercury.accountreconciliation.v10.api.craccountreconciliationprocedureservice.CrAccountReconciliationProcedureService.UpdateRequest,
                                            com.redhat.mercury.accountreconciliation.v10.UpdateAccountReconciliationProcedureResponseOuterClass.UpdateAccountReconciliationProcedureResponse>(
                                            this, METHODID_UPDATE, compression)))
                    .build();
        }
    }

    private static final int METHODID_CONTROL = 0;
    private static final int METHODID_EXCHANGE = 1;
    private static final int METHODID_EXECUTE = 2;
    private static final int METHODID_INITIATE = 3;
    private static final int METHODID_NOTIFY = 4;
    private static final int METHODID_REQUEST = 5;
    private static final int METHODID_RETRIEVE = 6;
    private static final int METHODID_UPDATE = 7;

    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 CRAccountReconciliationProcedureServiceImplBase serviceImpl;
        private final int methodId;
        private final String compression;

        MethodHandlers(CRAccountReconciliationProcedureServiceImplBase serviceImpl, int methodId, String compression) {
            this.serviceImpl = serviceImpl;
            this.methodId = methodId;
            this.compression = compression;
        }

        @java.lang.Override
        @java.lang.SuppressWarnings("unchecked")
        public void invoke(Req request, io.grpc.stub.StreamObserver responseObserver) {
            switch (methodId) {
                case METHODID_CONTROL:
                    io.quarkus.grpc.runtime.ServerCalls.oneToOne((com.redhat.mercury.accountreconciliation.v10.api.craccountreconciliationprocedureservice.CrAccountReconciliationProcedureService.ControlRequest) request,
                            (io.grpc.stub.StreamObserver) responseObserver,
                            compression,
                            serviceImpl::control);
                    break;
                case METHODID_EXCHANGE:
                    io.quarkus.grpc.runtime.ServerCalls.oneToOne((com.redhat.mercury.accountreconciliation.v10.api.craccountreconciliationprocedureservice.CrAccountReconciliationProcedureService.ExchangeRequest) request,
                            (io.grpc.stub.StreamObserver) responseObserver,
                            compression,
                            serviceImpl::exchange);
                    break;
                case METHODID_EXECUTE:
                    io.quarkus.grpc.runtime.ServerCalls.oneToOne((com.redhat.mercury.accountreconciliation.v10.api.craccountreconciliationprocedureservice.CrAccountReconciliationProcedureService.ExecuteRequest) request,
                            (io.grpc.stub.StreamObserver) responseObserver,
                            compression,
                            serviceImpl::execute);
                    break;
                case METHODID_INITIATE:
                    io.quarkus.grpc.runtime.ServerCalls.oneToOne((com.redhat.mercury.accountreconciliation.v10.api.craccountreconciliationprocedureservice.CrAccountReconciliationProcedureService.InitiateRequest) request,
                            (io.grpc.stub.StreamObserver) responseObserver,
                            compression,
                            serviceImpl::initiate);
                    break;
                case METHODID_NOTIFY:
                    io.quarkus.grpc.runtime.ServerCalls.oneToOne((com.redhat.mercury.accountreconciliation.v10.api.craccountreconciliationprocedureservice.CrAccountReconciliationProcedureService.NotifyRequest) request,
                            (io.grpc.stub.StreamObserver) responseObserver,
                            compression,
                            serviceImpl::notify);
                    break;
                case METHODID_REQUEST:
                    io.quarkus.grpc.runtime.ServerCalls.oneToOne((com.redhat.mercury.accountreconciliation.v10.api.craccountreconciliationprocedureservice.CrAccountReconciliationProcedureService.RequestRequest) request,
                            (io.grpc.stub.StreamObserver) responseObserver,
                            compression,
                            serviceImpl::request);
                    break;
                case METHODID_RETRIEVE:
                    io.quarkus.grpc.runtime.ServerCalls.oneToOne((com.redhat.mercury.accountreconciliation.v10.api.craccountreconciliationprocedureservice.CrAccountReconciliationProcedureService.RetrieveRequest) request,
                            (io.grpc.stub.StreamObserver) responseObserver,
                            compression,
                            serviceImpl::retrieve);
                    break;
                case METHODID_UPDATE:
                    io.quarkus.grpc.runtime.ServerCalls.oneToOne((com.redhat.mercury.accountreconciliation.v10.api.craccountreconciliationprocedureservice.CrAccountReconciliationProcedureService.UpdateRequest) request,
                            (io.grpc.stub.StreamObserver) responseObserver,
                            compression,
                            serviceImpl::update);
                    break;
                default:
                    throw new java.lang.AssertionError();
            }
        }

        @java.lang.Override
        @java.lang.SuppressWarnings("unchecked")
        public io.grpc.stub.StreamObserver invoke(io.grpc.stub.StreamObserver responseObserver) {
            switch (methodId) {
                default:
                    throw new java.lang.AssertionError();
            }
        }
    }

}