jointData.cpp

Go to the documentation of this file.

/*
 * SPDX-FileCopyrightText: 2006-2021 Istituto Italiano di Tecnologia (IIT)
 * SPDX-License-Identifier: BSD-3-Clause
 */
 
// Autogenerated by Thrift Compiler (0.14.1-yarped)
//
// This is an automatically generated file.
// It could get re-generated if the ALLOW_IDL_GENERATION flag is on.
 
#include <yarp/dev/impl/jointData.h>
 
namespace yarp::dev::impl {
 
// Constructor with field values
jointData::jointData(const yarp::sig::VectorOf<double>& jointPosition,
                     const bool jointPosition_isValid,
                     const yarp::sig::VectorOf<double>& jointVelocity,
                     const bool jointVelocity_isValid,
                     const yarp::sig::VectorOf<double>& jointAcceleration,
                     const bool jointAcceleration_isValid,
                     const yarp::sig::VectorOf<double>& motorPosition,
                     const bool motorPosition_isValid,
                     const yarp::sig::VectorOf<double>& motorVelocity,
                     const bool motorVelocity_isValid,
                     const yarp::sig::VectorOf<double>& motorAcceleration,
                     const bool motorAcceleration_isValid,
                     const yarp::sig::VectorOf<double>& torque,
                     const bool torque_isValid,
                     const yarp::sig::VectorOf<double>& pwmDutycycle,
                     const bool pwmDutycycle_isValid,
                     const yarp::sig::VectorOf<double>& current,
                     const bool current_isValid,
                     const yarp::sig::VectorOf<int>& controlMode,
                     const bool controlMode_isValid,
                     const yarp::sig::VectorOf<int>& interactionMode,
                     const bool interactionMode_isValid) :
        WirePortable(),
        jointPosition(jointPosition),
        jointPosition_isValid(jointPosition_isValid),
        jointVelocity(jointVelocity),
        jointVelocity_isValid(jointVelocity_isValid),
        jointAcceleration(jointAcceleration),
        jointAcceleration_isValid(jointAcceleration_isValid),
        motorPosition(motorPosition),
        motorPosition_isValid(motorPosition_isValid),
        motorVelocity(motorVelocity),
        motorVelocity_isValid(motorVelocity_isValid),
        motorAcceleration(motorAcceleration),
        motorAcceleration_isValid(motorAcceleration_isValid),
        torque(torque),
        torque_isValid(torque_isValid),
        pwmDutycycle(pwmDutycycle),
        pwmDutycycle_isValid(pwmDutycycle_isValid),
        current(current),
        current_isValid(current_isValid),
        controlMode(controlMode),
        controlMode_isValid(controlMode_isValid),
        interactionMode(interactionMode),
        interactionMode_isValid(interactionMode_isValid)
{
}
 
// Read structure on a Wire
bool jointData::read(yarp::os::idl::WireReader& reader)
{
    if (!nested_read_jointPosition(reader)) {
        return false;
    }
    if (!read_jointPosition_isValid(reader)) {
        return false;
    }
    if (!nested_read_jointVelocity(reader)) {
        return false;
    }
    if (!read_jointVelocity_isValid(reader)) {
        return false;
    }
    if (!nested_read_jointAcceleration(reader)) {
        return false;
    }
    if (!read_jointAcceleration_isValid(reader)) {
        return false;
    }
    if (!nested_read_motorPosition(reader)) {
        return false;
    }
    if (!read_motorPosition_isValid(reader)) {
        return false;
    }
    if (!nested_read_motorVelocity(reader)) {
        return false;
    }
    if (!read_motorVelocity_isValid(reader)) {
        return false;
    }
    if (!nested_read_motorAcceleration(reader)) {
        return false;
    }
    if (!read_motorAcceleration_isValid(reader)) {
        return false;
    }
    if (!nested_read_torque(reader)) {
        return false;
    }
    if (!read_torque_isValid(reader)) {
        return false;
    }
    if (!nested_read_pwmDutycycle(reader)) {
        return false;
    }
    if (!read_pwmDutycycle_isValid(reader)) {
        return false;
    }
    if (!nested_read_current(reader)) {
        return false;
    }
    if (!read_current_isValid(reader)) {
        return false;
    }
    if (!nested_read_controlMode(reader)) {
        return false;
    }
    if (!read_controlMode_isValid(reader)) {
        return false;
    }
    if (!nested_read_interactionMode(reader)) {
        return false;
    }
    if (!read_interactionMode_isValid(reader)) {
        return false;
    }
    if (reader.isError()) {
        return false;
    }
    return true;
}
 
// Read structure on a Connection
bool jointData::read(yarp::os::ConnectionReader& connection)
{
    yarp::os::idl::WireReader reader(connection);
    if (!reader.readListHeader(22)) {
        return false;
    }
    if (!read(reader)) {
        return false;
    }
    return true;
}
 
// Write structure on a Wire
bool jointData::write(const yarp::os::idl::WireWriter& writer) const
{
    if (!nested_write_jointPosition(writer)) {
        return false;
    }
    if (!write_jointPosition_isValid(writer)) {
        return false;
    }
    if (!nested_write_jointVelocity(writer)) {
        return false;
    }
    if (!write_jointVelocity_isValid(writer)) {
        return false;
    }
    if (!nested_write_jointAcceleration(writer)) {
        return false;
    }
    if (!write_jointAcceleration_isValid(writer)) {
        return false;
    }
    if (!nested_write_motorPosition(writer)) {
        return false;
    }
    if (!write_motorPosition_isValid(writer)) {
        return false;
    }
    if (!nested_write_motorVelocity(writer)) {
        return false;
    }
    if (!write_motorVelocity_isValid(writer)) {
        return false;
    }
    if (!nested_write_motorAcceleration(writer)) {
        return false;
    }
    if (!write_motorAcceleration_isValid(writer)) {
        return false;
    }
    if (!nested_write_torque(writer)) {
        return false;
    }
    if (!write_torque_isValid(writer)) {
        return false;
    }
    if (!nested_write_pwmDutycycle(writer)) {
        return false;
    }
    if (!write_pwmDutycycle_isValid(writer)) {
        return false;
    }
    if (!nested_write_current(writer)) {
        return false;
    }
    if (!write_current_isValid(writer)) {
        return false;
    }
    if (!nested_write_controlMode(writer)) {
        return false;
    }
    if (!write_controlMode_isValid(writer)) {
        return false;
    }
    if (!nested_write_interactionMode(writer)) {
        return false;
    }
    if (!write_interactionMode_isValid(writer)) {
        return false;
    }
    if (writer.isError()) {
        return false;
    }
    return true;
}
 
// Write structure on a Connection
bool jointData::write(yarp::os::ConnectionWriter& connection) const
{
    yarp::os::idl::WireWriter writer(connection);
    if (!writer.writeListHeader(22)) {
        return false;
    }
    if (!write(writer)) {
        return false;
    }
    return true;
}
 
// Convert to a printable string
std::string jointData::toString() const
{
    yarp::os::Bottle b;
    if (!yarp::os::Portable::copyPortable(*this, b)) {
        return {};
    }
    return b.toString();
}
 
// read jointPosition field
bool jointData::read_jointPosition(yarp::os::idl::WireReader& reader)
{
    if (reader.noMore()) {
        reader.fail();
        return false;
    }
    if (!reader.read(jointPosition)) {
        reader.fail();
        return false;
    }
    return true;
}
 
// write jointPosition field
bool jointData::write_jointPosition(const yarp::os::idl::WireWriter& writer) const
{
    if (!writer.write(jointPosition)) {
        return false;
    }
    return true;
}
 
// read (nested) jointPosition field
bool jointData::nested_read_jointPosition(yarp::os::idl::WireReader& reader)
{
    if (reader.noMore()) {
        reader.fail();
        return false;
    }
    if (!reader.readNested(jointPosition)) {
        reader.fail();
        return false;
    }
    return true;
}
 
// write (nested) jointPosition field
bool jointData::nested_write_jointPosition(const yarp::os::idl::WireWriter& writer) const
{
    if (!writer.writeNested(jointPosition)) {
        return false;
    }
    return true;
}
 
// read jointPosition_isValid field
bool jointData::read_jointPosition_isValid(yarp::os::idl::WireReader& reader)
{
    if (reader.noMore()) {
        reader.fail();
        return false;
    }
    if (!reader.readBool(jointPosition_isValid)) {
        reader.fail();
        return false;
    }
    return true;
}
 
// write jointPosition_isValid field
bool jointData::write_jointPosition_isValid(const yarp::os::idl::WireWriter& writer) const
{
    if (!writer.writeBool(jointPosition_isValid)) {
        return false;
    }
    return true;
}
 
// read (nested) jointPosition_isValid field
bool jointData::nested_read_jointPosition_isValid(yarp::os::idl::WireReader& reader)
{
    if (reader.noMore()) {
        reader.fail();
        return false;
    }
    if (!reader.readBool(jointPosition_isValid)) {
        reader.fail();
        return false;
    }
    return true;
}
 
// write (nested) jointPosition_isValid field
bool jointData::nested_write_jointPosition_isValid(const yarp::os::idl::WireWriter& writer) const
{
    if (!writer.writeBool(jointPosition_isValid)) {
        return false;
    }
    return true;
}
 
// read jointVelocity field
bool jointData::read_jointVelocity(yarp::os::idl::WireReader& reader)
{
    if (reader.noMore()) {
        reader.fail();
        return false;
    }
    if (!reader.read(jointVelocity)) {
        reader.fail();
        return false;
    }
    return true;
}
 
// write jointVelocity field
bool jointData::write_jointVelocity(const yarp::os::idl::WireWriter& writer) const
{
    if (!writer.write(jointVelocity)) {
        return false;
    }
    return true;
}
 
// read (nested) jointVelocity field
bool jointData::nested_read_jointVelocity(yarp::os::idl::WireReader& reader)
{
    if (reader.noMore()) {
        reader.fail();
        return false;
    }
    if (!reader.readNested(jointVelocity)) {
        reader.fail();
        return false;
    }
    return true;
}
 
// write (nested) jointVelocity field
bool jointData::nested_write_jointVelocity(const yarp::os::idl::WireWriter& writer) const
{
    if (!writer.writeNested(jointVelocity)) {
        return false;
    }
    return true;
}
 
// read jointVelocity_isValid field
bool jointData::read_jointVelocity_isValid(yarp::os::idl::WireReader& reader)
{
    if (reader.noMore()) {
        reader.fail();
        return false;
    }
    if (!reader.readBool(jointVelocity_isValid)) {
        reader.fail();
        return false;
    }
    return true;
}
 
// write jointVelocity_isValid field
bool jointData::write_jointVelocity_isValid(const yarp::os::idl::WireWriter& writer) const
{
    if (!writer.writeBool(jointVelocity_isValid)) {
        return false;
    }
    return true;
}
 
// read (nested) jointVelocity_isValid field
bool jointData::nested_read_jointVelocity_isValid(yarp::os::idl::WireReader& reader)
{
    if (reader.noMore()) {
        reader.fail();
        return false;
    }
    if (!reader.readBool(jointVelocity_isValid)) {
        reader.fail();
        return false;
    }
    return true;
}
 
// write (nested) jointVelocity_isValid field
bool jointData::nested_write_jointVelocity_isValid(const yarp::os::idl::WireWriter& writer) const
{
    if (!writer.writeBool(jointVelocity_isValid)) {
        return false;
    }
    return true;
}
 
// read jointAcceleration field
bool jointData::read_jointAcceleration(yarp::os::idl::WireReader& reader)
{
    if (reader.noMore()) {
        reader.fail();
        return false;
    }
    if (!reader.read(jointAcceleration)) {
        reader.fail();
        return false;
    }
    return true;
}
 
// write jointAcceleration field
bool jointData::write_jointAcceleration(const yarp::os::idl::WireWriter& writer) const
{
    if (!writer.write(jointAcceleration)) {
        return false;
    }
    return true;
}
 
// read (nested) jointAcceleration field
bool jointData::nested_read_jointAcceleration(yarp::os::idl::WireReader& reader)
{
    if (reader.noMore()) {
        reader.fail();
        return false;
    }
    if (!reader.readNested(jointAcceleration)) {
        reader.fail();
        return false;
    }
    return true;
}
 
// write (nested) jointAcceleration field
bool jointData::nested_write_jointAcceleration(const yarp::os::idl::WireWriter& writer) const
{
    if (!writer.writeNested(jointAcceleration)) {
        return false;
    }
    return true;
}
 
// read jointAcceleration_isValid field
bool jointData::read_jointAcceleration_isValid(yarp::os::idl::WireReader& reader)
{
    if (reader.noMore()) {
        reader.fail();
        return false;
    }
    if (!reader.readBool(jointAcceleration_isValid)) {
        reader.fail();
        return false;
    }
    return true;
}
 
// write jointAcceleration_isValid field
bool jointData::write_jointAcceleration_isValid(const yarp::os::idl::WireWriter& writer) const
{
    if (!writer.writeBool(jointAcceleration_isValid)) {
        return false;
    }
    return true;
}
 
// read (nested) jointAcceleration_isValid field
bool jointData::nested_read_jointAcceleration_isValid(yarp::os::idl::WireReader& reader)
{
    if (reader.noMore()) {
        reader.fail();
        return false;
    }
    if (!reader.readBool(jointAcceleration_isValid)) {
        reader.fail();
        return false;
    }
    return true;
}
 
// write (nested) jointAcceleration_isValid field
bool jointData::nested_write_jointAcceleration_isValid(const yarp::os::idl::WireWriter& writer) const
{
    if (!writer.writeBool(jointAcceleration_isValid)) {
        return false;
    }
    return true;
}
 
// read motorPosition field
bool jointData::read_motorPosition(yarp::os::idl::WireReader& reader)
{
    if (reader.noMore()) {
        reader.fail();
        return false;
    }
    if (!reader.read(motorPosition)) {
        reader.fail();
        return false;
    }
    return true;
}
 
// write motorPosition field
bool jointData::write_motorPosition(const yarp::os::idl::WireWriter& writer) const
{
    if (!writer.write(motorPosition)) {
        return false;
    }
    return true;
}
 
// read (nested) motorPosition field
bool jointData::nested_read_motorPosition(yarp::os::idl::WireReader& reader)
{
    if (reader.noMore()) {
        reader.fail();
        return false;
    }
    if (!reader.readNested(motorPosition)) {
        reader.fail();
        return false;
    }
    return true;
}
 
// write (nested) motorPosition field
bool jointData::nested_write_motorPosition(const yarp::os::idl::WireWriter& writer) const
{
    if (!writer.writeNested(motorPosition)) {
        return false;
    }
    return true;
}
 
// read motorPosition_isValid field
bool jointData::read_motorPosition_isValid(yarp::os::idl::WireReader& reader)
{
    if (reader.noMore()) {
        reader.fail();
        return false;
    }
    if (!reader.readBool(motorPosition_isValid)) {
        reader.fail();
        return false;
    }
    return true;
}
 
// write motorPosition_isValid field
bool jointData::write_motorPosition_isValid(const yarp::os::idl::WireWriter& writer) const
{
    if (!writer.writeBool(motorPosition_isValid)) {
        return false;
    }
    return true;
}
 
// read (nested) motorPosition_isValid field
bool jointData::nested_read_motorPosition_isValid(yarp::os::idl::WireReader& reader)
{
    if (reader.noMore()) {
        reader.fail();
        return false;
    }
    if (!reader.readBool(motorPosition_isValid)) {
        reader.fail();
        return false;
    }
    return true;
}
 
// write (nested) motorPosition_isValid field
bool jointData::nested_write_motorPosition_isValid(const yarp::os::idl::WireWriter& writer) const
{
    if (!writer.writeBool(motorPosition_isValid)) {
        return false;
    }
    return true;
}
 
// read motorVelocity field
bool jointData::read_motorVelocity(yarp::os::idl::WireReader& reader)
{
    if (reader.noMore()) {
        reader.fail();
        return false;
    }
    if (!reader.read(motorVelocity)) {
        reader.fail();
        return false;
    }
    return true;
}
 
// write motorVelocity field
bool jointData::write_motorVelocity(const yarp::os::idl::WireWriter& writer) const
{
    if (!writer.write(motorVelocity)) {
        return false;
    }
    return true;
}
 
// read (nested) motorVelocity field
bool jointData::nested_read_motorVelocity(yarp::os::idl::WireReader& reader)
{
    if (reader.noMore()) {
        reader.fail();
        return false;
    }
    if (!reader.readNested(motorVelocity)) {
        reader.fail();
        return false;
    }
    return true;
}
 
// write (nested) motorVelocity field
bool jointData::nested_write_motorVelocity(const yarp::os::idl::WireWriter& writer) const
{
    if (!writer.writeNested(motorVelocity)) {
        return false;
    }
    return true;
}
 
// read motorVelocity_isValid field
bool jointData::read_motorVelocity_isValid(yarp::os::idl::WireReader& reader)
{
    if (reader.noMore()) {
        reader.fail();
        return false;
    }
    if (!reader.readBool(motorVelocity_isValid)) {
        reader.fail();
        return false;
    }
    return true;
}
 
// write motorVelocity_isValid field
bool jointData::write_motorVelocity_isValid(const yarp::os::idl::WireWriter& writer) const
{
    if (!writer.writeBool(motorVelocity_isValid)) {
        return false;
    }
    return true;
}
 
// read (nested) motorVelocity_isValid field
bool jointData::nested_read_motorVelocity_isValid(yarp::os::idl::WireReader& reader)
{
    if (reader.noMore()) {
        reader.fail();
        return false;
    }
    if (!reader.readBool(motorVelocity_isValid)) {
        reader.fail();
        return false;
    }
    return true;
}
 
// write (nested) motorVelocity_isValid field
bool jointData::nested_write_motorVelocity_isValid(const yarp::os::idl::WireWriter& writer) const
{
    if (!writer.writeBool(motorVelocity_isValid)) {
        return false;
    }
    return true;
}
 
// read motorAcceleration field
bool jointData::read_motorAcceleration(yarp::os::idl::WireReader& reader)
{
    if (reader.noMore()) {
        reader.fail();
        return false;
    }
    if (!reader.read(motorAcceleration)) {
        reader.fail();
        return false;
    }
    return true;
}
 
// write motorAcceleration field
bool jointData::write_motorAcceleration(const yarp::os::idl::WireWriter& writer) const
{
    if (!writer.write(motorAcceleration)) {
        return false;
    }
    return true;
}
 
// read (nested) motorAcceleration field
bool jointData::nested_read_motorAcceleration(yarp::os::idl::WireReader& reader)
{
    if (reader.noMore()) {
        reader.fail();
        return false;
    }
    if (!reader.readNested(motorAcceleration)) {
        reader.fail();
        return false;
    }
    return true;
}
 
// write (nested) motorAcceleration field
bool jointData::nested_write_motorAcceleration(const yarp::os::idl::WireWriter& writer) const
{
    if (!writer.writeNested(motorAcceleration)) {
        return false;
    }
    return true;
}
 
// read motorAcceleration_isValid field
bool jointData::read_motorAcceleration_isValid(yarp::os::idl::WireReader& reader)
{
    if (reader.noMore()) {
        reader.fail();
        return false;
    }
    if (!reader.readBool(motorAcceleration_isValid)) {
        reader.fail();
        return false;
    }
    return true;
}
 
// write motorAcceleration_isValid field
bool jointData::write_motorAcceleration_isValid(const yarp::os::idl::WireWriter& writer) const
{
    if (!writer.writeBool(motorAcceleration_isValid)) {
        return false;
    }
    return true;
}
 
// read (nested) motorAcceleration_isValid field
bool jointData::nested_read_motorAcceleration_isValid(yarp::os::idl::WireReader& reader)
{
    if (reader.noMore()) {
        reader.fail();
        return false;
    }
    if (!reader.readBool(motorAcceleration_isValid)) {
        reader.fail();
        return false;
    }
    return true;
}
 
// write (nested) motorAcceleration_isValid field
bool jointData::nested_write_motorAcceleration_isValid(const yarp::os::idl::WireWriter& writer) const
{
    if (!writer.writeBool(motorAcceleration_isValid)) {
        return false;
    }
    return true;
}
 
// read torque field
bool jointData::read_torque(yarp::os::idl::WireReader& reader)
{
    if (reader.noMore()) {
        reader.fail();
        return false;
    }
    if (!reader.read(torque)) {
        reader.fail();
        return false;
    }
    return true;
}
 
// write torque field
bool jointData::write_torque(const yarp::os::idl::WireWriter& writer) const
{
    if (!writer.write(torque)) {
        return false;
    }
    return true;
}
 
// read (nested) torque field
bool jointData::nested_read_torque(yarp::os::idl::WireReader& reader)
{
    if (reader.noMore()) {
        reader.fail();
        return false;
    }
    if (!reader.readNested(torque)) {
        reader.fail();
        return false;
    }
    return true;
}
 
// write (nested) torque field
bool jointData::nested_write_torque(const yarp::os::idl::WireWriter& writer) const
{
    if (!writer.writeNested(torque)) {
        return false;
    }
    return true;
}
 
// read torque_isValid field
bool jointData::read_torque_isValid(yarp::os::idl::WireReader& reader)
{
    if (reader.noMore()) {
        reader.fail();
        return false;
    }
    if (!reader.readBool(torque_isValid)) {
        reader.fail();
        return false;
    }
    return true;
}
 
// write torque_isValid field
bool jointData::write_torque_isValid(const yarp::os::idl::WireWriter& writer) const
{
    if (!writer.writeBool(torque_isValid)) {
        return false;
    }
    return true;
}
 
// read (nested) torque_isValid field
bool jointData::nested_read_torque_isValid(yarp::os::idl::WireReader& reader)
{
    if (reader.noMore()) {
        reader.fail();
        return false;
    }
    if (!reader.readBool(torque_isValid)) {
        reader.fail();
        return false;
    }
    return true;
}
 
// write (nested) torque_isValid field
bool jointData::nested_write_torque_isValid(const yarp::os::idl::WireWriter& writer) const
{
    if (!writer.writeBool(torque_isValid)) {
        return false;
    }
    return true;
}
 
// read pwmDutycycle field
bool jointData::read_pwmDutycycle(yarp::os::idl::WireReader& reader)
{
    if (reader.noMore()) {
        reader.fail();
        return false;
    }
    if (!reader.read(pwmDutycycle)) {
        reader.fail();
        return false;
    }
    return true;
}
 
// write pwmDutycycle field
bool jointData::write_pwmDutycycle(const yarp::os::idl::WireWriter& writer) const
{
    if (!writer.write(pwmDutycycle)) {
        return false;
    }
    return true;
}
 
// read (nested) pwmDutycycle field
bool jointData::nested_read_pwmDutycycle(yarp::os::idl::WireReader& reader)
{
    if (reader.noMore()) {
        reader.fail();
        return false;
    }
    if (!reader.readNested(pwmDutycycle)) {
        reader.fail();
        return false;
    }
    return true;
}
 
// write (nested) pwmDutycycle field
bool jointData::nested_write_pwmDutycycle(const yarp::os::idl::WireWriter& writer) const
{
    if (!writer.writeNested(pwmDutycycle)) {
        return false;
    }
    return true;
}
 
// read pwmDutycycle_isValid field
bool jointData::read_pwmDutycycle_isValid(yarp::os::idl::WireReader& reader)
{
    if (reader.noMore()) {
        reader.fail();
        return false;
    }
    if (!reader.readBool(pwmDutycycle_isValid)) {
        reader.fail();
        return false;
    }
    return true;
}
 
// write pwmDutycycle_isValid field
bool jointData::write_pwmDutycycle_isValid(const yarp::os::idl::WireWriter& writer) const
{
    if (!writer.writeBool(pwmDutycycle_isValid)) {
        return false;
    }
    return true;
}
 
// read (nested) pwmDutycycle_isValid field
bool jointData::nested_read_pwmDutycycle_isValid(yarp::os::idl::WireReader& reader)
{
    if (reader.noMore()) {
        reader.fail();
        return false;
    }
    if (!reader.readBool(pwmDutycycle_isValid)) {
        reader.fail();
        return false;
    }
    return true;
}
 
// write (nested) pwmDutycycle_isValid field
bool jointData::nested_write_pwmDutycycle_isValid(const yarp::os::idl::WireWriter& writer) const
{
    if (!writer.writeBool(pwmDutycycle_isValid)) {
        return false;
    }
    return true;
}
 
// read current field
bool jointData::read_current(yarp::os::idl::WireReader& reader)
{
    if (reader.noMore()) {
        reader.fail();
        return false;
    }
    if (!reader.read(current)) {
        reader.fail();
        return false;
    }
    return true;
}
 
// write current field
bool jointData::write_current(const yarp::os::idl::WireWriter& writer) const
{
    if (!writer.write(current)) {
        return false;
    }
    return true;
}
 
// read (nested) current field
bool jointData::nested_read_current(yarp::os::idl::WireReader& reader)
{
    if (reader.noMore()) {
        reader.fail();
        return false;
    }
    if (!reader.readNested(current)) {
        reader.fail();
        return false;
    }
    return true;
}
 
// write (nested) current field
bool jointData::nested_write_current(const yarp::os::idl::WireWriter& writer) const
{
    if (!writer.writeNested(current)) {
        return false;
    }
    return true;
}
 
// read current_isValid field
bool jointData::read_current_isValid(yarp::os::idl::WireReader& reader)
{
    if (reader.noMore()) {
        reader.fail();
        return false;
    }
    if (!reader.readBool(current_isValid)) {
        reader.fail();
        return false;
    }
    return true;
}
 
// write current_isValid field
bool jointData::write_current_isValid(const yarp::os::idl::WireWriter& writer) const
{
    if (!writer.writeBool(current_isValid)) {
        return false;
    }
    return true;
}
 
// read (nested) current_isValid field
bool jointData::nested_read_current_isValid(yarp::os::idl::WireReader& reader)
{
    if (reader.noMore()) {
        reader.fail();
        return false;
    }
    if (!reader.readBool(current_isValid)) {
        reader.fail();
        return false;
    }
    return true;
}
 
// write (nested) current_isValid field
bool jointData::nested_write_current_isValid(const yarp::os::idl::WireWriter& writer) const
{
    if (!writer.writeBool(current_isValid)) {
        return false;
    }
    return true;
}
 
// read controlMode field
bool jointData::read_controlMode(yarp::os::idl::WireReader& reader)
{
    if (reader.noMore()) {
        reader.fail();
        return false;
    }
    if (!reader.read(controlMode)) {
        reader.fail();
        return false;
    }
    return true;
}
 
// write controlMode field
bool jointData::write_controlMode(const yarp::os::idl::WireWriter& writer) const
{
    if (!writer.write(controlMode)) {
        return false;
    }
    return true;
}
 
// read (nested) controlMode field
bool jointData::nested_read_controlMode(yarp::os::idl::WireReader& reader)
{
    if (reader.noMore()) {
        reader.fail();
        return false;
    }
    if (!reader.readNested(controlMode)) {
        reader.fail();
        return false;
    }
    return true;
}
 
// write (nested) controlMode field
bool jointData::nested_write_controlMode(const yarp::os::idl::WireWriter& writer) const
{
    if (!writer.writeNested(controlMode)) {
        return false;
    }
    return true;
}
 
// read controlMode_isValid field
bool jointData::read_controlMode_isValid(yarp::os::idl::WireReader& reader)
{
    if (reader.noMore()) {
        reader.fail();
        return false;
    }
    if (!reader.readBool(controlMode_isValid)) {
        reader.fail();
        return false;
    }
    return true;
}
 
// write controlMode_isValid field
bool jointData::write_controlMode_isValid(const yarp::os::idl::WireWriter& writer) const
{
    if (!writer.writeBool(controlMode_isValid)) {
        return false;
    }
    return true;
}
 
// read (nested) controlMode_isValid field
bool jointData::nested_read_controlMode_isValid(yarp::os::idl::WireReader& reader)
{
    if (reader.noMore()) {
        reader.fail();
        return false;
    }
    if (!reader.readBool(controlMode_isValid)) {
        reader.fail();
        return false;
    }
    return true;
}
 
// write (nested) controlMode_isValid field
bool jointData::nested_write_controlMode_isValid(const yarp::os::idl::WireWriter& writer) const
{
    if (!writer.writeBool(controlMode_isValid)) {
        return false;
    }
    return true;
}
 
// read interactionMode field
bool jointData::read_interactionMode(yarp::os::idl::WireReader& reader)
{
    if (reader.noMore()) {
        reader.fail();
        return false;
    }
    if (!reader.read(interactionMode)) {
        reader.fail();
        return false;
    }
    return true;
}
 
// write interactionMode field
bool jointData::write_interactionMode(const yarp::os::idl::WireWriter& writer) const
{
    if (!writer.write(interactionMode)) {
        return false;
    }
    return true;
}
 
// read (nested) interactionMode field
bool jointData::nested_read_interactionMode(yarp::os::idl::WireReader& reader)
{
    if (reader.noMore()) {
        reader.fail();
        return false;
    }
    if (!reader.readNested(interactionMode)) {
        reader.fail();
        return false;
    }
    return true;
}
 
// write (nested) interactionMode field
bool jointData::nested_write_interactionMode(const yarp::os::idl::WireWriter& writer) const
{
    if (!writer.writeNested(interactionMode)) {
        return false;
    }
    return true;
}
 
// read interactionMode_isValid field
bool jointData::read_interactionMode_isValid(yarp::os::idl::WireReader& reader)
{
    if (reader.noMore()) {
        reader.fail();
        return false;
    }
    if (!reader.readBool(interactionMode_isValid)) {
        reader.fail();
        return false;
    }
    return true;
}
 
// write interactionMode_isValid field
bool jointData::write_interactionMode_isValid(const yarp::os::idl::WireWriter& writer) const
{
    if (!writer.writeBool(interactionMode_isValid)) {
        return false;
    }
    return true;
}
 
// read (nested) interactionMode_isValid field
bool jointData::nested_read_interactionMode_isValid(yarp::os::idl::WireReader& reader)
{
    if (reader.noMore()) {
        reader.fail();
        return false;
    }
    if (!reader.readBool(interactionMode_isValid)) {
        reader.fail();
        return false;
    }
    return true;
}
 
// write (nested) interactionMode_isValid field
bool jointData::nested_write_interactionMode_isValid(const yarp::os::idl::WireWriter& writer) const
{
    if (!writer.writeBool(interactionMode_isValid)) {
        return false;
    }
    return true;
}
 
} // namespace yarp::dev::impl