package cmvr.api;

import static io.grpc.MethodDescriptor.generateFullMethodName;

/**
 */
@javax.annotation.Generated(
    value = "by gRPC proto compiler (version 1.52.0)",
    comments = "Source: cmvr/api/system_service.proto")
@io.grpc.stub.annotations.GrpcGenerated
public final class SystemServiceGrpc {

  private SystemServiceGrpc() {}

  public static final String SERVICE_NAME = "cmvr.api.SystemService";

  // Static method descriptors that strictly reflect the proto.
  private static volatile io.grpc.MethodDescriptor<cmvr.api.SystemCommand.GetSystemInfoCommand.Request,
      cmvr.api.SystemCommand.GetSystemInfoCommand.Feedback> getGetSystemInfoMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "GetSystemInfo",
      requestType = cmvr.api.SystemCommand.GetSystemInfoCommand.Request.class,
      responseType = cmvr.api.SystemCommand.GetSystemInfoCommand.Feedback.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor<cmvr.api.SystemCommand.GetSystemInfoCommand.Request,
      cmvr.api.SystemCommand.GetSystemInfoCommand.Feedback> getGetSystemInfoMethod() {
    io.grpc.MethodDescriptor<cmvr.api.SystemCommand.GetSystemInfoCommand.Request, cmvr.api.SystemCommand.GetSystemInfoCommand.Feedback> getGetSystemInfoMethod;
    if ((getGetSystemInfoMethod = SystemServiceGrpc.getGetSystemInfoMethod) == null) {
      synchronized (SystemServiceGrpc.class) {
        if ((getGetSystemInfoMethod = SystemServiceGrpc.getGetSystemInfoMethod) == null) {
          SystemServiceGrpc.getGetSystemInfoMethod = getGetSystemInfoMethod =
              io.grpc.MethodDescriptor.<cmvr.api.SystemCommand.GetSystemInfoCommand.Request, cmvr.api.SystemCommand.GetSystemInfoCommand.Feedback>newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "GetSystemInfo"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  cmvr.api.SystemCommand.GetSystemInfoCommand.Request.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  cmvr.api.SystemCommand.GetSystemInfoCommand.Feedback.getDefaultInstance()))
              .setSchemaDescriptor(new SystemServiceMethodDescriptorSupplier("GetSystemInfo"))
              .build();
        }
      }
    }
    return getGetSystemInfoMethod;
  }

  private static volatile io.grpc.MethodDescriptor<cmvr.api.SystemCommand.GetSystemStatusCommand.Request,
      cmvr.api.SystemCommand.GetSystemStatusCommand.Feedback> getGetSystemStatusMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "GetSystemStatus",
      requestType = cmvr.api.SystemCommand.GetSystemStatusCommand.Request.class,
      responseType = cmvr.api.SystemCommand.GetSystemStatusCommand.Feedback.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor<cmvr.api.SystemCommand.GetSystemStatusCommand.Request,
      cmvr.api.SystemCommand.GetSystemStatusCommand.Feedback> getGetSystemStatusMethod() {
    io.grpc.MethodDescriptor<cmvr.api.SystemCommand.GetSystemStatusCommand.Request, cmvr.api.SystemCommand.GetSystemStatusCommand.Feedback> getGetSystemStatusMethod;
    if ((getGetSystemStatusMethod = SystemServiceGrpc.getGetSystemStatusMethod) == null) {
      synchronized (SystemServiceGrpc.class) {
        if ((getGetSystemStatusMethod = SystemServiceGrpc.getGetSystemStatusMethod) == null) {
          SystemServiceGrpc.getGetSystemStatusMethod = getGetSystemStatusMethod =
              io.grpc.MethodDescriptor.<cmvr.api.SystemCommand.GetSystemStatusCommand.Request, cmvr.api.SystemCommand.GetSystemStatusCommand.Feedback>newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "GetSystemStatus"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  cmvr.api.SystemCommand.GetSystemStatusCommand.Request.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  cmvr.api.SystemCommand.GetSystemStatusCommand.Feedback.getDefaultInstance()))
              .setSchemaDescriptor(new SystemServiceMethodDescriptorSupplier("GetSystemStatus"))
              .build();
        }
      }
    }
    return getGetSystemStatusMethod;
  }

  private static volatile io.grpc.MethodDescriptor<cmvr.api.SystemCommand.UpdateParamsCommand.Request,
      cmvr.api.SystemCommand.UpdateParamsCommand.Feedback> getUpdateParamsMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "UpdateParams",
      requestType = cmvr.api.SystemCommand.UpdateParamsCommand.Request.class,
      responseType = cmvr.api.SystemCommand.UpdateParamsCommand.Feedback.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor<cmvr.api.SystemCommand.UpdateParamsCommand.Request,
      cmvr.api.SystemCommand.UpdateParamsCommand.Feedback> getUpdateParamsMethod() {
    io.grpc.MethodDescriptor<cmvr.api.SystemCommand.UpdateParamsCommand.Request, cmvr.api.SystemCommand.UpdateParamsCommand.Feedback> getUpdateParamsMethod;
    if ((getUpdateParamsMethod = SystemServiceGrpc.getUpdateParamsMethod) == null) {
      synchronized (SystemServiceGrpc.class) {
        if ((getUpdateParamsMethod = SystemServiceGrpc.getUpdateParamsMethod) == null) {
          SystemServiceGrpc.getUpdateParamsMethod = getUpdateParamsMethod =
              io.grpc.MethodDescriptor.<cmvr.api.SystemCommand.UpdateParamsCommand.Request, cmvr.api.SystemCommand.UpdateParamsCommand.Feedback>newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "UpdateParams"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  cmvr.api.SystemCommand.UpdateParamsCommand.Request.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  cmvr.api.SystemCommand.UpdateParamsCommand.Feedback.getDefaultInstance()))
              .setSchemaDescriptor(new SystemServiceMethodDescriptorSupplier("UpdateParams"))
              .build();
        }
      }
    }
    return getUpdateParamsMethod;
  }

  private static volatile io.grpc.MethodDescriptor<cmvr.api.SystemCommand.StopAllCommand.Request,
      cmvr.api.SystemCommand.StopAllCommand.Feedback> getStopAllMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "StopAll",
      requestType = cmvr.api.SystemCommand.StopAllCommand.Request.class,
      responseType = cmvr.api.SystemCommand.StopAllCommand.Feedback.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor<cmvr.api.SystemCommand.StopAllCommand.Request,
      cmvr.api.SystemCommand.StopAllCommand.Feedback> getStopAllMethod() {
    io.grpc.MethodDescriptor<cmvr.api.SystemCommand.StopAllCommand.Request, cmvr.api.SystemCommand.StopAllCommand.Feedback> getStopAllMethod;
    if ((getStopAllMethod = SystemServiceGrpc.getStopAllMethod) == null) {
      synchronized (SystemServiceGrpc.class) {
        if ((getStopAllMethod = SystemServiceGrpc.getStopAllMethod) == null) {
          SystemServiceGrpc.getStopAllMethod = getStopAllMethod =
              io.grpc.MethodDescriptor.<cmvr.api.SystemCommand.StopAllCommand.Request, cmvr.api.SystemCommand.StopAllCommand.Feedback>newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "StopAll"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  cmvr.api.SystemCommand.StopAllCommand.Request.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  cmvr.api.SystemCommand.StopAllCommand.Feedback.getDefaultInstance()))
              .setSchemaDescriptor(new SystemServiceMethodDescriptorSupplier("StopAll"))
              .build();
        }
      }
    }
    return getStopAllMethod;
  }

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

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

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

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

    /**
     */
    public void getSystemInfo(cmvr.api.SystemCommand.GetSystemInfoCommand.Request request,
        io.grpc.stub.StreamObserver<cmvr.api.SystemCommand.GetSystemInfoCommand.Feedback> responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getGetSystemInfoMethod(), responseObserver);
    }

    /**
     */
    public void getSystemStatus(cmvr.api.SystemCommand.GetSystemStatusCommand.Request request,
        io.grpc.stub.StreamObserver<cmvr.api.SystemCommand.GetSystemStatusCommand.Feedback> responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getGetSystemStatusMethod(), responseObserver);
    }

    /**
     */
    public void updateParams(cmvr.api.SystemCommand.UpdateParamsCommand.Request request,
        io.grpc.stub.StreamObserver<cmvr.api.SystemCommand.UpdateParamsCommand.Feedback> responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getUpdateParamsMethod(), responseObserver);
    }

    /**
     */
    public void stopAll(cmvr.api.SystemCommand.StopAllCommand.Request request,
        io.grpc.stub.StreamObserver<cmvr.api.SystemCommand.StopAllCommand.Feedback> responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getStopAllMethod(), responseObserver);
    }

    @java.lang.Override public final io.grpc.ServerServiceDefinition bindService() {
      return io.grpc.ServerServiceDefinition.builder(getServiceDescriptor())
          .addMethod(
            getGetSystemInfoMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                cmvr.api.SystemCommand.GetSystemInfoCommand.Request,
                cmvr.api.SystemCommand.GetSystemInfoCommand.Feedback>(
                  this, METHODID_GET_SYSTEM_INFO)))
          .addMethod(
            getGetSystemStatusMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                cmvr.api.SystemCommand.GetSystemStatusCommand.Request,
                cmvr.api.SystemCommand.GetSystemStatusCommand.Feedback>(
                  this, METHODID_GET_SYSTEM_STATUS)))
          .addMethod(
            getUpdateParamsMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                cmvr.api.SystemCommand.UpdateParamsCommand.Request,
                cmvr.api.SystemCommand.UpdateParamsCommand.Feedback>(
                  this, METHODID_UPDATE_PARAMS)))
          .addMethod(
            getStopAllMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                cmvr.api.SystemCommand.StopAllCommand.Request,
                cmvr.api.SystemCommand.StopAllCommand.Feedback>(
                  this, METHODID_STOP_ALL)))
          .build();
    }
  }

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

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

    /**
     */
    public void getSystemInfo(cmvr.api.SystemCommand.GetSystemInfoCommand.Request request,
        io.grpc.stub.StreamObserver<cmvr.api.SystemCommand.GetSystemInfoCommand.Feedback> responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getGetSystemInfoMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     */
    public void getSystemStatus(cmvr.api.SystemCommand.GetSystemStatusCommand.Request request,
        io.grpc.stub.StreamObserver<cmvr.api.SystemCommand.GetSystemStatusCommand.Feedback> responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getGetSystemStatusMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     */
    public void updateParams(cmvr.api.SystemCommand.UpdateParamsCommand.Request request,
        io.grpc.stub.StreamObserver<cmvr.api.SystemCommand.UpdateParamsCommand.Feedback> responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getUpdateParamsMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     */
    public void stopAll(cmvr.api.SystemCommand.StopAllCommand.Request request,
        io.grpc.stub.StreamObserver<cmvr.api.SystemCommand.StopAllCommand.Feedback> responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getStopAllMethod(), getCallOptions()), request, responseObserver);
    }
  }

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

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

    /**
     */
    public cmvr.api.SystemCommand.GetSystemInfoCommand.Feedback getSystemInfo(cmvr.api.SystemCommand.GetSystemInfoCommand.Request request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getGetSystemInfoMethod(), getCallOptions(), request);
    }

    /**
     */
    public cmvr.api.SystemCommand.GetSystemStatusCommand.Feedback getSystemStatus(cmvr.api.SystemCommand.GetSystemStatusCommand.Request request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getGetSystemStatusMethod(), getCallOptions(), request);
    }

    /**
     */
    public cmvr.api.SystemCommand.UpdateParamsCommand.Feedback updateParams(cmvr.api.SystemCommand.UpdateParamsCommand.Request request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getUpdateParamsMethod(), getCallOptions(), request);
    }

    /**
     */
    public cmvr.api.SystemCommand.StopAllCommand.Feedback stopAll(cmvr.api.SystemCommand.StopAllCommand.Request request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getStopAllMethod(), getCallOptions(), request);
    }
  }

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

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

    /**
     */
    public com.google.common.util.concurrent.ListenableFuture<cmvr.api.SystemCommand.GetSystemInfoCommand.Feedback> getSystemInfo(
        cmvr.api.SystemCommand.GetSystemInfoCommand.Request request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getGetSystemInfoMethod(), getCallOptions()), request);
    }

    /**
     */
    public com.google.common.util.concurrent.ListenableFuture<cmvr.api.SystemCommand.GetSystemStatusCommand.Feedback> getSystemStatus(
        cmvr.api.SystemCommand.GetSystemStatusCommand.Request request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getGetSystemStatusMethod(), getCallOptions()), request);
    }

    /**
     */
    public com.google.common.util.concurrent.ListenableFuture<cmvr.api.SystemCommand.UpdateParamsCommand.Feedback> updateParams(
        cmvr.api.SystemCommand.UpdateParamsCommand.Request request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getUpdateParamsMethod(), getCallOptions()), request);
    }

    /**
     */
    public com.google.common.util.concurrent.ListenableFuture<cmvr.api.SystemCommand.StopAllCommand.Feedback> stopAll(
        cmvr.api.SystemCommand.StopAllCommand.Request request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getStopAllMethod(), getCallOptions()), request);
    }
  }

  private static final int METHODID_GET_SYSTEM_INFO = 0;
  private static final int METHODID_GET_SYSTEM_STATUS = 1;
  private static final int METHODID_UPDATE_PARAMS = 2;
  private static final int METHODID_STOP_ALL = 3;

  private static final class MethodHandlers<Req, Resp> implements
      io.grpc.stub.ServerCalls.UnaryMethod<Req, Resp>,
      io.grpc.stub.ServerCalls.ServerStreamingMethod<Req, Resp>,
      io.grpc.stub.ServerCalls.ClientStreamingMethod<Req, Resp>,
      io.grpc.stub.ServerCalls.BidiStreamingMethod<Req, Resp> {
    private final SystemServiceImplBase serviceImpl;
    private final int methodId;

    MethodHandlers(SystemServiceImplBase 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<Resp> responseObserver) {
      switch (methodId) {
        case METHODID_GET_SYSTEM_INFO:
          serviceImpl.getSystemInfo((cmvr.api.SystemCommand.GetSystemInfoCommand.Request) request,
              (io.grpc.stub.StreamObserver<cmvr.api.SystemCommand.GetSystemInfoCommand.Feedback>) responseObserver);
          break;
        case METHODID_GET_SYSTEM_STATUS:
          serviceImpl.getSystemStatus((cmvr.api.SystemCommand.GetSystemStatusCommand.Request) request,
              (io.grpc.stub.StreamObserver<cmvr.api.SystemCommand.GetSystemStatusCommand.Feedback>) responseObserver);
          break;
        case METHODID_UPDATE_PARAMS:
          serviceImpl.updateParams((cmvr.api.SystemCommand.UpdateParamsCommand.Request) request,
              (io.grpc.stub.StreamObserver<cmvr.api.SystemCommand.UpdateParamsCommand.Feedback>) responseObserver);
          break;
        case METHODID_STOP_ALL:
          serviceImpl.stopAll((cmvr.api.SystemCommand.StopAllCommand.Request) request,
              (io.grpc.stub.StreamObserver<cmvr.api.SystemCommand.StopAllCommand.Feedback>) responseObserver);
          break;
        default:
          throw new AssertionError();
      }
    }

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

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

    @java.lang.Override
    public com.google.protobuf.Descriptors.FileDescriptor getFileDescriptor() {
      return cmvr.api.SystemServiceOuterClass.getDescriptor();
    }

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

  private static final class SystemServiceFileDescriptorSupplier
      extends SystemServiceBaseDescriptorSupplier {
    SystemServiceFileDescriptorSupplier() {}
  }

  private static final class SystemServiceMethodDescriptorSupplier
      extends SystemServiceBaseDescriptorSupplier
      implements io.grpc.protobuf.ProtoMethodDescriptorSupplier {
    private final String methodName;

    SystemServiceMethodDescriptorSupplier(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 (SystemServiceGrpc.class) {
        result = serviceDescriptor;
        if (result == null) {
          serviceDescriptor = result = io.grpc.ServiceDescriptor.newBuilder(SERVICE_NAME)
              .setSchemaDescriptor(new SystemServiceFileDescriptorSupplier())
              .addMethod(getGetSystemInfoMethod())
              .addMethod(getGetSystemStatusMethod())
              .addMethod(getUpdateParamsMethod())
              .addMethod(getStopAllMethod())
              .build();
        }
      }
    }
    return result;
  }
}
