721 lines
33 KiB
Java
721 lines
33 KiB
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/humanoid_robot_service.proto")
|
|
@io.grpc.stub.annotations.GrpcGenerated
|
|
public final class HumanoidRobotServiceGrpc {
|
|
|
|
private HumanoidRobotServiceGrpc() {}
|
|
|
|
public static final String SERVICE_NAME = "cmvr.api.HumanoidRobotService";
|
|
|
|
// Static method descriptors that strictly reflect the proto.
|
|
private static volatile io.grpc.MethodDescriptor<cmvr.api.Common.CommandHeader.Request,
|
|
cmvr.api.Common.CommandHeader.Feedback> getTorqueOffMethod;
|
|
|
|
@io.grpc.stub.annotations.RpcMethod(
|
|
fullMethodName = SERVICE_NAME + '/' + "torqueOff",
|
|
requestType = cmvr.api.Common.CommandHeader.Request.class,
|
|
responseType = cmvr.api.Common.CommandHeader.Feedback.class,
|
|
methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
|
|
public static io.grpc.MethodDescriptor<cmvr.api.Common.CommandHeader.Request,
|
|
cmvr.api.Common.CommandHeader.Feedback> getTorqueOffMethod() {
|
|
io.grpc.MethodDescriptor<cmvr.api.Common.CommandHeader.Request, cmvr.api.Common.CommandHeader.Feedback> getTorqueOffMethod;
|
|
if ((getTorqueOffMethod = HumanoidRobotServiceGrpc.getTorqueOffMethod) == null) {
|
|
synchronized (HumanoidRobotServiceGrpc.class) {
|
|
if ((getTorqueOffMethod = HumanoidRobotServiceGrpc.getTorqueOffMethod) == null) {
|
|
HumanoidRobotServiceGrpc.getTorqueOffMethod = getTorqueOffMethod =
|
|
io.grpc.MethodDescriptor.<cmvr.api.Common.CommandHeader.Request, cmvr.api.Common.CommandHeader.Feedback>newBuilder()
|
|
.setType(io.grpc.MethodDescriptor.MethodType.UNARY)
|
|
.setFullMethodName(generateFullMethodName(SERVICE_NAME, "torqueOff"))
|
|
.setSampledToLocalTracing(true)
|
|
.setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
|
|
cmvr.api.Common.CommandHeader.Request.getDefaultInstance()))
|
|
.setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
|
|
cmvr.api.Common.CommandHeader.Feedback.getDefaultInstance()))
|
|
.setSchemaDescriptor(new HumanoidRobotServiceMethodDescriptorSupplier("torqueOff"))
|
|
.build();
|
|
}
|
|
}
|
|
}
|
|
return getTorqueOffMethod;
|
|
}
|
|
|
|
private static volatile io.grpc.MethodDescriptor<cmvr.api.Common.CommandHeader.Request,
|
|
cmvr.api.Common.CommandHeader.Feedback> getTorqueOnMethod;
|
|
|
|
@io.grpc.stub.annotations.RpcMethod(
|
|
fullMethodName = SERVICE_NAME + '/' + "torqueOn",
|
|
requestType = cmvr.api.Common.CommandHeader.Request.class,
|
|
responseType = cmvr.api.Common.CommandHeader.Feedback.class,
|
|
methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
|
|
public static io.grpc.MethodDescriptor<cmvr.api.Common.CommandHeader.Request,
|
|
cmvr.api.Common.CommandHeader.Feedback> getTorqueOnMethod() {
|
|
io.grpc.MethodDescriptor<cmvr.api.Common.CommandHeader.Request, cmvr.api.Common.CommandHeader.Feedback> getTorqueOnMethod;
|
|
if ((getTorqueOnMethod = HumanoidRobotServiceGrpc.getTorqueOnMethod) == null) {
|
|
synchronized (HumanoidRobotServiceGrpc.class) {
|
|
if ((getTorqueOnMethod = HumanoidRobotServiceGrpc.getTorqueOnMethod) == null) {
|
|
HumanoidRobotServiceGrpc.getTorqueOnMethod = getTorqueOnMethod =
|
|
io.grpc.MethodDescriptor.<cmvr.api.Common.CommandHeader.Request, cmvr.api.Common.CommandHeader.Feedback>newBuilder()
|
|
.setType(io.grpc.MethodDescriptor.MethodType.UNARY)
|
|
.setFullMethodName(generateFullMethodName(SERVICE_NAME, "torqueOn"))
|
|
.setSampledToLocalTracing(true)
|
|
.setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
|
|
cmvr.api.Common.CommandHeader.Request.getDefaultInstance()))
|
|
.setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
|
|
cmvr.api.Common.CommandHeader.Feedback.getDefaultInstance()))
|
|
.setSchemaDescriptor(new HumanoidRobotServiceMethodDescriptorSupplier("torqueOn"))
|
|
.build();
|
|
}
|
|
}
|
|
}
|
|
return getTorqueOnMethod;
|
|
}
|
|
|
|
private static volatile io.grpc.MethodDescriptor<cmvr.api.HumanoidRobotCommand.MoveJ.Request,
|
|
cmvr.api.HumanoidRobotCommand.MoveJ.Response> getMoveJMethod;
|
|
|
|
@io.grpc.stub.annotations.RpcMethod(
|
|
fullMethodName = SERVICE_NAME + '/' + "moveJ",
|
|
requestType = cmvr.api.HumanoidRobotCommand.MoveJ.Request.class,
|
|
responseType = cmvr.api.HumanoidRobotCommand.MoveJ.Response.class,
|
|
methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
|
|
public static io.grpc.MethodDescriptor<cmvr.api.HumanoidRobotCommand.MoveJ.Request,
|
|
cmvr.api.HumanoidRobotCommand.MoveJ.Response> getMoveJMethod() {
|
|
io.grpc.MethodDescriptor<cmvr.api.HumanoidRobotCommand.MoveJ.Request, cmvr.api.HumanoidRobotCommand.MoveJ.Response> getMoveJMethod;
|
|
if ((getMoveJMethod = HumanoidRobotServiceGrpc.getMoveJMethod) == null) {
|
|
synchronized (HumanoidRobotServiceGrpc.class) {
|
|
if ((getMoveJMethod = HumanoidRobotServiceGrpc.getMoveJMethod) == null) {
|
|
HumanoidRobotServiceGrpc.getMoveJMethod = getMoveJMethod =
|
|
io.grpc.MethodDescriptor.<cmvr.api.HumanoidRobotCommand.MoveJ.Request, cmvr.api.HumanoidRobotCommand.MoveJ.Response>newBuilder()
|
|
.setType(io.grpc.MethodDescriptor.MethodType.UNARY)
|
|
.setFullMethodName(generateFullMethodName(SERVICE_NAME, "moveJ"))
|
|
.setSampledToLocalTracing(true)
|
|
.setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
|
|
cmvr.api.HumanoidRobotCommand.MoveJ.Request.getDefaultInstance()))
|
|
.setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
|
|
cmvr.api.HumanoidRobotCommand.MoveJ.Response.getDefaultInstance()))
|
|
.setSchemaDescriptor(new HumanoidRobotServiceMethodDescriptorSupplier("moveJ"))
|
|
.build();
|
|
}
|
|
}
|
|
}
|
|
return getMoveJMethod;
|
|
}
|
|
|
|
private static volatile io.grpc.MethodDescriptor<cmvr.api.HumanoidRobotCommand.MoveL.Request,
|
|
cmvr.api.HumanoidRobotCommand.MoveL.Response> getMoveLMethod;
|
|
|
|
@io.grpc.stub.annotations.RpcMethod(
|
|
fullMethodName = SERVICE_NAME + '/' + "moveL",
|
|
requestType = cmvr.api.HumanoidRobotCommand.MoveL.Request.class,
|
|
responseType = cmvr.api.HumanoidRobotCommand.MoveL.Response.class,
|
|
methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
|
|
public static io.grpc.MethodDescriptor<cmvr.api.HumanoidRobotCommand.MoveL.Request,
|
|
cmvr.api.HumanoidRobotCommand.MoveL.Response> getMoveLMethod() {
|
|
io.grpc.MethodDescriptor<cmvr.api.HumanoidRobotCommand.MoveL.Request, cmvr.api.HumanoidRobotCommand.MoveL.Response> getMoveLMethod;
|
|
if ((getMoveLMethod = HumanoidRobotServiceGrpc.getMoveLMethod) == null) {
|
|
synchronized (HumanoidRobotServiceGrpc.class) {
|
|
if ((getMoveLMethod = HumanoidRobotServiceGrpc.getMoveLMethod) == null) {
|
|
HumanoidRobotServiceGrpc.getMoveLMethod = getMoveLMethod =
|
|
io.grpc.MethodDescriptor.<cmvr.api.HumanoidRobotCommand.MoveL.Request, cmvr.api.HumanoidRobotCommand.MoveL.Response>newBuilder()
|
|
.setType(io.grpc.MethodDescriptor.MethodType.UNARY)
|
|
.setFullMethodName(generateFullMethodName(SERVICE_NAME, "moveL"))
|
|
.setSampledToLocalTracing(true)
|
|
.setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
|
|
cmvr.api.HumanoidRobotCommand.MoveL.Request.getDefaultInstance()))
|
|
.setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
|
|
cmvr.api.HumanoidRobotCommand.MoveL.Response.getDefaultInstance()))
|
|
.setSchemaDescriptor(new HumanoidRobotServiceMethodDescriptorSupplier("moveL"))
|
|
.build();
|
|
}
|
|
}
|
|
}
|
|
return getMoveLMethod;
|
|
}
|
|
|
|
private static volatile io.grpc.MethodDescriptor<cmvr.api.HumanoidRobotCommand.SpeedJ.Request,
|
|
cmvr.api.HumanoidRobotCommand.SpeedJ.Response> getSpeedJMethod;
|
|
|
|
@io.grpc.stub.annotations.RpcMethod(
|
|
fullMethodName = SERVICE_NAME + '/' + "speedJ",
|
|
requestType = cmvr.api.HumanoidRobotCommand.SpeedJ.Request.class,
|
|
responseType = cmvr.api.HumanoidRobotCommand.SpeedJ.Response.class,
|
|
methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
|
|
public static io.grpc.MethodDescriptor<cmvr.api.HumanoidRobotCommand.SpeedJ.Request,
|
|
cmvr.api.HumanoidRobotCommand.SpeedJ.Response> getSpeedJMethod() {
|
|
io.grpc.MethodDescriptor<cmvr.api.HumanoidRobotCommand.SpeedJ.Request, cmvr.api.HumanoidRobotCommand.SpeedJ.Response> getSpeedJMethod;
|
|
if ((getSpeedJMethod = HumanoidRobotServiceGrpc.getSpeedJMethod) == null) {
|
|
synchronized (HumanoidRobotServiceGrpc.class) {
|
|
if ((getSpeedJMethod = HumanoidRobotServiceGrpc.getSpeedJMethod) == null) {
|
|
HumanoidRobotServiceGrpc.getSpeedJMethod = getSpeedJMethod =
|
|
io.grpc.MethodDescriptor.<cmvr.api.HumanoidRobotCommand.SpeedJ.Request, cmvr.api.HumanoidRobotCommand.SpeedJ.Response>newBuilder()
|
|
.setType(io.grpc.MethodDescriptor.MethodType.UNARY)
|
|
.setFullMethodName(generateFullMethodName(SERVICE_NAME, "speedJ"))
|
|
.setSampledToLocalTracing(true)
|
|
.setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
|
|
cmvr.api.HumanoidRobotCommand.SpeedJ.Request.getDefaultInstance()))
|
|
.setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
|
|
cmvr.api.HumanoidRobotCommand.SpeedJ.Response.getDefaultInstance()))
|
|
.setSchemaDescriptor(new HumanoidRobotServiceMethodDescriptorSupplier("speedJ"))
|
|
.build();
|
|
}
|
|
}
|
|
}
|
|
return getSpeedJMethod;
|
|
}
|
|
|
|
private static volatile io.grpc.MethodDescriptor<cmvr.api.HumanoidRobotCommand.SpeedL.Request,
|
|
cmvr.api.HumanoidRobotCommand.SpeedL.Response> getSpeedLMethod;
|
|
|
|
@io.grpc.stub.annotations.RpcMethod(
|
|
fullMethodName = SERVICE_NAME + '/' + "speedL",
|
|
requestType = cmvr.api.HumanoidRobotCommand.SpeedL.Request.class,
|
|
responseType = cmvr.api.HumanoidRobotCommand.SpeedL.Response.class,
|
|
methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
|
|
public static io.grpc.MethodDescriptor<cmvr.api.HumanoidRobotCommand.SpeedL.Request,
|
|
cmvr.api.HumanoidRobotCommand.SpeedL.Response> getSpeedLMethod() {
|
|
io.grpc.MethodDescriptor<cmvr.api.HumanoidRobotCommand.SpeedL.Request, cmvr.api.HumanoidRobotCommand.SpeedL.Response> getSpeedLMethod;
|
|
if ((getSpeedLMethod = HumanoidRobotServiceGrpc.getSpeedLMethod) == null) {
|
|
synchronized (HumanoidRobotServiceGrpc.class) {
|
|
if ((getSpeedLMethod = HumanoidRobotServiceGrpc.getSpeedLMethod) == null) {
|
|
HumanoidRobotServiceGrpc.getSpeedLMethod = getSpeedLMethod =
|
|
io.grpc.MethodDescriptor.<cmvr.api.HumanoidRobotCommand.SpeedL.Request, cmvr.api.HumanoidRobotCommand.SpeedL.Response>newBuilder()
|
|
.setType(io.grpc.MethodDescriptor.MethodType.UNARY)
|
|
.setFullMethodName(generateFullMethodName(SERVICE_NAME, "speedL"))
|
|
.setSampledToLocalTracing(true)
|
|
.setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
|
|
cmvr.api.HumanoidRobotCommand.SpeedL.Request.getDefaultInstance()))
|
|
.setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
|
|
cmvr.api.HumanoidRobotCommand.SpeedL.Response.getDefaultInstance()))
|
|
.setSchemaDescriptor(new HumanoidRobotServiceMethodDescriptorSupplier("speedL"))
|
|
.build();
|
|
}
|
|
}
|
|
}
|
|
return getSpeedLMethod;
|
|
}
|
|
|
|
private static volatile io.grpc.MethodDescriptor<cmvr.api.HumanoidRobotCommand.JointRequest,
|
|
cmvr.api.HumanoidRobotCommand.JointResponse> getGetJointStateMethod;
|
|
|
|
@io.grpc.stub.annotations.RpcMethod(
|
|
fullMethodName = SERVICE_NAME + '/' + "getJointState",
|
|
requestType = cmvr.api.HumanoidRobotCommand.JointRequest.class,
|
|
responseType = cmvr.api.HumanoidRobotCommand.JointResponse.class,
|
|
methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
|
|
public static io.grpc.MethodDescriptor<cmvr.api.HumanoidRobotCommand.JointRequest,
|
|
cmvr.api.HumanoidRobotCommand.JointResponse> getGetJointStateMethod() {
|
|
io.grpc.MethodDescriptor<cmvr.api.HumanoidRobotCommand.JointRequest, cmvr.api.HumanoidRobotCommand.JointResponse> getGetJointStateMethod;
|
|
if ((getGetJointStateMethod = HumanoidRobotServiceGrpc.getGetJointStateMethod) == null) {
|
|
synchronized (HumanoidRobotServiceGrpc.class) {
|
|
if ((getGetJointStateMethod = HumanoidRobotServiceGrpc.getGetJointStateMethod) == null) {
|
|
HumanoidRobotServiceGrpc.getGetJointStateMethod = getGetJointStateMethod =
|
|
io.grpc.MethodDescriptor.<cmvr.api.HumanoidRobotCommand.JointRequest, cmvr.api.HumanoidRobotCommand.JointResponse>newBuilder()
|
|
.setType(io.grpc.MethodDescriptor.MethodType.UNARY)
|
|
.setFullMethodName(generateFullMethodName(SERVICE_NAME, "getJointState"))
|
|
.setSampledToLocalTracing(true)
|
|
.setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
|
|
cmvr.api.HumanoidRobotCommand.JointRequest.getDefaultInstance()))
|
|
.setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
|
|
cmvr.api.HumanoidRobotCommand.JointResponse.getDefaultInstance()))
|
|
.setSchemaDescriptor(new HumanoidRobotServiceMethodDescriptorSupplier("getJointState"))
|
|
.build();
|
|
}
|
|
}
|
|
}
|
|
return getGetJointStateMethod;
|
|
}
|
|
|
|
/**
|
|
* Creates a new async stub that supports all call types for the service
|
|
*/
|
|
public static HumanoidRobotServiceStub newStub(io.grpc.Channel channel) {
|
|
io.grpc.stub.AbstractStub.StubFactory<HumanoidRobotServiceStub> factory =
|
|
new io.grpc.stub.AbstractStub.StubFactory<HumanoidRobotServiceStub>() {
|
|
@java.lang.Override
|
|
public HumanoidRobotServiceStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
|
|
return new HumanoidRobotServiceStub(channel, callOptions);
|
|
}
|
|
};
|
|
return HumanoidRobotServiceStub.newStub(factory, channel);
|
|
}
|
|
|
|
/**
|
|
* Creates a new blocking-style stub that supports unary and streaming output calls on the service
|
|
*/
|
|
public static HumanoidRobotServiceBlockingStub newBlockingStub(
|
|
io.grpc.Channel channel) {
|
|
io.grpc.stub.AbstractStub.StubFactory<HumanoidRobotServiceBlockingStub> factory =
|
|
new io.grpc.stub.AbstractStub.StubFactory<HumanoidRobotServiceBlockingStub>() {
|
|
@java.lang.Override
|
|
public HumanoidRobotServiceBlockingStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
|
|
return new HumanoidRobotServiceBlockingStub(channel, callOptions);
|
|
}
|
|
};
|
|
return HumanoidRobotServiceBlockingStub.newStub(factory, channel);
|
|
}
|
|
|
|
/**
|
|
* Creates a new ListenableFuture-style stub that supports unary calls on the service
|
|
*/
|
|
public static HumanoidRobotServiceFutureStub newFutureStub(
|
|
io.grpc.Channel channel) {
|
|
io.grpc.stub.AbstractStub.StubFactory<HumanoidRobotServiceFutureStub> factory =
|
|
new io.grpc.stub.AbstractStub.StubFactory<HumanoidRobotServiceFutureStub>() {
|
|
@java.lang.Override
|
|
public HumanoidRobotServiceFutureStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
|
|
return new HumanoidRobotServiceFutureStub(channel, callOptions);
|
|
}
|
|
};
|
|
return HumanoidRobotServiceFutureStub.newStub(factory, channel);
|
|
}
|
|
|
|
/**
|
|
*/
|
|
public static abstract class HumanoidRobotServiceImplBase implements io.grpc.BindableService {
|
|
|
|
/**
|
|
*/
|
|
public void torqueOff(cmvr.api.Common.CommandHeader.Request request,
|
|
io.grpc.stub.StreamObserver<cmvr.api.Common.CommandHeader.Feedback> responseObserver) {
|
|
io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getTorqueOffMethod(), responseObserver);
|
|
}
|
|
|
|
/**
|
|
*/
|
|
public void torqueOn(cmvr.api.Common.CommandHeader.Request request,
|
|
io.grpc.stub.StreamObserver<cmvr.api.Common.CommandHeader.Feedback> responseObserver) {
|
|
io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getTorqueOnMethod(), responseObserver);
|
|
}
|
|
|
|
/**
|
|
*/
|
|
public void moveJ(cmvr.api.HumanoidRobotCommand.MoveJ.Request request,
|
|
io.grpc.stub.StreamObserver<cmvr.api.HumanoidRobotCommand.MoveJ.Response> responseObserver) {
|
|
io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getMoveJMethod(), responseObserver);
|
|
}
|
|
|
|
/**
|
|
*/
|
|
public void moveL(cmvr.api.HumanoidRobotCommand.MoveL.Request request,
|
|
io.grpc.stub.StreamObserver<cmvr.api.HumanoidRobotCommand.MoveL.Response> responseObserver) {
|
|
io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getMoveLMethod(), responseObserver);
|
|
}
|
|
|
|
/**
|
|
*/
|
|
public void speedJ(cmvr.api.HumanoidRobotCommand.SpeedJ.Request request,
|
|
io.grpc.stub.StreamObserver<cmvr.api.HumanoidRobotCommand.SpeedJ.Response> responseObserver) {
|
|
io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getSpeedJMethod(), responseObserver);
|
|
}
|
|
|
|
/**
|
|
*/
|
|
public void speedL(cmvr.api.HumanoidRobotCommand.SpeedL.Request request,
|
|
io.grpc.stub.StreamObserver<cmvr.api.HumanoidRobotCommand.SpeedL.Response> responseObserver) {
|
|
io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getSpeedLMethod(), responseObserver);
|
|
}
|
|
|
|
/**
|
|
*/
|
|
public void getJointState(cmvr.api.HumanoidRobotCommand.JointRequest request,
|
|
io.grpc.stub.StreamObserver<cmvr.api.HumanoidRobotCommand.JointResponse> responseObserver) {
|
|
io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getGetJointStateMethod(), responseObserver);
|
|
}
|
|
|
|
@java.lang.Override public final io.grpc.ServerServiceDefinition bindService() {
|
|
return io.grpc.ServerServiceDefinition.builder(getServiceDescriptor())
|
|
.addMethod(
|
|
getTorqueOffMethod(),
|
|
io.grpc.stub.ServerCalls.asyncUnaryCall(
|
|
new MethodHandlers<
|
|
cmvr.api.Common.CommandHeader.Request,
|
|
cmvr.api.Common.CommandHeader.Feedback>(
|
|
this, METHODID_TORQUE_OFF)))
|
|
.addMethod(
|
|
getTorqueOnMethod(),
|
|
io.grpc.stub.ServerCalls.asyncUnaryCall(
|
|
new MethodHandlers<
|
|
cmvr.api.Common.CommandHeader.Request,
|
|
cmvr.api.Common.CommandHeader.Feedback>(
|
|
this, METHODID_TORQUE_ON)))
|
|
.addMethod(
|
|
getMoveJMethod(),
|
|
io.grpc.stub.ServerCalls.asyncUnaryCall(
|
|
new MethodHandlers<
|
|
cmvr.api.HumanoidRobotCommand.MoveJ.Request,
|
|
cmvr.api.HumanoidRobotCommand.MoveJ.Response>(
|
|
this, METHODID_MOVE_J)))
|
|
.addMethod(
|
|
getMoveLMethod(),
|
|
io.grpc.stub.ServerCalls.asyncUnaryCall(
|
|
new MethodHandlers<
|
|
cmvr.api.HumanoidRobotCommand.MoveL.Request,
|
|
cmvr.api.HumanoidRobotCommand.MoveL.Response>(
|
|
this, METHODID_MOVE_L)))
|
|
.addMethod(
|
|
getSpeedJMethod(),
|
|
io.grpc.stub.ServerCalls.asyncUnaryCall(
|
|
new MethodHandlers<
|
|
cmvr.api.HumanoidRobotCommand.SpeedJ.Request,
|
|
cmvr.api.HumanoidRobotCommand.SpeedJ.Response>(
|
|
this, METHODID_SPEED_J)))
|
|
.addMethod(
|
|
getSpeedLMethod(),
|
|
io.grpc.stub.ServerCalls.asyncUnaryCall(
|
|
new MethodHandlers<
|
|
cmvr.api.HumanoidRobotCommand.SpeedL.Request,
|
|
cmvr.api.HumanoidRobotCommand.SpeedL.Response>(
|
|
this, METHODID_SPEED_L)))
|
|
.addMethod(
|
|
getGetJointStateMethod(),
|
|
io.grpc.stub.ServerCalls.asyncUnaryCall(
|
|
new MethodHandlers<
|
|
cmvr.api.HumanoidRobotCommand.JointRequest,
|
|
cmvr.api.HumanoidRobotCommand.JointResponse>(
|
|
this, METHODID_GET_JOINT_STATE)))
|
|
.build();
|
|
}
|
|
}
|
|
|
|
/**
|
|
*/
|
|
public static final class HumanoidRobotServiceStub extends io.grpc.stub.AbstractAsyncStub<HumanoidRobotServiceStub> {
|
|
private HumanoidRobotServiceStub(
|
|
io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
|
|
super(channel, callOptions);
|
|
}
|
|
|
|
@java.lang.Override
|
|
protected HumanoidRobotServiceStub build(
|
|
io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
|
|
return new HumanoidRobotServiceStub(channel, callOptions);
|
|
}
|
|
|
|
/**
|
|
*/
|
|
public void torqueOff(cmvr.api.Common.CommandHeader.Request request,
|
|
io.grpc.stub.StreamObserver<cmvr.api.Common.CommandHeader.Feedback> responseObserver) {
|
|
io.grpc.stub.ClientCalls.asyncUnaryCall(
|
|
getChannel().newCall(getTorqueOffMethod(), getCallOptions()), request, responseObserver);
|
|
}
|
|
|
|
/**
|
|
*/
|
|
public void torqueOn(cmvr.api.Common.CommandHeader.Request request,
|
|
io.grpc.stub.StreamObserver<cmvr.api.Common.CommandHeader.Feedback> responseObserver) {
|
|
io.grpc.stub.ClientCalls.asyncUnaryCall(
|
|
getChannel().newCall(getTorqueOnMethod(), getCallOptions()), request, responseObserver);
|
|
}
|
|
|
|
/**
|
|
*/
|
|
public void moveJ(cmvr.api.HumanoidRobotCommand.MoveJ.Request request,
|
|
io.grpc.stub.StreamObserver<cmvr.api.HumanoidRobotCommand.MoveJ.Response> responseObserver) {
|
|
io.grpc.stub.ClientCalls.asyncUnaryCall(
|
|
getChannel().newCall(getMoveJMethod(), getCallOptions()), request, responseObserver);
|
|
}
|
|
|
|
/**
|
|
*/
|
|
public void moveL(cmvr.api.HumanoidRobotCommand.MoveL.Request request,
|
|
io.grpc.stub.StreamObserver<cmvr.api.HumanoidRobotCommand.MoveL.Response> responseObserver) {
|
|
io.grpc.stub.ClientCalls.asyncUnaryCall(
|
|
getChannel().newCall(getMoveLMethod(), getCallOptions()), request, responseObserver);
|
|
}
|
|
|
|
/**
|
|
*/
|
|
public void speedJ(cmvr.api.HumanoidRobotCommand.SpeedJ.Request request,
|
|
io.grpc.stub.StreamObserver<cmvr.api.HumanoidRobotCommand.SpeedJ.Response> responseObserver) {
|
|
io.grpc.stub.ClientCalls.asyncUnaryCall(
|
|
getChannel().newCall(getSpeedJMethod(), getCallOptions()), request, responseObserver);
|
|
}
|
|
|
|
/**
|
|
*/
|
|
public void speedL(cmvr.api.HumanoidRobotCommand.SpeedL.Request request,
|
|
io.grpc.stub.StreamObserver<cmvr.api.HumanoidRobotCommand.SpeedL.Response> responseObserver) {
|
|
io.grpc.stub.ClientCalls.asyncUnaryCall(
|
|
getChannel().newCall(getSpeedLMethod(), getCallOptions()), request, responseObserver);
|
|
}
|
|
|
|
/**
|
|
*/
|
|
public void getJointState(cmvr.api.HumanoidRobotCommand.JointRequest request,
|
|
io.grpc.stub.StreamObserver<cmvr.api.HumanoidRobotCommand.JointResponse> responseObserver) {
|
|
io.grpc.stub.ClientCalls.asyncUnaryCall(
|
|
getChannel().newCall(getGetJointStateMethod(), getCallOptions()), request, responseObserver);
|
|
}
|
|
}
|
|
|
|
/**
|
|
*/
|
|
public static final class HumanoidRobotServiceBlockingStub extends io.grpc.stub.AbstractBlockingStub<HumanoidRobotServiceBlockingStub> {
|
|
private HumanoidRobotServiceBlockingStub(
|
|
io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
|
|
super(channel, callOptions);
|
|
}
|
|
|
|
@java.lang.Override
|
|
protected HumanoidRobotServiceBlockingStub build(
|
|
io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
|
|
return new HumanoidRobotServiceBlockingStub(channel, callOptions);
|
|
}
|
|
|
|
/**
|
|
*/
|
|
public cmvr.api.Common.CommandHeader.Feedback torqueOff(cmvr.api.Common.CommandHeader.Request request) {
|
|
return io.grpc.stub.ClientCalls.blockingUnaryCall(
|
|
getChannel(), getTorqueOffMethod(), getCallOptions(), request);
|
|
}
|
|
|
|
/**
|
|
*/
|
|
public cmvr.api.Common.CommandHeader.Feedback torqueOn(cmvr.api.Common.CommandHeader.Request request) {
|
|
return io.grpc.stub.ClientCalls.blockingUnaryCall(
|
|
getChannel(), getTorqueOnMethod(), getCallOptions(), request);
|
|
}
|
|
|
|
/**
|
|
*/
|
|
public cmvr.api.HumanoidRobotCommand.MoveJ.Response moveJ(cmvr.api.HumanoidRobotCommand.MoveJ.Request request) {
|
|
return io.grpc.stub.ClientCalls.blockingUnaryCall(
|
|
getChannel(), getMoveJMethod(), getCallOptions(), request);
|
|
}
|
|
|
|
/**
|
|
*/
|
|
public cmvr.api.HumanoidRobotCommand.MoveL.Response moveL(cmvr.api.HumanoidRobotCommand.MoveL.Request request) {
|
|
return io.grpc.stub.ClientCalls.blockingUnaryCall(
|
|
getChannel(), getMoveLMethod(), getCallOptions(), request);
|
|
}
|
|
|
|
/**
|
|
*/
|
|
public cmvr.api.HumanoidRobotCommand.SpeedJ.Response speedJ(cmvr.api.HumanoidRobotCommand.SpeedJ.Request request) {
|
|
return io.grpc.stub.ClientCalls.blockingUnaryCall(
|
|
getChannel(), getSpeedJMethod(), getCallOptions(), request);
|
|
}
|
|
|
|
/**
|
|
*/
|
|
public cmvr.api.HumanoidRobotCommand.SpeedL.Response speedL(cmvr.api.HumanoidRobotCommand.SpeedL.Request request) {
|
|
return io.grpc.stub.ClientCalls.blockingUnaryCall(
|
|
getChannel(), getSpeedLMethod(), getCallOptions(), request);
|
|
}
|
|
|
|
/**
|
|
*/
|
|
public cmvr.api.HumanoidRobotCommand.JointResponse getJointState(cmvr.api.HumanoidRobotCommand.JointRequest request) {
|
|
return io.grpc.stub.ClientCalls.blockingUnaryCall(
|
|
getChannel(), getGetJointStateMethod(), getCallOptions(), request);
|
|
}
|
|
}
|
|
|
|
/**
|
|
*/
|
|
public static final class HumanoidRobotServiceFutureStub extends io.grpc.stub.AbstractFutureStub<HumanoidRobotServiceFutureStub> {
|
|
private HumanoidRobotServiceFutureStub(
|
|
io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
|
|
super(channel, callOptions);
|
|
}
|
|
|
|
@java.lang.Override
|
|
protected HumanoidRobotServiceFutureStub build(
|
|
io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
|
|
return new HumanoidRobotServiceFutureStub(channel, callOptions);
|
|
}
|
|
|
|
/**
|
|
*/
|
|
public com.google.common.util.concurrent.ListenableFuture<cmvr.api.Common.CommandHeader.Feedback> torqueOff(
|
|
cmvr.api.Common.CommandHeader.Request request) {
|
|
return io.grpc.stub.ClientCalls.futureUnaryCall(
|
|
getChannel().newCall(getTorqueOffMethod(), getCallOptions()), request);
|
|
}
|
|
|
|
/**
|
|
*/
|
|
public com.google.common.util.concurrent.ListenableFuture<cmvr.api.Common.CommandHeader.Feedback> torqueOn(
|
|
cmvr.api.Common.CommandHeader.Request request) {
|
|
return io.grpc.stub.ClientCalls.futureUnaryCall(
|
|
getChannel().newCall(getTorqueOnMethod(), getCallOptions()), request);
|
|
}
|
|
|
|
/**
|
|
*/
|
|
public com.google.common.util.concurrent.ListenableFuture<cmvr.api.HumanoidRobotCommand.MoveJ.Response> moveJ(
|
|
cmvr.api.HumanoidRobotCommand.MoveJ.Request request) {
|
|
return io.grpc.stub.ClientCalls.futureUnaryCall(
|
|
getChannel().newCall(getMoveJMethod(), getCallOptions()), request);
|
|
}
|
|
|
|
/**
|
|
*/
|
|
public com.google.common.util.concurrent.ListenableFuture<cmvr.api.HumanoidRobotCommand.MoveL.Response> moveL(
|
|
cmvr.api.HumanoidRobotCommand.MoveL.Request request) {
|
|
return io.grpc.stub.ClientCalls.futureUnaryCall(
|
|
getChannel().newCall(getMoveLMethod(), getCallOptions()), request);
|
|
}
|
|
|
|
/**
|
|
*/
|
|
public com.google.common.util.concurrent.ListenableFuture<cmvr.api.HumanoidRobotCommand.SpeedJ.Response> speedJ(
|
|
cmvr.api.HumanoidRobotCommand.SpeedJ.Request request) {
|
|
return io.grpc.stub.ClientCalls.futureUnaryCall(
|
|
getChannel().newCall(getSpeedJMethod(), getCallOptions()), request);
|
|
}
|
|
|
|
/**
|
|
*/
|
|
public com.google.common.util.concurrent.ListenableFuture<cmvr.api.HumanoidRobotCommand.SpeedL.Response> speedL(
|
|
cmvr.api.HumanoidRobotCommand.SpeedL.Request request) {
|
|
return io.grpc.stub.ClientCalls.futureUnaryCall(
|
|
getChannel().newCall(getSpeedLMethod(), getCallOptions()), request);
|
|
}
|
|
|
|
/**
|
|
*/
|
|
public com.google.common.util.concurrent.ListenableFuture<cmvr.api.HumanoidRobotCommand.JointResponse> getJointState(
|
|
cmvr.api.HumanoidRobotCommand.JointRequest request) {
|
|
return io.grpc.stub.ClientCalls.futureUnaryCall(
|
|
getChannel().newCall(getGetJointStateMethod(), getCallOptions()), request);
|
|
}
|
|
}
|
|
|
|
private static final int METHODID_TORQUE_OFF = 0;
|
|
private static final int METHODID_TORQUE_ON = 1;
|
|
private static final int METHODID_MOVE_J = 2;
|
|
private static final int METHODID_MOVE_L = 3;
|
|
private static final int METHODID_SPEED_J = 4;
|
|
private static final int METHODID_SPEED_L = 5;
|
|
private static final int METHODID_GET_JOINT_STATE = 6;
|
|
|
|
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 HumanoidRobotServiceImplBase serviceImpl;
|
|
private final int methodId;
|
|
|
|
MethodHandlers(HumanoidRobotServiceImplBase 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_TORQUE_OFF:
|
|
serviceImpl.torqueOff((cmvr.api.Common.CommandHeader.Request) request,
|
|
(io.grpc.stub.StreamObserver<cmvr.api.Common.CommandHeader.Feedback>) responseObserver);
|
|
break;
|
|
case METHODID_TORQUE_ON:
|
|
serviceImpl.torqueOn((cmvr.api.Common.CommandHeader.Request) request,
|
|
(io.grpc.stub.StreamObserver<cmvr.api.Common.CommandHeader.Feedback>) responseObserver);
|
|
break;
|
|
case METHODID_MOVE_J:
|
|
serviceImpl.moveJ((cmvr.api.HumanoidRobotCommand.MoveJ.Request) request,
|
|
(io.grpc.stub.StreamObserver<cmvr.api.HumanoidRobotCommand.MoveJ.Response>) responseObserver);
|
|
break;
|
|
case METHODID_MOVE_L:
|
|
serviceImpl.moveL((cmvr.api.HumanoidRobotCommand.MoveL.Request) request,
|
|
(io.grpc.stub.StreamObserver<cmvr.api.HumanoidRobotCommand.MoveL.Response>) responseObserver);
|
|
break;
|
|
case METHODID_SPEED_J:
|
|
serviceImpl.speedJ((cmvr.api.HumanoidRobotCommand.SpeedJ.Request) request,
|
|
(io.grpc.stub.StreamObserver<cmvr.api.HumanoidRobotCommand.SpeedJ.Response>) responseObserver);
|
|
break;
|
|
case METHODID_SPEED_L:
|
|
serviceImpl.speedL((cmvr.api.HumanoidRobotCommand.SpeedL.Request) request,
|
|
(io.grpc.stub.StreamObserver<cmvr.api.HumanoidRobotCommand.SpeedL.Response>) responseObserver);
|
|
break;
|
|
case METHODID_GET_JOINT_STATE:
|
|
serviceImpl.getJointState((cmvr.api.HumanoidRobotCommand.JointRequest) request,
|
|
(io.grpc.stub.StreamObserver<cmvr.api.HumanoidRobotCommand.JointResponse>) 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 HumanoidRobotServiceBaseDescriptorSupplier
|
|
implements io.grpc.protobuf.ProtoFileDescriptorSupplier, io.grpc.protobuf.ProtoServiceDescriptorSupplier {
|
|
HumanoidRobotServiceBaseDescriptorSupplier() {}
|
|
|
|
@java.lang.Override
|
|
public com.google.protobuf.Descriptors.FileDescriptor getFileDescriptor() {
|
|
return cmvr.api.HumanoidRobotServiceOuterClass.getDescriptor();
|
|
}
|
|
|
|
@java.lang.Override
|
|
public com.google.protobuf.Descriptors.ServiceDescriptor getServiceDescriptor() {
|
|
return getFileDescriptor().findServiceByName("HumanoidRobotService");
|
|
}
|
|
}
|
|
|
|
private static final class HumanoidRobotServiceFileDescriptorSupplier
|
|
extends HumanoidRobotServiceBaseDescriptorSupplier {
|
|
HumanoidRobotServiceFileDescriptorSupplier() {}
|
|
}
|
|
|
|
private static final class HumanoidRobotServiceMethodDescriptorSupplier
|
|
extends HumanoidRobotServiceBaseDescriptorSupplier
|
|
implements io.grpc.protobuf.ProtoMethodDescriptorSupplier {
|
|
private final String methodName;
|
|
|
|
HumanoidRobotServiceMethodDescriptorSupplier(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 (HumanoidRobotServiceGrpc.class) {
|
|
result = serviceDescriptor;
|
|
if (result == null) {
|
|
serviceDescriptor = result = io.grpc.ServiceDescriptor.newBuilder(SERVICE_NAME)
|
|
.setSchemaDescriptor(new HumanoidRobotServiceFileDescriptorSupplier())
|
|
.addMethod(getTorqueOffMethod())
|
|
.addMethod(getTorqueOnMethod())
|
|
.addMethod(getMoveJMethod())
|
|
.addMethod(getMoveLMethod())
|
|
.addMethod(getSpeedJMethod())
|
|
.addMethod(getSpeedLMethod())
|
|
.addMethod(getGetJointStateMethod())
|
|
.build();
|
|
}
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
}
|