All Downloads are FREE. Search and download functionalities are using the official Maven repository.

com.redhat.mercury.assetsecuritization.v10.api.crassetsecuritizationtransactionservice.CRAssetSecuritizationTransactionServiceGrpc Maven / Gradle / Ivy

package com.redhat.mercury.assetsecuritization.v10.api.crassetsecuritizationtransactionservice;

import static io.grpc.MethodDescriptor.generateFullMethodName;

/**
 */
@javax.annotation.Generated(
    value = "by gRPC proto compiler (version 1.42.1)",
    comments = "Source: v10/api/cr_asset_securitization_transaction_service.proto")
@io.grpc.stub.annotations.GrpcGenerated
public final class CRAssetSecuritizationTransactionServiceGrpc {

  private CRAssetSecuritizationTransactionServiceGrpc() {}

  public static final String SERVICE_NAME = "com.redhat.mercury.assetsecuritization.v10.api.crassetsecuritizationtransactionservice.CRAssetSecuritizationTransactionService";

  // Static method descriptors that strictly reflect the proto.
  private static volatile io.grpc.MethodDescriptor getControlMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "Control",
      requestType = com.redhat.mercury.assetsecuritization.v10.api.crassetsecuritizationtransactionservice.CrAssetSecuritizationTransactionService.ControlRequest.class,
      responseType = com.redhat.mercury.assetsecuritization.v10.ControlAssetSecuritizationTransactionResponseOuterClass.ControlAssetSecuritizationTransactionResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor getControlMethod() {
    io.grpc.MethodDescriptor getControlMethod;
    if ((getControlMethod = CRAssetSecuritizationTransactionServiceGrpc.getControlMethod) == null) {
      synchronized (CRAssetSecuritizationTransactionServiceGrpc.class) {
        if ((getControlMethod = CRAssetSecuritizationTransactionServiceGrpc.getControlMethod) == null) {
          CRAssetSecuritizationTransactionServiceGrpc.getControlMethod = getControlMethod =
              io.grpc.MethodDescriptor.newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "Control"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  com.redhat.mercury.assetsecuritization.v10.api.crassetsecuritizationtransactionservice.CrAssetSecuritizationTransactionService.ControlRequest.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  com.redhat.mercury.assetsecuritization.v10.ControlAssetSecuritizationTransactionResponseOuterClass.ControlAssetSecuritizationTransactionResponse.getDefaultInstance()))
              .setSchemaDescriptor(new CRAssetSecuritizationTransactionServiceMethodDescriptorSupplier("Control"))
              .build();
        }
      }
    }
    return getControlMethod;
  }

  private static volatile io.grpc.MethodDescriptor getExchangeMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "Exchange",
      requestType = com.redhat.mercury.assetsecuritization.v10.api.crassetsecuritizationtransactionservice.CrAssetSecuritizationTransactionService.ExchangeRequest.class,
      responseType = com.redhat.mercury.assetsecuritization.v10.ExchangeAssetSecuritizationTransactionResponseOuterClass.ExchangeAssetSecuritizationTransactionResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor getExchangeMethod() {
    io.grpc.MethodDescriptor getExchangeMethod;
    if ((getExchangeMethod = CRAssetSecuritizationTransactionServiceGrpc.getExchangeMethod) == null) {
      synchronized (CRAssetSecuritizationTransactionServiceGrpc.class) {
        if ((getExchangeMethod = CRAssetSecuritizationTransactionServiceGrpc.getExchangeMethod) == null) {
          CRAssetSecuritizationTransactionServiceGrpc.getExchangeMethod = getExchangeMethod =
              io.grpc.MethodDescriptor.newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "Exchange"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  com.redhat.mercury.assetsecuritization.v10.api.crassetsecuritizationtransactionservice.CrAssetSecuritizationTransactionService.ExchangeRequest.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  com.redhat.mercury.assetsecuritization.v10.ExchangeAssetSecuritizationTransactionResponseOuterClass.ExchangeAssetSecuritizationTransactionResponse.getDefaultInstance()))
              .setSchemaDescriptor(new CRAssetSecuritizationTransactionServiceMethodDescriptorSupplier("Exchange"))
              .build();
        }
      }
    }
    return getExchangeMethod;
  }

  private static volatile io.grpc.MethodDescriptor getExecuteMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "Execute",
      requestType = com.redhat.mercury.assetsecuritization.v10.api.crassetsecuritizationtransactionservice.CrAssetSecuritizationTransactionService.ExecuteRequest.class,
      responseType = com.redhat.mercury.assetsecuritization.v10.ExecuteAssetSecuritizationTransactionResponseOuterClass.ExecuteAssetSecuritizationTransactionResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor getExecuteMethod() {
    io.grpc.MethodDescriptor getExecuteMethod;
    if ((getExecuteMethod = CRAssetSecuritizationTransactionServiceGrpc.getExecuteMethod) == null) {
      synchronized (CRAssetSecuritizationTransactionServiceGrpc.class) {
        if ((getExecuteMethod = CRAssetSecuritizationTransactionServiceGrpc.getExecuteMethod) == null) {
          CRAssetSecuritizationTransactionServiceGrpc.getExecuteMethod = getExecuteMethod =
              io.grpc.MethodDescriptor.newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "Execute"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  com.redhat.mercury.assetsecuritization.v10.api.crassetsecuritizationtransactionservice.CrAssetSecuritizationTransactionService.ExecuteRequest.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  com.redhat.mercury.assetsecuritization.v10.ExecuteAssetSecuritizationTransactionResponseOuterClass.ExecuteAssetSecuritizationTransactionResponse.getDefaultInstance()))
              .setSchemaDescriptor(new CRAssetSecuritizationTransactionServiceMethodDescriptorSupplier("Execute"))
              .build();
        }
      }
    }
    return getExecuteMethod;
  }

  private static volatile io.grpc.MethodDescriptor getInitiateMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "Initiate",
      requestType = com.redhat.mercury.assetsecuritization.v10.api.crassetsecuritizationtransactionservice.CrAssetSecuritizationTransactionService.InitiateRequest.class,
      responseType = com.redhat.mercury.assetsecuritization.v10.InitiateAssetSecuritizationTransactionResponseOuterClass.InitiateAssetSecuritizationTransactionResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor getInitiateMethod() {
    io.grpc.MethodDescriptor getInitiateMethod;
    if ((getInitiateMethod = CRAssetSecuritizationTransactionServiceGrpc.getInitiateMethod) == null) {
      synchronized (CRAssetSecuritizationTransactionServiceGrpc.class) {
        if ((getInitiateMethod = CRAssetSecuritizationTransactionServiceGrpc.getInitiateMethod) == null) {
          CRAssetSecuritizationTransactionServiceGrpc.getInitiateMethod = getInitiateMethod =
              io.grpc.MethodDescriptor.newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "Initiate"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  com.redhat.mercury.assetsecuritization.v10.api.crassetsecuritizationtransactionservice.CrAssetSecuritizationTransactionService.InitiateRequest.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  com.redhat.mercury.assetsecuritization.v10.InitiateAssetSecuritizationTransactionResponseOuterClass.InitiateAssetSecuritizationTransactionResponse.getDefaultInstance()))
              .setSchemaDescriptor(new CRAssetSecuritizationTransactionServiceMethodDescriptorSupplier("Initiate"))
              .build();
        }
      }
    }
    return getInitiateMethod;
  }

  private static volatile io.grpc.MethodDescriptor getRequestMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "Request",
      requestType = com.redhat.mercury.assetsecuritization.v10.api.crassetsecuritizationtransactionservice.CrAssetSecuritizationTransactionService.RequestRequest.class,
      responseType = com.redhat.mercury.assetsecuritization.v10.RequestAssetSecuritizationTransactionResponseOuterClass.RequestAssetSecuritizationTransactionResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor getRequestMethod() {
    io.grpc.MethodDescriptor getRequestMethod;
    if ((getRequestMethod = CRAssetSecuritizationTransactionServiceGrpc.getRequestMethod) == null) {
      synchronized (CRAssetSecuritizationTransactionServiceGrpc.class) {
        if ((getRequestMethod = CRAssetSecuritizationTransactionServiceGrpc.getRequestMethod) == null) {
          CRAssetSecuritizationTransactionServiceGrpc.getRequestMethod = getRequestMethod =
              io.grpc.MethodDescriptor.newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "Request"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  com.redhat.mercury.assetsecuritization.v10.api.crassetsecuritizationtransactionservice.CrAssetSecuritizationTransactionService.RequestRequest.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  com.redhat.mercury.assetsecuritization.v10.RequestAssetSecuritizationTransactionResponseOuterClass.RequestAssetSecuritizationTransactionResponse.getDefaultInstance()))
              .setSchemaDescriptor(new CRAssetSecuritizationTransactionServiceMethodDescriptorSupplier("Request"))
              .build();
        }
      }
    }
    return getRequestMethod;
  }

  private static volatile io.grpc.MethodDescriptor getRetrieveMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "Retrieve",
      requestType = com.redhat.mercury.assetsecuritization.v10.api.crassetsecuritizationtransactionservice.CrAssetSecuritizationTransactionService.RetrieveRequest.class,
      responseType = com.redhat.mercury.assetsecuritization.v10.RetrieveAssetSecuritizationTransactionResponseOuterClass.RetrieveAssetSecuritizationTransactionResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor getRetrieveMethod() {
    io.grpc.MethodDescriptor getRetrieveMethod;
    if ((getRetrieveMethod = CRAssetSecuritizationTransactionServiceGrpc.getRetrieveMethod) == null) {
      synchronized (CRAssetSecuritizationTransactionServiceGrpc.class) {
        if ((getRetrieveMethod = CRAssetSecuritizationTransactionServiceGrpc.getRetrieveMethod) == null) {
          CRAssetSecuritizationTransactionServiceGrpc.getRetrieveMethod = getRetrieveMethod =
              io.grpc.MethodDescriptor.newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "Retrieve"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  com.redhat.mercury.assetsecuritization.v10.api.crassetsecuritizationtransactionservice.CrAssetSecuritizationTransactionService.RetrieveRequest.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  com.redhat.mercury.assetsecuritization.v10.RetrieveAssetSecuritizationTransactionResponseOuterClass.RetrieveAssetSecuritizationTransactionResponse.getDefaultInstance()))
              .setSchemaDescriptor(new CRAssetSecuritizationTransactionServiceMethodDescriptorSupplier("Retrieve"))
              .build();
        }
      }
    }
    return getRetrieveMethod;
  }

  private static volatile io.grpc.MethodDescriptor getUpdateMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "Update",
      requestType = com.redhat.mercury.assetsecuritization.v10.api.crassetsecuritizationtransactionservice.CrAssetSecuritizationTransactionService.UpdateRequest.class,
      responseType = com.redhat.mercury.assetsecuritization.v10.UpdateAssetSecuritizationTransactionResponseOuterClass.UpdateAssetSecuritizationTransactionResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor getUpdateMethod() {
    io.grpc.MethodDescriptor getUpdateMethod;
    if ((getUpdateMethod = CRAssetSecuritizationTransactionServiceGrpc.getUpdateMethod) == null) {
      synchronized (CRAssetSecuritizationTransactionServiceGrpc.class) {
        if ((getUpdateMethod = CRAssetSecuritizationTransactionServiceGrpc.getUpdateMethod) == null) {
          CRAssetSecuritizationTransactionServiceGrpc.getUpdateMethod = getUpdateMethod =
              io.grpc.MethodDescriptor.newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "Update"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  com.redhat.mercury.assetsecuritization.v10.api.crassetsecuritizationtransactionservice.CrAssetSecuritizationTransactionService.UpdateRequest.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  com.redhat.mercury.assetsecuritization.v10.UpdateAssetSecuritizationTransactionResponseOuterClass.UpdateAssetSecuritizationTransactionResponse.getDefaultInstance()))
              .setSchemaDescriptor(new CRAssetSecuritizationTransactionServiceMethodDescriptorSupplier("Update"))
              .build();
        }
      }
    }
    return getUpdateMethod;
  }

  /**
   * Creates a new async stub that supports all call types for the service
   */
  public static CRAssetSecuritizationTransactionServiceStub newStub(io.grpc.Channel channel) {
    io.grpc.stub.AbstractStub.StubFactory factory =
      new io.grpc.stub.AbstractStub.StubFactory() {
        @java.lang.Override
        public CRAssetSecuritizationTransactionServiceStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
          return new CRAssetSecuritizationTransactionServiceStub(channel, callOptions);
        }
      };
    return CRAssetSecuritizationTransactionServiceStub.newStub(factory, channel);
  }

  /**
   * Creates a new blocking-style stub that supports unary and streaming output calls on the service
   */
  public static CRAssetSecuritizationTransactionServiceBlockingStub newBlockingStub(
      io.grpc.Channel channel) {
    io.grpc.stub.AbstractStub.StubFactory factory =
      new io.grpc.stub.AbstractStub.StubFactory() {
        @java.lang.Override
        public CRAssetSecuritizationTransactionServiceBlockingStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
          return new CRAssetSecuritizationTransactionServiceBlockingStub(channel, callOptions);
        }
      };
    return CRAssetSecuritizationTransactionServiceBlockingStub.newStub(factory, channel);
  }

  /**
   * Creates a new ListenableFuture-style stub that supports unary calls on the service
   */
  public static CRAssetSecuritizationTransactionServiceFutureStub newFutureStub(
      io.grpc.Channel channel) {
    io.grpc.stub.AbstractStub.StubFactory factory =
      new io.grpc.stub.AbstractStub.StubFactory() {
        @java.lang.Override
        public CRAssetSecuritizationTransactionServiceFutureStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
          return new CRAssetSecuritizationTransactionServiceFutureStub(channel, callOptions);
        }
      };
    return CRAssetSecuritizationTransactionServiceFutureStub.newStub(factory, channel);
  }

  /**
   */
  public static abstract class CRAssetSecuritizationTransactionServiceImplBase implements io.grpc.BindableService {

    /**
     */
    public void control(com.redhat.mercury.assetsecuritization.v10.api.crassetsecuritizationtransactionservice.CrAssetSecuritizationTransactionService.ControlRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getControlMethod(), responseObserver);
    }

    /**
     */
    public void exchange(com.redhat.mercury.assetsecuritization.v10.api.crassetsecuritizationtransactionservice.CrAssetSecuritizationTransactionService.ExchangeRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getExchangeMethod(), responseObserver);
    }

    /**
     */
    public void execute(com.redhat.mercury.assetsecuritization.v10.api.crassetsecuritizationtransactionservice.CrAssetSecuritizationTransactionService.ExecuteRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getExecuteMethod(), responseObserver);
    }

    /**
     */
    public void initiate(com.redhat.mercury.assetsecuritization.v10.api.crassetsecuritizationtransactionservice.CrAssetSecuritizationTransactionService.InitiateRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getInitiateMethod(), responseObserver);
    }

    /**
     */
    public void request(com.redhat.mercury.assetsecuritization.v10.api.crassetsecuritizationtransactionservice.CrAssetSecuritizationTransactionService.RequestRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getRequestMethod(), responseObserver);
    }

    /**
     */
    public void retrieve(com.redhat.mercury.assetsecuritization.v10.api.crassetsecuritizationtransactionservice.CrAssetSecuritizationTransactionService.RetrieveRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getRetrieveMethod(), responseObserver);
    }

    /**
     */
    public void update(com.redhat.mercury.assetsecuritization.v10.api.crassetsecuritizationtransactionservice.CrAssetSecuritizationTransactionService.UpdateRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getUpdateMethod(), responseObserver);
    }

    @java.lang.Override public final io.grpc.ServerServiceDefinition bindService() {
      return io.grpc.ServerServiceDefinition.builder(getServiceDescriptor())
          .addMethod(
            getControlMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.redhat.mercury.assetsecuritization.v10.api.crassetsecuritizationtransactionservice.CrAssetSecuritizationTransactionService.ControlRequest,
                com.redhat.mercury.assetsecuritization.v10.ControlAssetSecuritizationTransactionResponseOuterClass.ControlAssetSecuritizationTransactionResponse>(
                  this, METHODID_CONTROL)))
          .addMethod(
            getExchangeMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.redhat.mercury.assetsecuritization.v10.api.crassetsecuritizationtransactionservice.CrAssetSecuritizationTransactionService.ExchangeRequest,
                com.redhat.mercury.assetsecuritization.v10.ExchangeAssetSecuritizationTransactionResponseOuterClass.ExchangeAssetSecuritizationTransactionResponse>(
                  this, METHODID_EXCHANGE)))
          .addMethod(
            getExecuteMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.redhat.mercury.assetsecuritization.v10.api.crassetsecuritizationtransactionservice.CrAssetSecuritizationTransactionService.ExecuteRequest,
                com.redhat.mercury.assetsecuritization.v10.ExecuteAssetSecuritizationTransactionResponseOuterClass.ExecuteAssetSecuritizationTransactionResponse>(
                  this, METHODID_EXECUTE)))
          .addMethod(
            getInitiateMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.redhat.mercury.assetsecuritization.v10.api.crassetsecuritizationtransactionservice.CrAssetSecuritizationTransactionService.InitiateRequest,
                com.redhat.mercury.assetsecuritization.v10.InitiateAssetSecuritizationTransactionResponseOuterClass.InitiateAssetSecuritizationTransactionResponse>(
                  this, METHODID_INITIATE)))
          .addMethod(
            getRequestMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.redhat.mercury.assetsecuritization.v10.api.crassetsecuritizationtransactionservice.CrAssetSecuritizationTransactionService.RequestRequest,
                com.redhat.mercury.assetsecuritization.v10.RequestAssetSecuritizationTransactionResponseOuterClass.RequestAssetSecuritizationTransactionResponse>(
                  this, METHODID_REQUEST)))
          .addMethod(
            getRetrieveMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.redhat.mercury.assetsecuritization.v10.api.crassetsecuritizationtransactionservice.CrAssetSecuritizationTransactionService.RetrieveRequest,
                com.redhat.mercury.assetsecuritization.v10.RetrieveAssetSecuritizationTransactionResponseOuterClass.RetrieveAssetSecuritizationTransactionResponse>(
                  this, METHODID_RETRIEVE)))
          .addMethod(
            getUpdateMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.redhat.mercury.assetsecuritization.v10.api.crassetsecuritizationtransactionservice.CrAssetSecuritizationTransactionService.UpdateRequest,
                com.redhat.mercury.assetsecuritization.v10.UpdateAssetSecuritizationTransactionResponseOuterClass.UpdateAssetSecuritizationTransactionResponse>(
                  this, METHODID_UPDATE)))
          .build();
    }
  }

  /**
   */
  public static final class CRAssetSecuritizationTransactionServiceStub extends io.grpc.stub.AbstractAsyncStub {
    private CRAssetSecuritizationTransactionServiceStub(
        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
      super(channel, callOptions);
    }

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

    /**
     */
    public void control(com.redhat.mercury.assetsecuritization.v10.api.crassetsecuritizationtransactionservice.CrAssetSecuritizationTransactionService.ControlRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getControlMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     */
    public void exchange(com.redhat.mercury.assetsecuritization.v10.api.crassetsecuritizationtransactionservice.CrAssetSecuritizationTransactionService.ExchangeRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getExchangeMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     */
    public void execute(com.redhat.mercury.assetsecuritization.v10.api.crassetsecuritizationtransactionservice.CrAssetSecuritizationTransactionService.ExecuteRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getExecuteMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     */
    public void initiate(com.redhat.mercury.assetsecuritization.v10.api.crassetsecuritizationtransactionservice.CrAssetSecuritizationTransactionService.InitiateRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getInitiateMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     */
    public void request(com.redhat.mercury.assetsecuritization.v10.api.crassetsecuritizationtransactionservice.CrAssetSecuritizationTransactionService.RequestRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getRequestMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     */
    public void retrieve(com.redhat.mercury.assetsecuritization.v10.api.crassetsecuritizationtransactionservice.CrAssetSecuritizationTransactionService.RetrieveRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getRetrieveMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     */
    public void update(com.redhat.mercury.assetsecuritization.v10.api.crassetsecuritizationtransactionservice.CrAssetSecuritizationTransactionService.UpdateRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getUpdateMethod(), getCallOptions()), request, responseObserver);
    }
  }

  /**
   */
  public static final class CRAssetSecuritizationTransactionServiceBlockingStub extends io.grpc.stub.AbstractBlockingStub {
    private CRAssetSecuritizationTransactionServiceBlockingStub(
        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
      super(channel, callOptions);
    }

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

    /**
     */
    public com.redhat.mercury.assetsecuritization.v10.ControlAssetSecuritizationTransactionResponseOuterClass.ControlAssetSecuritizationTransactionResponse control(com.redhat.mercury.assetsecuritization.v10.api.crassetsecuritizationtransactionservice.CrAssetSecuritizationTransactionService.ControlRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getControlMethod(), getCallOptions(), request);
    }

    /**
     */
    public com.redhat.mercury.assetsecuritization.v10.ExchangeAssetSecuritizationTransactionResponseOuterClass.ExchangeAssetSecuritizationTransactionResponse exchange(com.redhat.mercury.assetsecuritization.v10.api.crassetsecuritizationtransactionservice.CrAssetSecuritizationTransactionService.ExchangeRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getExchangeMethod(), getCallOptions(), request);
    }

    /**
     */
    public com.redhat.mercury.assetsecuritization.v10.ExecuteAssetSecuritizationTransactionResponseOuterClass.ExecuteAssetSecuritizationTransactionResponse execute(com.redhat.mercury.assetsecuritization.v10.api.crassetsecuritizationtransactionservice.CrAssetSecuritizationTransactionService.ExecuteRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getExecuteMethod(), getCallOptions(), request);
    }

    /**
     */
    public com.redhat.mercury.assetsecuritization.v10.InitiateAssetSecuritizationTransactionResponseOuterClass.InitiateAssetSecuritizationTransactionResponse initiate(com.redhat.mercury.assetsecuritization.v10.api.crassetsecuritizationtransactionservice.CrAssetSecuritizationTransactionService.InitiateRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getInitiateMethod(), getCallOptions(), request);
    }

    /**
     */
    public com.redhat.mercury.assetsecuritization.v10.RequestAssetSecuritizationTransactionResponseOuterClass.RequestAssetSecuritizationTransactionResponse request(com.redhat.mercury.assetsecuritization.v10.api.crassetsecuritizationtransactionservice.CrAssetSecuritizationTransactionService.RequestRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getRequestMethod(), getCallOptions(), request);
    }

    /**
     */
    public com.redhat.mercury.assetsecuritization.v10.RetrieveAssetSecuritizationTransactionResponseOuterClass.RetrieveAssetSecuritizationTransactionResponse retrieve(com.redhat.mercury.assetsecuritization.v10.api.crassetsecuritizationtransactionservice.CrAssetSecuritizationTransactionService.RetrieveRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getRetrieveMethod(), getCallOptions(), request);
    }

    /**
     */
    public com.redhat.mercury.assetsecuritization.v10.UpdateAssetSecuritizationTransactionResponseOuterClass.UpdateAssetSecuritizationTransactionResponse update(com.redhat.mercury.assetsecuritization.v10.api.crassetsecuritizationtransactionservice.CrAssetSecuritizationTransactionService.UpdateRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getUpdateMethod(), getCallOptions(), request);
    }
  }

  /**
   */
  public static final class CRAssetSecuritizationTransactionServiceFutureStub extends io.grpc.stub.AbstractFutureStub {
    private CRAssetSecuritizationTransactionServiceFutureStub(
        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
      super(channel, callOptions);
    }

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

    /**
     */
    public com.google.common.util.concurrent.ListenableFuture control(
        com.redhat.mercury.assetsecuritization.v10.api.crassetsecuritizationtransactionservice.CrAssetSecuritizationTransactionService.ControlRequest request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getControlMethod(), getCallOptions()), request);
    }

    /**
     */
    public com.google.common.util.concurrent.ListenableFuture exchange(
        com.redhat.mercury.assetsecuritization.v10.api.crassetsecuritizationtransactionservice.CrAssetSecuritizationTransactionService.ExchangeRequest request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getExchangeMethod(), getCallOptions()), request);
    }

    /**
     */
    public com.google.common.util.concurrent.ListenableFuture execute(
        com.redhat.mercury.assetsecuritization.v10.api.crassetsecuritizationtransactionservice.CrAssetSecuritizationTransactionService.ExecuteRequest request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getExecuteMethod(), getCallOptions()), request);
    }

    /**
     */
    public com.google.common.util.concurrent.ListenableFuture initiate(
        com.redhat.mercury.assetsecuritization.v10.api.crassetsecuritizationtransactionservice.CrAssetSecuritizationTransactionService.InitiateRequest request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getInitiateMethod(), getCallOptions()), request);
    }

    /**
     */
    public com.google.common.util.concurrent.ListenableFuture request(
        com.redhat.mercury.assetsecuritization.v10.api.crassetsecuritizationtransactionservice.CrAssetSecuritizationTransactionService.RequestRequest request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getRequestMethod(), getCallOptions()), request);
    }

    /**
     */
    public com.google.common.util.concurrent.ListenableFuture retrieve(
        com.redhat.mercury.assetsecuritization.v10.api.crassetsecuritizationtransactionservice.CrAssetSecuritizationTransactionService.RetrieveRequest request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getRetrieveMethod(), getCallOptions()), request);
    }

    /**
     */
    public com.google.common.util.concurrent.ListenableFuture update(
        com.redhat.mercury.assetsecuritization.v10.api.crassetsecuritizationtransactionservice.CrAssetSecuritizationTransactionService.UpdateRequest request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getUpdateMethod(), getCallOptions()), request);
    }
  }

  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_REQUEST = 4;
  private static final int METHODID_RETRIEVE = 5;
  private static final int METHODID_UPDATE = 6;

  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 CRAssetSecuritizationTransactionServiceImplBase serviceImpl;
    private final int methodId;

    MethodHandlers(CRAssetSecuritizationTransactionServiceImplBase 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_CONTROL:
          serviceImpl.control((com.redhat.mercury.assetsecuritization.v10.api.crassetsecuritizationtransactionservice.CrAssetSecuritizationTransactionService.ControlRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_EXCHANGE:
          serviceImpl.exchange((com.redhat.mercury.assetsecuritization.v10.api.crassetsecuritizationtransactionservice.CrAssetSecuritizationTransactionService.ExchangeRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_EXECUTE:
          serviceImpl.execute((com.redhat.mercury.assetsecuritization.v10.api.crassetsecuritizationtransactionservice.CrAssetSecuritizationTransactionService.ExecuteRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_INITIATE:
          serviceImpl.initiate((com.redhat.mercury.assetsecuritization.v10.api.crassetsecuritizationtransactionservice.CrAssetSecuritizationTransactionService.InitiateRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_REQUEST:
          serviceImpl.request((com.redhat.mercury.assetsecuritization.v10.api.crassetsecuritizationtransactionservice.CrAssetSecuritizationTransactionService.RequestRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_RETRIEVE:
          serviceImpl.retrieve((com.redhat.mercury.assetsecuritization.v10.api.crassetsecuritizationtransactionservice.CrAssetSecuritizationTransactionService.RetrieveRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_UPDATE:
          serviceImpl.update((com.redhat.mercury.assetsecuritization.v10.api.crassetsecuritizationtransactionservice.CrAssetSecuritizationTransactionService.UpdateRequest) 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 CRAssetSecuritizationTransactionServiceBaseDescriptorSupplier
      implements io.grpc.protobuf.ProtoFileDescriptorSupplier, io.grpc.protobuf.ProtoServiceDescriptorSupplier {
    CRAssetSecuritizationTransactionServiceBaseDescriptorSupplier() {}

    @java.lang.Override
    public com.google.protobuf.Descriptors.FileDescriptor getFileDescriptor() {
      return com.redhat.mercury.assetsecuritization.v10.api.crassetsecuritizationtransactionservice.CrAssetSecuritizationTransactionService.getDescriptor();
    }

    @java.lang.Override
    public com.google.protobuf.Descriptors.ServiceDescriptor getServiceDescriptor() {
      return getFileDescriptor().findServiceByName("CRAssetSecuritizationTransactionService");
    }
  }

  private static final class CRAssetSecuritizationTransactionServiceFileDescriptorSupplier
      extends CRAssetSecuritizationTransactionServiceBaseDescriptorSupplier {
    CRAssetSecuritizationTransactionServiceFileDescriptorSupplier() {}
  }

  private static final class CRAssetSecuritizationTransactionServiceMethodDescriptorSupplier
      extends CRAssetSecuritizationTransactionServiceBaseDescriptorSupplier
      implements io.grpc.protobuf.ProtoMethodDescriptorSupplier {
    private final String methodName;

    CRAssetSecuritizationTransactionServiceMethodDescriptorSupplier(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 (CRAssetSecuritizationTransactionServiceGrpc.class) {
        result = serviceDescriptor;
        if (result == null) {
          serviceDescriptor = result = io.grpc.ServiceDescriptor.newBuilder(SERVICE_NAME)
              .setSchemaDescriptor(new CRAssetSecuritizationTransactionServiceFileDescriptorSupplier())
              .addMethod(getControlMethod())
              .addMethod(getExchangeMethod())
              .addMethod(getExecuteMethod())
              .addMethod(getInitiateMethod())
              .addMethod(getRequestMethod())
              .addMethod(getRetrieveMethod())
              .addMethod(getUpdateMethod())
              .build();
        }
      }
    }
    return result;
  }
}




© 2015 - 2025 Weber Informatics LLC | Privacy Policy