CMVR-IOT/cmvr-iot-api/cmvr-iot-edge/cmvr-iot-grpc-lib/src/main/java/cmvr/api/SystemServiceGrpc.java

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.GetDeviceListCommand.Request,
      cmvr.api.SystemCommand.GetDeviceListCommand.Feedback> getGetDeviceListMethod;

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

  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;
  }

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

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

  private static volatile io.grpc.MethodDescriptor<cmvr.api.SafetyCommand.GetSafetyStateCommand.Request,
      cmvr.api.SafetyCommand.GetSafetyStateCommand.Feedback> getGetSafetyStateMethod;

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

  private static volatile io.grpc.MethodDescriptor<cmvr.api.SafetyCommand.RecoverSafetyStateCommand.Request,
      cmvr.api.SafetyCommand.RecoverSafetyStateCommand.Feedback> getRecoverSafetyStateMethod;

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

  private static volatile io.grpc.MethodDescriptor<cmvr.api.SafetyCommand.RestoreOperationalStateCommand.Request,
      cmvr.api.SafetyCommand.RestoreOperationalStateCommand.Feedback> getRestoreOperationalStateMethod;

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

  /**
   * 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 getDeviceList(cmvr.api.SystemCommand.GetDeviceListCommand.Request request,
        io.grpc.stub.StreamObserver<cmvr.api.SystemCommand.GetDeviceListCommand.Feedback> responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getGetDeviceListMethod(), 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);
    }

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

    /**
     */
    public void getSafetyState(cmvr.api.SafetyCommand.GetSafetyStateCommand.Request request,
        io.grpc.stub.StreamObserver<cmvr.api.SafetyCommand.GetSafetyStateCommand.Feedback> responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getGetSafetyStateMethod(), responseObserver);
    }

    /**
     */
    public void recoverSafetyState(cmvr.api.SafetyCommand.RecoverSafetyStateCommand.Request request,
        io.grpc.stub.StreamObserver<cmvr.api.SafetyCommand.RecoverSafetyStateCommand.Feedback> responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getRecoverSafetyStateMethod(), responseObserver);
    }

    /**
     */
    public void restoreOperationalState(cmvr.api.SafetyCommand.RestoreOperationalStateCommand.Request request,
        io.grpc.stub.StreamObserver<cmvr.api.SafetyCommand.RestoreOperationalStateCommand.Feedback> responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getRestoreOperationalStateMethod(), 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(
            getGetDeviceListMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                cmvr.api.SystemCommand.GetDeviceListCommand.Request,
                cmvr.api.SystemCommand.GetDeviceListCommand.Feedback>(
                  this, METHODID_GET_DEVICE_LIST)))
          .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)))
          .addMethod(
            getExecuteActionQueueMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                cmvr.api.SystemCommand.ActionQueueCommand.Request,
                cmvr.api.SystemCommand.ActionQueueCommand.Feedback>(
                  this, METHODID_EXECUTE_ACTION_QUEUE)))
          .addMethod(
            getGetSafetyStateMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                cmvr.api.SafetyCommand.GetSafetyStateCommand.Request,
                cmvr.api.SafetyCommand.GetSafetyStateCommand.Feedback>(
                  this, METHODID_GET_SAFETY_STATE)))
          .addMethod(
            getRecoverSafetyStateMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                cmvr.api.SafetyCommand.RecoverSafetyStateCommand.Request,
                cmvr.api.SafetyCommand.RecoverSafetyStateCommand.Feedback>(
                  this, METHODID_RECOVER_SAFETY_STATE)))
          .addMethod(
            getRestoreOperationalStateMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                cmvr.api.SafetyCommand.RestoreOperationalStateCommand.Request,
                cmvr.api.SafetyCommand.RestoreOperationalStateCommand.Feedback>(
                  this, METHODID_RESTORE_OPERATIONAL_STATE)))
          .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 getDeviceList(cmvr.api.SystemCommand.GetDeviceListCommand.Request request,
        io.grpc.stub.StreamObserver<cmvr.api.SystemCommand.GetDeviceListCommand.Feedback> responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getGetDeviceListMethod(), 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 void executeActionQueue(cmvr.api.SystemCommand.ActionQueueCommand.Request request,
        io.grpc.stub.StreamObserver<cmvr.api.SystemCommand.ActionQueueCommand.Feedback> responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getExecuteActionQueueMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     */
    public void getSafetyState(cmvr.api.SafetyCommand.GetSafetyStateCommand.Request request,
        io.grpc.stub.StreamObserver<cmvr.api.SafetyCommand.GetSafetyStateCommand.Feedback> responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getGetSafetyStateMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     */
    public void recoverSafetyState(cmvr.api.SafetyCommand.RecoverSafetyStateCommand.Request request,
        io.grpc.stub.StreamObserver<cmvr.api.SafetyCommand.RecoverSafetyStateCommand.Feedback> responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getRecoverSafetyStateMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     */
    public void restoreOperationalState(cmvr.api.SafetyCommand.RestoreOperationalStateCommand.Request request,
        io.grpc.stub.StreamObserver<cmvr.api.SafetyCommand.RestoreOperationalStateCommand.Feedback> responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getRestoreOperationalStateMethod(), 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.GetDeviceListCommand.Feedback getDeviceList(cmvr.api.SystemCommand.GetDeviceListCommand.Request request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getGetDeviceListMethod(), 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 cmvr.api.SystemCommand.ActionQueueCommand.Feedback executeActionQueue(cmvr.api.SystemCommand.ActionQueueCommand.Request request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getExecuteActionQueueMethod(), getCallOptions(), request);
    }

    /**
     */
    public cmvr.api.SafetyCommand.GetSafetyStateCommand.Feedback getSafetyState(cmvr.api.SafetyCommand.GetSafetyStateCommand.Request request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getGetSafetyStateMethod(), getCallOptions(), request);
    }

    /**
     */
    public cmvr.api.SafetyCommand.RecoverSafetyStateCommand.Feedback recoverSafetyState(cmvr.api.SafetyCommand.RecoverSafetyStateCommand.Request request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getRecoverSafetyStateMethod(), getCallOptions(), request);
    }

    /**
     */
    public cmvr.api.SafetyCommand.RestoreOperationalStateCommand.Feedback restoreOperationalState(cmvr.api.SafetyCommand.RestoreOperationalStateCommand.Request request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getRestoreOperationalStateMethod(), 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.GetDeviceListCommand.Feedback> getDeviceList(
        cmvr.api.SystemCommand.GetDeviceListCommand.Request request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getGetDeviceListMethod(), 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);
    }

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

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

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

    /**
     */
    public com.google.common.util.concurrent.ListenableFuture<cmvr.api.SafetyCommand.RestoreOperationalStateCommand.Feedback> restoreOperationalState(
        cmvr.api.SafetyCommand.RestoreOperationalStateCommand.Request request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getRestoreOperationalStateMethod(), 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_GET_DEVICE_LIST = 2;
  private static final int METHODID_UPDATE_PARAMS = 3;
  private static final int METHODID_STOP_ALL = 4;
  private static final int METHODID_EXECUTE_ACTION_QUEUE = 5;
  private static final int METHODID_GET_SAFETY_STATE = 6;
  private static final int METHODID_RECOVER_SAFETY_STATE = 7;
  private static final int METHODID_RESTORE_OPERATIONAL_STATE = 8;

  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_GET_DEVICE_LIST:
          serviceImpl.getDeviceList((cmvr.api.SystemCommand.GetDeviceListCommand.Request) request,
              (io.grpc.stub.StreamObserver<cmvr.api.SystemCommand.GetDeviceListCommand.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;
        case METHODID_EXECUTE_ACTION_QUEUE:
          serviceImpl.executeActionQueue((cmvr.api.SystemCommand.ActionQueueCommand.Request) request,
              (io.grpc.stub.StreamObserver<cmvr.api.SystemCommand.ActionQueueCommand.Feedback>) responseObserver);
          break;
        case METHODID_GET_SAFETY_STATE:
          serviceImpl.getSafetyState((cmvr.api.SafetyCommand.GetSafetyStateCommand.Request) request,
              (io.grpc.stub.StreamObserver<cmvr.api.SafetyCommand.GetSafetyStateCommand.Feedback>) responseObserver);
          break;
        case METHODID_RECOVER_SAFETY_STATE:
          serviceImpl.recoverSafetyState((cmvr.api.SafetyCommand.RecoverSafetyStateCommand.Request) request,
              (io.grpc.stub.StreamObserver<cmvr.api.SafetyCommand.RecoverSafetyStateCommand.Feedback>) responseObserver);
          break;
        case METHODID_RESTORE_OPERATIONAL_STATE:
          serviceImpl.restoreOperationalState((cmvr.api.SafetyCommand.RestoreOperationalStateCommand.Request) request,
              (io.grpc.stub.StreamObserver<cmvr.api.SafetyCommand.RestoreOperationalStateCommand.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(getGetDeviceListMethod())
              .addMethod(getUpdateParamsMethod())
              .addMethod(getStopAllMethod())
              .addMethod(getExecuteActionQueueMethod())
              .addMethod(getGetSafetyStateMethod())
              .addMethod(getRecoverSafetyStateMethod())
              .addMethod(getRestoreOperationalStateMethod())
              .build();
        }
      }
    }
    return result;
  }
}