spot-sdk-ts/dist/bosdyn/api/gripper_command.js

TypeScript bindings based on protobufs (proto3) provided by Boston Dynamics

"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.ClawGripperCommand_Feedback = exports.ClawGripperCommand_Request = exports.ClawGripperCommand = exports.GripperCommand_Feedback = exports.GripperCommand_Request = exports.GripperCommand = exports.clawGripperCommand_Feedback_StatusToJSON = exports.clawGripperCommand_Feedback_StatusFromJSON = exports.ClawGripperCommand_Feedback_Status = exports.protobufPackage = void 0;
/* eslint-disable */
const basic_command_1 = require("./basic_command");
const trajectory_1 = require("./trajectory");
const minimal_1 = __importDefault(require("protobufjs/minimal"));
const wrappers_1 = require("../../google/protobuf/wrappers");
exports.protobufPackage = "bosdyn.api";
var ClawGripperCommand_Feedback_Status;
(function (ClawGripperCommand_Feedback_Status) {
    /** STATUS_UNKNOWN - STATUS_UNKNOWN should never be used. If used, an internal error has happened. */
    ClawGripperCommand_Feedback_Status[ClawGripperCommand_Feedback_Status["STATUS_UNKNOWN"] = 0] = "STATUS_UNKNOWN";
    /** STATUS_IN_PROGRESS - The gripper is opening or closing. */
    ClawGripperCommand_Feedback_Status[ClawGripperCommand_Feedback_Status["STATUS_IN_PROGRESS"] = 1] = "STATUS_IN_PROGRESS";
    /** STATUS_AT_GOAL - The gripper is at the final point of the trajectory. */
    ClawGripperCommand_Feedback_Status[ClawGripperCommand_Feedback_Status["STATUS_AT_GOAL"] = 2] = "STATUS_AT_GOAL";
    /** STATUS_APPLYING_FORCE - During a close, detected contact and transitioned to force control. */
    ClawGripperCommand_Feedback_Status[ClawGripperCommand_Feedback_Status["STATUS_APPLYING_FORCE"] = 3] = "STATUS_APPLYING_FORCE";
    ClawGripperCommand_Feedback_Status[ClawGripperCommand_Feedback_Status["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
})(ClawGripperCommand_Feedback_Status = exports.ClawGripperCommand_Feedback_Status || (exports.ClawGripperCommand_Feedback_Status = {}));
function clawGripperCommand_Feedback_StatusFromJSON(object) {
    switch (object) {
        case 0:
        case "STATUS_UNKNOWN":
            return ClawGripperCommand_Feedback_Status.STATUS_UNKNOWN;
        case 1:
        case "STATUS_IN_PROGRESS":
            return ClawGripperCommand_Feedback_Status.STATUS_IN_PROGRESS;
        case 2:
        case "STATUS_AT_GOAL":
            return ClawGripperCommand_Feedback_Status.STATUS_AT_GOAL;
        case 3:
        case "STATUS_APPLYING_FORCE":
            return ClawGripperCommand_Feedback_Status.STATUS_APPLYING_FORCE;
        case -1:
        case "UNRECOGNIZED":
        default:
            return ClawGripperCommand_Feedback_Status.UNRECOGNIZED;
    }
}
exports.clawGripperCommand_Feedback_StatusFromJSON = clawGripperCommand_Feedback_StatusFromJSON;
function clawGripperCommand_Feedback_StatusToJSON(object) {
    switch (object) {
        case ClawGripperCommand_Feedback_Status.STATUS_UNKNOWN:
            return "STATUS_UNKNOWN";
        case ClawGripperCommand_Feedback_Status.STATUS_IN_PROGRESS:
            return "STATUS_IN_PROGRESS";
        case ClawGripperCommand_Feedback_Status.STATUS_AT_GOAL:
            return "STATUS_AT_GOAL";
        case ClawGripperCommand_Feedback_Status.STATUS_APPLYING_FORCE:
            return "STATUS_APPLYING_FORCE";
        case ClawGripperCommand_Feedback_Status.UNRECOGNIZED:
        default:
            return "UNRECOGNIZED";
    }
}
exports.clawGripperCommand_Feedback_StatusToJSON = clawGripperCommand_Feedback_StatusToJSON;
function createBaseGripperCommand() {
    return {};
}
exports.GripperCommand = {
    encode(_, writer = minimal_1.default.Writer.create()) {
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseGripperCommand();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromJSON(_) {
        return {};
    },
    toJSON(_) {
        const obj = {};
        return obj;
    },
    fromPartial(_) {
        const message = createBaseGripperCommand();
        return message;
    },
};
function createBaseGripperCommand_Request() {
    return { clawGripperCommand: undefined };
}
exports.GripperCommand_Request = {
    encode(message, writer = minimal_1.default.Writer.create()) {
        if (message.clawGripperCommand !== undefined) {
            exports.ClawGripperCommand_Request.encode(message.clawGripperCommand, writer.uint32(10).fork()).ldelim();
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseGripperCommand_Request();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.clawGripperCommand = exports.ClawGripperCommand_Request.decode(reader, reader.uint32());
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromJSON(object) {
        return {
            clawGripperCommand: isSet(object.clawGripperCommand)
                ? exports.ClawGripperCommand_Request.fromJSON(object.clawGripperCommand)
                : undefined,
        };
    },
    toJSON(message) {
        const obj = {};
        message.clawGripperCommand !== undefined &&
            (obj.clawGripperCommand = message.clawGripperCommand
                ? exports.ClawGripperCommand_Request.toJSON(message.clawGripperCommand)
                : undefined);
        return obj;
    },
    fromPartial(object) {
        const message = createBaseGripperCommand_Request();
        message.clawGripperCommand =
            object.clawGripperCommand !== undefined &&
                object.clawGripperCommand !== null
                ? exports.ClawGripperCommand_Request.fromPartial(object.clawGripperCommand)
                : undefined;
        return message;
    },
};
function createBaseGripperCommand_Feedback() {
    return { clawGripperFeedback: undefined, status: 0 };
}
exports.GripperCommand_Feedback = {
    encode(message, writer = minimal_1.default.Writer.create()) {
        if (message.clawGripperFeedback !== undefined) {
            exports.ClawGripperCommand_Feedback.encode(message.clawGripperFeedback, writer.uint32(10).fork()).ldelim();
        }
        if (message.status !== 0) {
            writer.uint32(16).int32(message.status);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseGripperCommand_Feedback();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.clawGripperFeedback = exports.ClawGripperCommand_Feedback.decode(reader, reader.uint32());
                    break;
                case 2:
                    message.status = reader.int32();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromJSON(object) {
        return {
            clawGripperFeedback: isSet(object.clawGripperFeedback)
                ? exports.ClawGripperCommand_Feedback.fromJSON(object.clawGripperFeedback)
                : undefined,
            status: isSet(object.status)
                ? (0, basic_command_1.robotCommandFeedbackStatus_StatusFromJSON)(object.status)
                : 0,
        };
    },
    toJSON(message) {
        const obj = {};
        message.clawGripperFeedback !== undefined &&
            (obj.clawGripperFeedback = message.clawGripperFeedback
                ? exports.ClawGripperCommand_Feedback.toJSON(message.clawGripperFeedback)
                : undefined);
        message.status !== undefined &&
            (obj.status = (0, basic_command_1.robotCommandFeedbackStatus_StatusToJSON)(message.status));
        return obj;
    },
    fromPartial(object) {
        const message = createBaseGripperCommand_Feedback();
        message.clawGripperFeedback =
            object.clawGripperFeedback !== undefined &&
                object.clawGripperFeedback !== null
                ? exports.ClawGripperCommand_Feedback.fromPartial(object.clawGripperFeedback)
                : undefined;
        message.status = object.status ?? 0;
        return message;
    },
};
function createBaseClawGripperCommand() {
    return {};
}
exports.ClawGripperCommand = {
    encode(_, writer = minimal_1.default.Writer.create()) {
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseClawGripperCommand();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromJSON(_) {
        return {};
    },
    toJSON(_) {
        const obj = {};
        return obj;
    },
    fromPartial(_) {
        const message = createBaseClawGripperCommand();
        return message;
    },
};
function createBaseClawGripperCommand_Request() {
    return {
        trajectory: undefined,
        maximumOpenCloseVelocity: undefined,
        maximumOpenCloseAcceleration: undefined,
        maximumTorque: undefined,
        disableForceOnContact: false,
    };
}
exports.ClawGripperCommand_Request = {
    encode(message, writer = minimal_1.default.Writer.create()) {
        if (message.trajectory !== undefined) {
            trajectory_1.ScalarTrajectory.encode(message.trajectory, writer.uint32(42).fork()).ldelim();
        }
        if (message.maximumOpenCloseVelocity !== undefined) {
            wrappers_1.DoubleValue.encode({ value: message.maximumOpenCloseVelocity }, writer.uint32(18).fork()).ldelim();
        }
        if (message.maximumOpenCloseAcceleration !== undefined) {
            wrappers_1.DoubleValue.encode({ value: message.maximumOpenCloseAcceleration }, writer.uint32(26).fork()).ldelim();
        }
        if (message.maximumTorque !== undefined) {
            wrappers_1.DoubleValue.encode({ value: message.maximumTorque }, writer.uint32(34).fork()).ldelim();
        }
        if (message.disableForceOnContact === true) {
            writer.uint32(48).bool(message.disableForceOnContact);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseClawGripperCommand_Request();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 5:
                    message.trajectory = trajectory_1.ScalarTrajectory.decode(reader, reader.uint32());
                    break;
                case 2:
                    message.maximumOpenCloseVelocity = wrappers_1.DoubleValue.decode(reader, reader.uint32()).value;
                    break;
                case 3:
                    message.maximumOpenCloseAcceleration = wrappers_1.DoubleValue.decode(reader, reader.uint32()).value;
                    break;
                case 4:
                    message.maximumTorque = wrappers_1.DoubleValue.decode(reader, reader.uint32()).value;
                    break;
                case 6:
                    message.disableForceOnContact = reader.bool();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromJSON(object) {
        return {
            trajectory: isSet(object.trajectory)
                ? trajectory_1.ScalarTrajectory.fromJSON(object.trajectory)
                : undefined,
            maximumOpenCloseVelocity: isSet(object.maximumOpenCloseVelocity)
                ? Number(object.maximumOpenCloseVelocity)
                : undefined,
            maximumOpenCloseAcceleration: isSet(object.maximumOpenCloseAcceleration)
                ? Number(object.maximumOpenCloseAcceleration)
                : undefined,
            maximumTorque: isSet(object.maximumTorque)
                ? Number(object.maximumTorque)
                : undefined,
            disableForceOnContact: isSet(object.disableForceOnContact)
                ? Boolean(object.disableForceOnContact)
                : false,
        };
    },
    toJSON(message) {
        const obj = {};
        message.trajectory !== undefined &&
            (obj.trajectory = message.trajectory
                ? trajectory_1.ScalarTrajectory.toJSON(message.trajectory)
                : undefined);
        message.maximumOpenCloseVelocity !== undefined &&
            (obj.maximumOpenCloseVelocity = message.maximumOpenCloseVelocity);
        message.maximumOpenCloseAcceleration !== undefined &&
            (obj.maximumOpenCloseAcceleration = message.maximumOpenCloseAcceleration);
        message.maximumTorque !== undefined &&
            (obj.maximumTorque = message.maximumTorque);
        message.disableForceOnContact !== undefined &&
            (obj.disableForceOnContact = message.disableForceOnContact);
        return obj;
    },
    fromPartial(object) {
        const message = createBaseClawGripperCommand_Request();
        message.trajectory =
            object.trajectory !== undefined && object.trajectory !== null
                ? trajectory_1.ScalarTrajectory.fromPartial(object.trajectory)
                : undefined;
        message.maximumOpenCloseVelocity =
            object.maximumOpenCloseVelocity ?? undefined;
        message.maximumOpenCloseAcceleration =
            object.maximumOpenCloseAcceleration ?? undefined;
        message.maximumTorque = object.maximumTorque ?? undefined;
        message.disableForceOnContact = object.disableForceOnContact ?? false;
        return message;
    },
};
function createBaseClawGripperCommand_Feedback() {
    return { status: 0 };
}
exports.ClawGripperCommand_Feedback = {
    encode(message, writer = minimal_1.default.Writer.create()) {
        if (message.status !== 0) {
            writer.uint32(8).int32(message.status);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseClawGripperCommand_Feedback();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.status = reader.int32();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromJSON(object) {
        return {
            status: isSet(object.status)
                ? clawGripperCommand_Feedback_StatusFromJSON(object.status)
                : 0,
        };
    },
    toJSON(message) {
        const obj = {};
        message.status !== undefined &&
            (obj.status = clawGripperCommand_Feedback_StatusToJSON(message.status));
        return obj;
    },
    fromPartial(object) {
        const message = createBaseClawGripperCommand_Feedback();
        message.status = object.status ?? 0;
        return message;
    },
};
function isSet(value) {
    return value !== null && value !== undefined;
}
//# sourceMappingURL=gripper_command.js.map