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

com.figure.block.api.proto.groups.GroupServiceGrpc Maven / Gradle / Ivy

The newest version!
package com.figure.block.api.proto.groups;

import static io.grpc.MethodDescriptor.generateFullMethodName;

/**
 */
@javax.annotation.Generated(
    value = "by gRPC proto compiler (version 1.56.0)",
    comments = "Source: groups/group-server.proto")
@io.grpc.stub.annotations.GrpcGenerated
public final class GroupServiceGrpc {

  private GroupServiceGrpc() {}

  public static final String SERVICE_NAME = "api.groups.GroupService";

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

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "LatestGroupState",
      requestType = com.figure.block.api.proto.groups.GroupServer.LatestGroupStateRequest.class,
      responseType = com.figure.block.api.proto.groups.GroupServer.LatestGroupStateResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor getLatestGroupStateMethod() {
    io.grpc.MethodDescriptor getLatestGroupStateMethod;
    if ((getLatestGroupStateMethod = GroupServiceGrpc.getLatestGroupStateMethod) == null) {
      synchronized (GroupServiceGrpc.class) {
        if ((getLatestGroupStateMethod = GroupServiceGrpc.getLatestGroupStateMethod) == null) {
          GroupServiceGrpc.getLatestGroupStateMethod = getLatestGroupStateMethod =
              io.grpc.MethodDescriptor.newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "LatestGroupState"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  com.figure.block.api.proto.groups.GroupServer.LatestGroupStateRequest.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  com.figure.block.api.proto.groups.GroupServer.LatestGroupStateResponse.getDefaultInstance()))
              .setSchemaDescriptor(new GroupServiceMethodDescriptorSupplier("LatestGroupState"))
              .build();
        }
      }
    }
    return getLatestGroupStateMethod;
  }

  private static volatile io.grpc.MethodDescriptor getGroupStateAtHeightMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "GroupStateAtHeight",
      requestType = com.figure.block.api.proto.groups.GroupServer.GroupStateAtHeightRequest.class,
      responseType = com.figure.block.api.proto.groups.GroupServer.GroupStateAtHeightResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor getGroupStateAtHeightMethod() {
    io.grpc.MethodDescriptor getGroupStateAtHeightMethod;
    if ((getGroupStateAtHeightMethod = GroupServiceGrpc.getGroupStateAtHeightMethod) == null) {
      synchronized (GroupServiceGrpc.class) {
        if ((getGroupStateAtHeightMethod = GroupServiceGrpc.getGroupStateAtHeightMethod) == null) {
          GroupServiceGrpc.getGroupStateAtHeightMethod = getGroupStateAtHeightMethod =
              io.grpc.MethodDescriptor.newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "GroupStateAtHeight"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  com.figure.block.api.proto.groups.GroupServer.GroupStateAtHeightRequest.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  com.figure.block.api.proto.groups.GroupServer.GroupStateAtHeightResponse.getDefaultInstance()))
              .setSchemaDescriptor(new GroupServiceMethodDescriptorSupplier("GroupStateAtHeight"))
              .build();
        }
      }
    }
    return getGroupStateAtHeightMethod;
  }

  private static volatile io.grpc.MethodDescriptor getAllGroupStatesMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "AllGroupStates",
      requestType = com.figure.block.api.proto.groups.GroupServer.AllGroupStatesRequest.class,
      responseType = com.figure.block.api.proto.groups.GroupServer.AllGroupStatesResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor getAllGroupStatesMethod() {
    io.grpc.MethodDescriptor getAllGroupStatesMethod;
    if ((getAllGroupStatesMethod = GroupServiceGrpc.getAllGroupStatesMethod) == null) {
      synchronized (GroupServiceGrpc.class) {
        if ((getAllGroupStatesMethod = GroupServiceGrpc.getAllGroupStatesMethod) == null) {
          GroupServiceGrpc.getAllGroupStatesMethod = getAllGroupStatesMethod =
              io.grpc.MethodDescriptor.newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "AllGroupStates"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  com.figure.block.api.proto.groups.GroupServer.AllGroupStatesRequest.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  com.figure.block.api.proto.groups.GroupServer.AllGroupStatesResponse.getDefaultInstance()))
              .setSchemaDescriptor(new GroupServiceMethodDescriptorSupplier("AllGroupStates"))
              .build();
        }
      }
    }
    return getAllGroupStatesMethod;
  }

  private static volatile io.grpc.MethodDescriptor getLatestGroupStatesByAdminMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "LatestGroupStatesByAdmin",
      requestType = com.figure.block.api.proto.groups.GroupServer.LatestGroupStatesByAdminRequest.class,
      responseType = com.figure.block.api.proto.groups.GroupServer.LatestGroupStatesByAdminResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor getLatestGroupStatesByAdminMethod() {
    io.grpc.MethodDescriptor getLatestGroupStatesByAdminMethod;
    if ((getLatestGroupStatesByAdminMethod = GroupServiceGrpc.getLatestGroupStatesByAdminMethod) == null) {
      synchronized (GroupServiceGrpc.class) {
        if ((getLatestGroupStatesByAdminMethod = GroupServiceGrpc.getLatestGroupStatesByAdminMethod) == null) {
          GroupServiceGrpc.getLatestGroupStatesByAdminMethod = getLatestGroupStatesByAdminMethod =
              io.grpc.MethodDescriptor.newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "LatestGroupStatesByAdmin"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  com.figure.block.api.proto.groups.GroupServer.LatestGroupStatesByAdminRequest.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  com.figure.block.api.proto.groups.GroupServer.LatestGroupStatesByAdminResponse.getDefaultInstance()))
              .setSchemaDescriptor(new GroupServiceMethodDescriptorSupplier("LatestGroupStatesByAdmin"))
              .build();
        }
      }
    }
    return getLatestGroupStatesByAdminMethod;
  }

  private static volatile io.grpc.MethodDescriptor getLatestGroupStatesByMemberMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "LatestGroupStatesByMember",
      requestType = com.figure.block.api.proto.groups.GroupServer.LatestGroupStatesByMemberRequest.class,
      responseType = com.figure.block.api.proto.groups.GroupServer.LatestGroupStatesByMemberResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor getLatestGroupStatesByMemberMethod() {
    io.grpc.MethodDescriptor getLatestGroupStatesByMemberMethod;
    if ((getLatestGroupStatesByMemberMethod = GroupServiceGrpc.getLatestGroupStatesByMemberMethod) == null) {
      synchronized (GroupServiceGrpc.class) {
        if ((getLatestGroupStatesByMemberMethod = GroupServiceGrpc.getLatestGroupStatesByMemberMethod) == null) {
          GroupServiceGrpc.getLatestGroupStatesByMemberMethod = getLatestGroupStatesByMemberMethod =
              io.grpc.MethodDescriptor.newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "LatestGroupStatesByMember"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  com.figure.block.api.proto.groups.GroupServer.LatestGroupStatesByMemberRequest.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  com.figure.block.api.proto.groups.GroupServer.LatestGroupStatesByMemberResponse.getDefaultInstance()))
              .setSchemaDescriptor(new GroupServiceMethodDescriptorSupplier("LatestGroupStatesByMember"))
              .build();
        }
      }
    }
    return getLatestGroupStatesByMemberMethod;
  }

  private static volatile io.grpc.MethodDescriptor getStreamLatestGroupStatesMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "StreamLatestGroupStates",
      requestType = com.figure.block.api.proto.groups.GroupServer.StreamLatestGroupStatesRequest.class,
      responseType = com.figure.block.api.proto.groups.GroupServer.StreamLatestGroupStatesResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.SERVER_STREAMING)
  public static io.grpc.MethodDescriptor getStreamLatestGroupStatesMethod() {
    io.grpc.MethodDescriptor getStreamLatestGroupStatesMethod;
    if ((getStreamLatestGroupStatesMethod = GroupServiceGrpc.getStreamLatestGroupStatesMethod) == null) {
      synchronized (GroupServiceGrpc.class) {
        if ((getStreamLatestGroupStatesMethod = GroupServiceGrpc.getStreamLatestGroupStatesMethod) == null) {
          GroupServiceGrpc.getStreamLatestGroupStatesMethod = getStreamLatestGroupStatesMethod =
              io.grpc.MethodDescriptor.newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.SERVER_STREAMING)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "StreamLatestGroupStates"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  com.figure.block.api.proto.groups.GroupServer.StreamLatestGroupStatesRequest.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  com.figure.block.api.proto.groups.GroupServer.StreamLatestGroupStatesResponse.getDefaultInstance()))
              .setSchemaDescriptor(new GroupServiceMethodDescriptorSupplier("StreamLatestGroupStates"))
              .build();
        }
      }
    }
    return getStreamLatestGroupStatesMethod;
  }

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

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

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

  /**
   */
  public interface AsyncService {

    /**
     */
    default void latestGroupState(com.figure.block.api.proto.groups.GroupServer.LatestGroupStateRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getLatestGroupStateMethod(), responseObserver);
    }

    /**
     */
    default void groupStateAtHeight(com.figure.block.api.proto.groups.GroupServer.GroupStateAtHeightRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getGroupStateAtHeightMethod(), responseObserver);
    }

    /**
     */
    default void allGroupStates(com.figure.block.api.proto.groups.GroupServer.AllGroupStatesRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getAllGroupStatesMethod(), responseObserver);
    }

    /**
     */
    default void latestGroupStatesByAdmin(com.figure.block.api.proto.groups.GroupServer.LatestGroupStatesByAdminRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getLatestGroupStatesByAdminMethod(), responseObserver);
    }

    /**
     */
    default void latestGroupStatesByMember(com.figure.block.api.proto.groups.GroupServer.LatestGroupStatesByMemberRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getLatestGroupStatesByMemberMethod(), responseObserver);
    }

    /**
     */
    default void streamLatestGroupStates(com.figure.block.api.proto.groups.GroupServer.StreamLatestGroupStatesRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getStreamLatestGroupStatesMethod(), responseObserver);
    }
  }

  /**
   * Base class for the server implementation of the service GroupService.
   */
  public static abstract class GroupServiceImplBase
      implements io.grpc.BindableService, AsyncService {

    @java.lang.Override public final io.grpc.ServerServiceDefinition bindService() {
      return GroupServiceGrpc.bindService(this);
    }
  }

  /**
   * A stub to allow clients to do asynchronous rpc calls to service GroupService.
   */
  public static final class GroupServiceStub
      extends io.grpc.stub.AbstractAsyncStub {
    private GroupServiceStub(
        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
      super(channel, callOptions);
    }

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

    /**
     */
    public void latestGroupState(com.figure.block.api.proto.groups.GroupServer.LatestGroupStateRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getLatestGroupStateMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     */
    public void groupStateAtHeight(com.figure.block.api.proto.groups.GroupServer.GroupStateAtHeightRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getGroupStateAtHeightMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     */
    public void allGroupStates(com.figure.block.api.proto.groups.GroupServer.AllGroupStatesRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getAllGroupStatesMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     */
    public void latestGroupStatesByAdmin(com.figure.block.api.proto.groups.GroupServer.LatestGroupStatesByAdminRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getLatestGroupStatesByAdminMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     */
    public void latestGroupStatesByMember(com.figure.block.api.proto.groups.GroupServer.LatestGroupStatesByMemberRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getLatestGroupStatesByMemberMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     */
    public void streamLatestGroupStates(com.figure.block.api.proto.groups.GroupServer.StreamLatestGroupStatesRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ClientCalls.asyncServerStreamingCall(
          getChannel().newCall(getStreamLatestGroupStatesMethod(), getCallOptions()), request, responseObserver);
    }
  }

  /**
   * A stub to allow clients to do synchronous rpc calls to service GroupService.
   */
  public static final class GroupServiceBlockingStub
      extends io.grpc.stub.AbstractBlockingStub {
    private GroupServiceBlockingStub(
        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
      super(channel, callOptions);
    }

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

    /**
     */
    public com.figure.block.api.proto.groups.GroupServer.LatestGroupStateResponse latestGroupState(com.figure.block.api.proto.groups.GroupServer.LatestGroupStateRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getLatestGroupStateMethod(), getCallOptions(), request);
    }

    /**
     */
    public com.figure.block.api.proto.groups.GroupServer.GroupStateAtHeightResponse groupStateAtHeight(com.figure.block.api.proto.groups.GroupServer.GroupStateAtHeightRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getGroupStateAtHeightMethod(), getCallOptions(), request);
    }

    /**
     */
    public com.figure.block.api.proto.groups.GroupServer.AllGroupStatesResponse allGroupStates(com.figure.block.api.proto.groups.GroupServer.AllGroupStatesRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getAllGroupStatesMethod(), getCallOptions(), request);
    }

    /**
     */
    public com.figure.block.api.proto.groups.GroupServer.LatestGroupStatesByAdminResponse latestGroupStatesByAdmin(com.figure.block.api.proto.groups.GroupServer.LatestGroupStatesByAdminRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getLatestGroupStatesByAdminMethod(), getCallOptions(), request);
    }

    /**
     */
    public com.figure.block.api.proto.groups.GroupServer.LatestGroupStatesByMemberResponse latestGroupStatesByMember(com.figure.block.api.proto.groups.GroupServer.LatestGroupStatesByMemberRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getLatestGroupStatesByMemberMethod(), getCallOptions(), request);
    }

    /**
     */
    public java.util.Iterator streamLatestGroupStates(
        com.figure.block.api.proto.groups.GroupServer.StreamLatestGroupStatesRequest request) {
      return io.grpc.stub.ClientCalls.blockingServerStreamingCall(
          getChannel(), getStreamLatestGroupStatesMethod(), getCallOptions(), request);
    }
  }

  /**
   * A stub to allow clients to do ListenableFuture-style rpc calls to service GroupService.
   */
  public static final class GroupServiceFutureStub
      extends io.grpc.stub.AbstractFutureStub {
    private GroupServiceFutureStub(
        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
      super(channel, callOptions);
    }

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

    /**
     */
    public com.google.common.util.concurrent.ListenableFuture latestGroupState(
        com.figure.block.api.proto.groups.GroupServer.LatestGroupStateRequest request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getLatestGroupStateMethod(), getCallOptions()), request);
    }

    /**
     */
    public com.google.common.util.concurrent.ListenableFuture groupStateAtHeight(
        com.figure.block.api.proto.groups.GroupServer.GroupStateAtHeightRequest request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getGroupStateAtHeightMethod(), getCallOptions()), request);
    }

    /**
     */
    public com.google.common.util.concurrent.ListenableFuture allGroupStates(
        com.figure.block.api.proto.groups.GroupServer.AllGroupStatesRequest request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getAllGroupStatesMethod(), getCallOptions()), request);
    }

    /**
     */
    public com.google.common.util.concurrent.ListenableFuture latestGroupStatesByAdmin(
        com.figure.block.api.proto.groups.GroupServer.LatestGroupStatesByAdminRequest request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getLatestGroupStatesByAdminMethod(), getCallOptions()), request);
    }

    /**
     */
    public com.google.common.util.concurrent.ListenableFuture latestGroupStatesByMember(
        com.figure.block.api.proto.groups.GroupServer.LatestGroupStatesByMemberRequest request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getLatestGroupStatesByMemberMethod(), getCallOptions()), request);
    }
  }

  private static final int METHODID_LATEST_GROUP_STATE = 0;
  private static final int METHODID_GROUP_STATE_AT_HEIGHT = 1;
  private static final int METHODID_ALL_GROUP_STATES = 2;
  private static final int METHODID_LATEST_GROUP_STATES_BY_ADMIN = 3;
  private static final int METHODID_LATEST_GROUP_STATES_BY_MEMBER = 4;
  private static final int METHODID_STREAM_LATEST_GROUP_STATES = 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 AsyncService serviceImpl;
    private final int methodId;

    MethodHandlers(AsyncService 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_LATEST_GROUP_STATE:
          serviceImpl.latestGroupState((com.figure.block.api.proto.groups.GroupServer.LatestGroupStateRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_GROUP_STATE_AT_HEIGHT:
          serviceImpl.groupStateAtHeight((com.figure.block.api.proto.groups.GroupServer.GroupStateAtHeightRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_ALL_GROUP_STATES:
          serviceImpl.allGroupStates((com.figure.block.api.proto.groups.GroupServer.AllGroupStatesRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_LATEST_GROUP_STATES_BY_ADMIN:
          serviceImpl.latestGroupStatesByAdmin((com.figure.block.api.proto.groups.GroupServer.LatestGroupStatesByAdminRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_LATEST_GROUP_STATES_BY_MEMBER:
          serviceImpl.latestGroupStatesByMember((com.figure.block.api.proto.groups.GroupServer.LatestGroupStatesByMemberRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_STREAM_LATEST_GROUP_STATES:
          serviceImpl.streamLatestGroupStates((com.figure.block.api.proto.groups.GroupServer.StreamLatestGroupStatesRequest) 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();
      }
    }
  }

  public static final io.grpc.ServerServiceDefinition bindService(AsyncService service) {
    return io.grpc.ServerServiceDefinition.builder(getServiceDescriptor())
        .addMethod(
          getLatestGroupStateMethod(),
          io.grpc.stub.ServerCalls.asyncUnaryCall(
            new MethodHandlers<
              com.figure.block.api.proto.groups.GroupServer.LatestGroupStateRequest,
              com.figure.block.api.proto.groups.GroupServer.LatestGroupStateResponse>(
                service, METHODID_LATEST_GROUP_STATE)))
        .addMethod(
          getGroupStateAtHeightMethod(),
          io.grpc.stub.ServerCalls.asyncUnaryCall(
            new MethodHandlers<
              com.figure.block.api.proto.groups.GroupServer.GroupStateAtHeightRequest,
              com.figure.block.api.proto.groups.GroupServer.GroupStateAtHeightResponse>(
                service, METHODID_GROUP_STATE_AT_HEIGHT)))
        .addMethod(
          getAllGroupStatesMethod(),
          io.grpc.stub.ServerCalls.asyncUnaryCall(
            new MethodHandlers<
              com.figure.block.api.proto.groups.GroupServer.AllGroupStatesRequest,
              com.figure.block.api.proto.groups.GroupServer.AllGroupStatesResponse>(
                service, METHODID_ALL_GROUP_STATES)))
        .addMethod(
          getLatestGroupStatesByAdminMethod(),
          io.grpc.stub.ServerCalls.asyncUnaryCall(
            new MethodHandlers<
              com.figure.block.api.proto.groups.GroupServer.LatestGroupStatesByAdminRequest,
              com.figure.block.api.proto.groups.GroupServer.LatestGroupStatesByAdminResponse>(
                service, METHODID_LATEST_GROUP_STATES_BY_ADMIN)))
        .addMethod(
          getLatestGroupStatesByMemberMethod(),
          io.grpc.stub.ServerCalls.asyncUnaryCall(
            new MethodHandlers<
              com.figure.block.api.proto.groups.GroupServer.LatestGroupStatesByMemberRequest,
              com.figure.block.api.proto.groups.GroupServer.LatestGroupStatesByMemberResponse>(
                service, METHODID_LATEST_GROUP_STATES_BY_MEMBER)))
        .addMethod(
          getStreamLatestGroupStatesMethod(),
          io.grpc.stub.ServerCalls.asyncServerStreamingCall(
            new MethodHandlers<
              com.figure.block.api.proto.groups.GroupServer.StreamLatestGroupStatesRequest,
              com.figure.block.api.proto.groups.GroupServer.StreamLatestGroupStatesResponse>(
                service, METHODID_STREAM_LATEST_GROUP_STATES)))
        .build();
  }

  private static abstract class GroupServiceBaseDescriptorSupplier
      implements io.grpc.protobuf.ProtoFileDescriptorSupplier, io.grpc.protobuf.ProtoServiceDescriptorSupplier {
    GroupServiceBaseDescriptorSupplier() {}

    @java.lang.Override
    public com.google.protobuf.Descriptors.FileDescriptor getFileDescriptor() {
      return com.figure.block.api.proto.groups.GroupServer.getDescriptor();
    }

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

  private static final class GroupServiceFileDescriptorSupplier
      extends GroupServiceBaseDescriptorSupplier {
    GroupServiceFileDescriptorSupplier() {}
  }

  private static final class GroupServiceMethodDescriptorSupplier
      extends GroupServiceBaseDescriptorSupplier
      implements io.grpc.protobuf.ProtoMethodDescriptorSupplier {
    private final String methodName;

    GroupServiceMethodDescriptorSupplier(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 (GroupServiceGrpc.class) {
        result = serviceDescriptor;
        if (result == null) {
          serviceDescriptor = result = io.grpc.ServiceDescriptor.newBuilder(SERVICE_NAME)
              .setSchemaDescriptor(new GroupServiceFileDescriptorSupplier())
              .addMethod(getLatestGroupStateMethod())
              .addMethod(getGroupStateAtHeightMethod())
              .addMethod(getAllGroupStatesMethod())
              .addMethod(getLatestGroupStatesByAdminMethod())
              .addMethod(getLatestGroupStatesByMemberMethod())
              .addMethod(getStreamLatestGroupStatesMethod())
              .build();
        }
      }
    }
    return result;
  }
}




© 2015 - 2024 Weber Informatics LLC | Privacy Policy