• Home
• io.streamlayer
• sl-protofiles
• 5.118.0
• source code
• QuestionsGrpc.java

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

main.grpc.com.streamlayer.interactive.question.QuestionsGrpc Maven / Gradle / Ivy

package com.streamlayer.interactive.question;

import static io.grpc.MethodDescriptor.generateFullMethodName;

/**
 */
@javax.annotation.Generated(
    value = "by gRPC proto compiler (version 1.65.1)",
    comments = "Source: streamlayer/interactive/question/interactive.questions.proto")
@io.grpc.stub.annotations.GrpcGenerated
public final class QuestionsGrpc {

  private QuestionsGrpc() {}

  public static final java.lang.String SERVICE_NAME = "streamlayer.interactive.question.Questions";

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

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "Create",
      requestType = com.streamlayer.interactive.question.CreateRequest.class,
      responseType = com.streamlayer.interactive.question.CreateResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor getCreateMethod() {
    io.grpc.MethodDescriptor getCreateMethod;
    if ((getCreateMethod = QuestionsGrpc.getCreateMethod) == null) {
      synchronized (QuestionsGrpc.class) {
        if ((getCreateMethod = QuestionsGrpc.getCreateMethod) == null) {
          QuestionsGrpc.getCreateMethod = getCreateMethod =
              io.grpc.MethodDescriptor.newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "Create"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller(
                  com.streamlayer.interactive.question.CreateRequest.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller(
                  com.streamlayer.interactive.question.CreateResponse.getDefaultInstance()))
              .build();
        }
      }
    }
    return getCreateMethod;
  }

  private static volatile io.grpc.MethodDescriptor getDeleteMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "Delete",
      requestType = com.streamlayer.interactive.question.DeleteRequest.class,
      responseType = com.streamlayer.interactive.question.DeleteResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor getDeleteMethod() {
    io.grpc.MethodDescriptor getDeleteMethod;
    if ((getDeleteMethod = QuestionsGrpc.getDeleteMethod) == null) {
      synchronized (QuestionsGrpc.class) {
        if ((getDeleteMethod = QuestionsGrpc.getDeleteMethod) == null) {
          QuestionsGrpc.getDeleteMethod = getDeleteMethod =
              io.grpc.MethodDescriptor.newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "Delete"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller(
                  com.streamlayer.interactive.question.DeleteRequest.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller(
                  com.streamlayer.interactive.question.DeleteResponse.getDefaultInstance()))
              .build();
        }
      }
    }
    return getDeleteMethod;
  }

  private static volatile io.grpc.MethodDescriptor getRestoreMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "Restore",
      requestType = com.streamlayer.interactive.question.RestoreRequest.class,
      responseType = com.streamlayer.interactive.question.RestoreResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor getRestoreMethod() {
    io.grpc.MethodDescriptor getRestoreMethod;
    if ((getRestoreMethod = QuestionsGrpc.getRestoreMethod) == null) {
      synchronized (QuestionsGrpc.class) {
        if ((getRestoreMethod = QuestionsGrpc.getRestoreMethod) == null) {
          QuestionsGrpc.getRestoreMethod = getRestoreMethod =
              io.grpc.MethodDescriptor.newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "Restore"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller(
                  com.streamlayer.interactive.question.RestoreRequest.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller(
                  com.streamlayer.interactive.question.RestoreResponse.getDefaultInstance()))
              .build();
        }
      }
    }
    return getRestoreMethod;
  }

  private static volatile io.grpc.MethodDescriptor getUpdateMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "Update",
      requestType = com.streamlayer.interactive.question.UpdateRequest.class,
      responseType = com.streamlayer.interactive.question.UpdateResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor getUpdateMethod() {
    io.grpc.MethodDescriptor getUpdateMethod;
    if ((getUpdateMethod = QuestionsGrpc.getUpdateMethod) == null) {
      synchronized (QuestionsGrpc.class) {
        if ((getUpdateMethod = QuestionsGrpc.getUpdateMethod) == null) {
          QuestionsGrpc.getUpdateMethod = getUpdateMethod =
              io.grpc.MethodDescriptor.newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "Update"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller(
                  com.streamlayer.interactive.question.UpdateRequest.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller(
                  com.streamlayer.interactive.question.UpdateResponse.getDefaultInstance()))
              .build();
        }
      }
    }
    return getUpdateMethod;
  }

  private static volatile io.grpc.MethodDescriptor getListMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "List",
      requestType = com.streamlayer.interactive.question.ListRequest.class,
      responseType = com.streamlayer.interactive.question.ListResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor getListMethod() {
    io.grpc.MethodDescriptor getListMethod;
    if ((getListMethod = QuestionsGrpc.getListMethod) == null) {
      synchronized (QuestionsGrpc.class) {
        if ((getListMethod = QuestionsGrpc.getListMethod) == null) {
          QuestionsGrpc.getListMethod = getListMethod =
              io.grpc.MethodDescriptor.newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "List"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller(
                  com.streamlayer.interactive.question.ListRequest.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller(
                  com.streamlayer.interactive.question.ListResponse.getDefaultInstance()))
              .build();
        }
      }
    }
    return getListMethod;
  }

  private static volatile io.grpc.MethodDescriptor getSetStatusMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "SetStatus",
      requestType = com.streamlayer.interactive.question.SetStatusRequest.class,
      responseType = com.streamlayer.interactive.question.SetStatusResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor getSetStatusMethod() {
    io.grpc.MethodDescriptor getSetStatusMethod;
    if ((getSetStatusMethod = QuestionsGrpc.getSetStatusMethod) == null) {
      synchronized (QuestionsGrpc.class) {
        if ((getSetStatusMethod = QuestionsGrpc.getSetStatusMethod) == null) {
          QuestionsGrpc.getSetStatusMethod = getSetStatusMethod =
              io.grpc.MethodDescriptor.newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "SetStatus"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller(
                  com.streamlayer.interactive.question.SetStatusRequest.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller(
                  com.streamlayer.interactive.question.SetStatusResponse.getDefaultInstance()))
              .build();
        }
      }
    }
    return getSetStatusMethod;
  }

  private static volatile io.grpc.MethodDescriptor getSetMarketClosedMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "SetMarketClosed",
      requestType = com.streamlayer.interactive.question.SetMarketClosedRequest.class,
      responseType = com.streamlayer.interactive.question.SetMarketClosedResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor getSetMarketClosedMethod() {
    io.grpc.MethodDescriptor getSetMarketClosedMethod;
    if ((getSetMarketClosedMethod = QuestionsGrpc.getSetMarketClosedMethod) == null) {
      synchronized (QuestionsGrpc.class) {
        if ((getSetMarketClosedMethod = QuestionsGrpc.getSetMarketClosedMethod) == null) {
          QuestionsGrpc.getSetMarketClosedMethod = getSetMarketClosedMethod =
              io.grpc.MethodDescriptor.newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "SetMarketClosed"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller(
                  com.streamlayer.interactive.question.SetMarketClosedRequest.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller(
                  com.streamlayer.interactive.question.SetMarketClosedResponse.getDefaultInstance()))
              .build();
        }
      }
    }
    return getSetMarketClosedMethod;
  }

  private static volatile io.grpc.MethodDescriptor getSetPositionMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "SetPosition",
      requestType = com.streamlayer.interactive.question.SetPositionRequest.class,
      responseType = com.streamlayer.interactive.question.SetPositionResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor getSetPositionMethod() {
    io.grpc.MethodDescriptor getSetPositionMethod;
    if ((getSetPositionMethod = QuestionsGrpc.getSetPositionMethod) == null) {
      synchronized (QuestionsGrpc.class) {
        if ((getSetPositionMethod = QuestionsGrpc.getSetPositionMethod) == null) {
          QuestionsGrpc.getSetPositionMethod = getSetPositionMethod =
              io.grpc.MethodDescriptor.newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "SetPosition"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller(
                  com.streamlayer.interactive.question.SetPositionRequest.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller(
                  com.streamlayer.interactive.question.SetPositionResponse.getDefaultInstance()))
              .build();
        }
      }
    }
    return getSetPositionMethod;
  }

  private static volatile io.grpc.MethodDescriptor getSetCorrectAnswerMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "SetCorrectAnswer",
      requestType = com.streamlayer.interactive.question.SetCorrectAnswerRequest.class,
      responseType = com.streamlayer.interactive.question.SetCorrectAnswerResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor getSetCorrectAnswerMethod() {
    io.grpc.MethodDescriptor getSetCorrectAnswerMethod;
    if ((getSetCorrectAnswerMethod = QuestionsGrpc.getSetCorrectAnswerMethod) == null) {
      synchronized (QuestionsGrpc.class) {
        if ((getSetCorrectAnswerMethod = QuestionsGrpc.getSetCorrectAnswerMethod) == null) {
          QuestionsGrpc.getSetCorrectAnswerMethod = getSetCorrectAnswerMethod =
              io.grpc.MethodDescriptor.newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "SetCorrectAnswer"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller(
                  com.streamlayer.interactive.question.SetCorrectAnswerRequest.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller(
                  com.streamlayer.interactive.question.SetCorrectAnswerResponse.getDefaultInstance()))
              .build();
        }
      }
    }
    return getSetCorrectAnswerMethod;
  }

  private static volatile io.grpc.MethodDescriptor getStatsMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "Stats",
      requestType = com.streamlayer.interactive.question.StatsRequest.class,
      responseType = com.streamlayer.interactive.question.StatsResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor getStatsMethod() {
    io.grpc.MethodDescriptor getStatsMethod;
    if ((getStatsMethod = QuestionsGrpc.getStatsMethod) == null) {
      synchronized (QuestionsGrpc.class) {
        if ((getStatsMethod = QuestionsGrpc.getStatsMethod) == null) {
          QuestionsGrpc.getStatsMethod = getStatsMethod =
              io.grpc.MethodDescriptor.newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "Stats"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller(
                  com.streamlayer.interactive.question.StatsRequest.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller(
                  com.streamlayer.interactive.question.StatsResponse.getDefaultInstance()))
              .build();
        }
      }
    }
    return getStatsMethod;
  }

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

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

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

  /**
   */
  public interface AsyncService {

    /**
     */
    default void create(com.streamlayer.interactive.question.CreateRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getCreateMethod(), responseObserver);
    }

    /**
     */
    default void delete(com.streamlayer.interactive.question.DeleteRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getDeleteMethod(), responseObserver);
    }

    /**
     */
    default void restore(com.streamlayer.interactive.question.RestoreRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getRestoreMethod(), responseObserver);
    }

    /**
     */
    default void update(com.streamlayer.interactive.question.UpdateRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getUpdateMethod(), responseObserver);
    }

    /**
     */
    default void list(com.streamlayer.interactive.question.ListRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getListMethod(), responseObserver);
    }

    /**
     */
    default void setStatus(com.streamlayer.interactive.question.SetStatusRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getSetStatusMethod(), responseObserver);
    }

    /**
     */
    default void setMarketClosed(com.streamlayer.interactive.question.SetMarketClosedRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getSetMarketClosedMethod(), responseObserver);
    }

    /**
     */
    default void setPosition(com.streamlayer.interactive.question.SetPositionRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getSetPositionMethod(), responseObserver);
    }

    /**
     */
    default void setCorrectAnswer(com.streamlayer.interactive.question.SetCorrectAnswerRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getSetCorrectAnswerMethod(), responseObserver);
    }

    /**
     */
    default void stats(com.streamlayer.interactive.question.StatsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getStatsMethod(), responseObserver);
    }
  }

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

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

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

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

    /**
     */
    public void create(com.streamlayer.interactive.question.CreateRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getCreateMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     */
    public void delete(com.streamlayer.interactive.question.DeleteRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getDeleteMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     */
    public void restore(com.streamlayer.interactive.question.RestoreRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getRestoreMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     */
    public void update(com.streamlayer.interactive.question.UpdateRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getUpdateMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     */
    public void list(com.streamlayer.interactive.question.ListRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getListMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     */
    public void setStatus(com.streamlayer.interactive.question.SetStatusRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getSetStatusMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     */
    public void setMarketClosed(com.streamlayer.interactive.question.SetMarketClosedRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getSetMarketClosedMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     */
    public void setPosition(com.streamlayer.interactive.question.SetPositionRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getSetPositionMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     */
    public void setCorrectAnswer(com.streamlayer.interactive.question.SetCorrectAnswerRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getSetCorrectAnswerMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     */
    public void stats(com.streamlayer.interactive.question.StatsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getStatsMethod(), getCallOptions()), request, responseObserver);
    }
  }

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

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

    /**
     */
    public com.streamlayer.interactive.question.CreateResponse create(com.streamlayer.interactive.question.CreateRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getCreateMethod(), getCallOptions(), request);
    }

    /**
     */
    public com.streamlayer.interactive.question.DeleteResponse delete(com.streamlayer.interactive.question.DeleteRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getDeleteMethod(), getCallOptions(), request);
    }

    /**
     */
    public com.streamlayer.interactive.question.RestoreResponse restore(com.streamlayer.interactive.question.RestoreRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getRestoreMethod(), getCallOptions(), request);
    }

    /**
     */
    public com.streamlayer.interactive.question.UpdateResponse update(com.streamlayer.interactive.question.UpdateRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getUpdateMethod(), getCallOptions(), request);
    }

    /**
     */
    public com.streamlayer.interactive.question.ListResponse list(com.streamlayer.interactive.question.ListRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getListMethod(), getCallOptions(), request);
    }

    /**
     */
    public com.streamlayer.interactive.question.SetStatusResponse setStatus(com.streamlayer.interactive.question.SetStatusRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getSetStatusMethod(), getCallOptions(), request);
    }

    /**
     */
    public com.streamlayer.interactive.question.SetMarketClosedResponse setMarketClosed(com.streamlayer.interactive.question.SetMarketClosedRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getSetMarketClosedMethod(), getCallOptions(), request);
    }

    /**
     */
    public com.streamlayer.interactive.question.SetPositionResponse setPosition(com.streamlayer.interactive.question.SetPositionRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getSetPositionMethod(), getCallOptions(), request);
    }

    /**
     */
    public com.streamlayer.interactive.question.SetCorrectAnswerResponse setCorrectAnswer(com.streamlayer.interactive.question.SetCorrectAnswerRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getSetCorrectAnswerMethod(), getCallOptions(), request);
    }

    /**
     */
    public com.streamlayer.interactive.question.StatsResponse stats(com.streamlayer.interactive.question.StatsRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getStatsMethod(), getCallOptions(), request);
    }
  }

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

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

    /**
     */
    public com.google.common.util.concurrent.ListenableFuture create(
        com.streamlayer.interactive.question.CreateRequest request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getCreateMethod(), getCallOptions()), request);
    }

    /**
     */
    public com.google.common.util.concurrent.ListenableFuture delete(
        com.streamlayer.interactive.question.DeleteRequest request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getDeleteMethod(), getCallOptions()), request);
    }

    /**
     */
    public com.google.common.util.concurrent.ListenableFuture restore(
        com.streamlayer.interactive.question.RestoreRequest request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getRestoreMethod(), getCallOptions()), request);
    }

    /**
     */
    public com.google.common.util.concurrent.ListenableFuture update(
        com.streamlayer.interactive.question.UpdateRequest request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getUpdateMethod(), getCallOptions()), request);
    }

    /**
     */
    public com.google.common.util.concurrent.ListenableFuture list(
        com.streamlayer.interactive.question.ListRequest request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getListMethod(), getCallOptions()), request);
    }

    /**
     */
    public com.google.common.util.concurrent.ListenableFuture setStatus(
        com.streamlayer.interactive.question.SetStatusRequest request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getSetStatusMethod(), getCallOptions()), request);
    }

    /**
     */
    public com.google.common.util.concurrent.ListenableFuture setMarketClosed(
        com.streamlayer.interactive.question.SetMarketClosedRequest request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getSetMarketClosedMethod(), getCallOptions()), request);
    }

    /**
     */
    public com.google.common.util.concurrent.ListenableFuture setPosition(
        com.streamlayer.interactive.question.SetPositionRequest request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getSetPositionMethod(), getCallOptions()), request);
    }

    /**
     */
    public com.google.common.util.concurrent.ListenableFuture setCorrectAnswer(
        com.streamlayer.interactive.question.SetCorrectAnswerRequest request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getSetCorrectAnswerMethod(), getCallOptions()), request);
    }

    /**
     */
    public com.google.common.util.concurrent.ListenableFuture stats(
        com.streamlayer.interactive.question.StatsRequest request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getStatsMethod(), getCallOptions()), request);
    }
  }

  private static final int METHODID_CREATE = 0;
  private static final int METHODID_DELETE = 1;
  private static final int METHODID_RESTORE = 2;
  private static final int METHODID_UPDATE = 3;
  private static final int METHODID_LIST = 4;
  private static final int METHODID_SET_STATUS = 5;
  private static final int METHODID_SET_MARKET_CLOSED = 6;
  private static final int METHODID_SET_POSITION = 7;
  private static final int METHODID_SET_CORRECT_ANSWER = 8;
  private static final int METHODID_STATS = 9;

  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_CREATE:
          serviceImpl.create((com.streamlayer.interactive.question.CreateRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_DELETE:
          serviceImpl.delete((com.streamlayer.interactive.question.DeleteRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_RESTORE:
          serviceImpl.restore((com.streamlayer.interactive.question.RestoreRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_UPDATE:
          serviceImpl.update((com.streamlayer.interactive.question.UpdateRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_LIST:
          serviceImpl.list((com.streamlayer.interactive.question.ListRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_SET_STATUS:
          serviceImpl.setStatus((com.streamlayer.interactive.question.SetStatusRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_SET_MARKET_CLOSED:
          serviceImpl.setMarketClosed((com.streamlayer.interactive.question.SetMarketClosedRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_SET_POSITION:
          serviceImpl.setPosition((com.streamlayer.interactive.question.SetPositionRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_SET_CORRECT_ANSWER:
          serviceImpl.setCorrectAnswer((com.streamlayer.interactive.question.SetCorrectAnswerRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_STATS:
          serviceImpl.stats((com.streamlayer.interactive.question.StatsRequest) 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(
          getCreateMethod(),
          io.grpc.stub.ServerCalls.asyncUnaryCall(
            new MethodHandlers<
              com.streamlayer.interactive.question.CreateRequest,
              com.streamlayer.interactive.question.CreateResponse>(
                service, METHODID_CREATE)))
        .addMethod(
          getDeleteMethod(),
          io.grpc.stub.ServerCalls.asyncUnaryCall(
            new MethodHandlers<
              com.streamlayer.interactive.question.DeleteRequest,
              com.streamlayer.interactive.question.DeleteResponse>(
                service, METHODID_DELETE)))
        .addMethod(
          getRestoreMethod(),
          io.grpc.stub.ServerCalls.asyncUnaryCall(
            new MethodHandlers<
              com.streamlayer.interactive.question.RestoreRequest,
              com.streamlayer.interactive.question.RestoreResponse>(
                service, METHODID_RESTORE)))
        .addMethod(
          getUpdateMethod(),
          io.grpc.stub.ServerCalls.asyncUnaryCall(
            new MethodHandlers<
              com.streamlayer.interactive.question.UpdateRequest,
              com.streamlayer.interactive.question.UpdateResponse>(
                service, METHODID_UPDATE)))
        .addMethod(
          getListMethod(),
          io.grpc.stub.ServerCalls.asyncUnaryCall(
            new MethodHandlers<
              com.streamlayer.interactive.question.ListRequest,
              com.streamlayer.interactive.question.ListResponse>(
                service, METHODID_LIST)))
        .addMethod(
          getSetStatusMethod(),
          io.grpc.stub.ServerCalls.asyncUnaryCall(
            new MethodHandlers<
              com.streamlayer.interactive.question.SetStatusRequest,
              com.streamlayer.interactive.question.SetStatusResponse>(
                service, METHODID_SET_STATUS)))
        .addMethod(
          getSetMarketClosedMethod(),
          io.grpc.stub.ServerCalls.asyncUnaryCall(
            new MethodHandlers<
              com.streamlayer.interactive.question.SetMarketClosedRequest,
              com.streamlayer.interactive.question.SetMarketClosedResponse>(
                service, METHODID_SET_MARKET_CLOSED)))
        .addMethod(
          getSetPositionMethod(),
          io.grpc.stub.ServerCalls.asyncUnaryCall(
            new MethodHandlers<
              com.streamlayer.interactive.question.SetPositionRequest,
              com.streamlayer.interactive.question.SetPositionResponse>(
                service, METHODID_SET_POSITION)))
        .addMethod(
          getSetCorrectAnswerMethod(),
          io.grpc.stub.ServerCalls.asyncUnaryCall(
            new MethodHandlers<
              com.streamlayer.interactive.question.SetCorrectAnswerRequest,
              com.streamlayer.interactive.question.SetCorrectAnswerResponse>(
                service, METHODID_SET_CORRECT_ANSWER)))
        .addMethod(
          getStatsMethod(),
          io.grpc.stub.ServerCalls.asyncUnaryCall(
            new MethodHandlers<
              com.streamlayer.interactive.question.StatsRequest,
              com.streamlayer.interactive.question.StatsResponse>(
                service, METHODID_STATS)))
        .build();
  }

  private static volatile io.grpc.ServiceDescriptor serviceDescriptor;

  public static io.grpc.ServiceDescriptor getServiceDescriptor() {
    io.grpc.ServiceDescriptor result = serviceDescriptor;
    if (result == null) {
      synchronized (QuestionsGrpc.class) {
        result = serviceDescriptor;
        if (result == null) {
          serviceDescriptor = result = io.grpc.ServiceDescriptor.newBuilder(SERVICE_NAME)
              .addMethod(getCreateMethod())
              .addMethod(getDeleteMethod())
              .addMethod(getRestoreMethod())
              .addMethod(getUpdateMethod())
              .addMethod(getListMethod())
              .addMethod(getSetStatusMethod())
              .addMethod(getSetMarketClosedMethod())
              .addMethod(getSetPositionMethod())
              .addMethod(getSetCorrectAnswerMethod())
              .addMethod(getStatsMethod())
              .build();
        }
      }
    }
    return result;
  }
}