SensorRPCData.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 <SensorRPCData.h>
 
// Constructor with field values
SensorRPCData::SensorRPCData(const std::vector<SensorMetadata>& ThreeAxisGyroscopes,
                             const std::vector<SensorMetadata>& ThreeAxisLinearAccelerometers,
                             const std::vector<SensorMetadata>& ThreeAxisMagnetometers,
                             const std::vector<SensorMetadata>& OrientationSensors,
                             const std::vector<SensorMetadata>& TemperatureSensors,
                             const std::vector<SensorMetadata>& SixAxisForceTorqueSensors,
                             const std::vector<SensorMetadata>& ContactLoadCellArrays,
                             const std::vector<SensorMetadata>& EncoderArrays,
                             const std::vector<SensorMetadata>& SkinPatches,
                             const std::vector<SensorMetadata>& PositionSensors,
                             const std::vector<SensorMetadata>& LinearVelocitySensors,
                             const std::vector<SensorMetadata>& ThreeAxisAngularAccelerometers) :
        WirePortable(),
        ThreeAxisGyroscopes(ThreeAxisGyroscopes),
        ThreeAxisLinearAccelerometers(ThreeAxisLinearAccelerometers),
        ThreeAxisMagnetometers(ThreeAxisMagnetometers),
        OrientationSensors(OrientationSensors),
        TemperatureSensors(TemperatureSensors),
        SixAxisForceTorqueSensors(SixAxisForceTorqueSensors),
        ContactLoadCellArrays(ContactLoadCellArrays),
        EncoderArrays(EncoderArrays),
        SkinPatches(SkinPatches),
        PositionSensors(PositionSensors),
        LinearVelocitySensors(LinearVelocitySensors),
        ThreeAxisAngularAccelerometers(ThreeAxisAngularAccelerometers)
{
}
 
// Read structure on a Wire
bool SensorRPCData::read(yarp::os::idl::WireReader& reader)
{
    if (!read_ThreeAxisGyroscopes(reader)) {
        return false;
    }
    if (!read_ThreeAxisLinearAccelerometers(reader)) {
        return false;
    }
    if (!read_ThreeAxisMagnetometers(reader)) {
        return false;
    }
    if (!read_OrientationSensors(reader)) {
        return false;
    }
    if (!read_TemperatureSensors(reader)) {
        return false;
    }
    if (!read_SixAxisForceTorqueSensors(reader)) {
        return false;
    }
    if (!read_ContactLoadCellArrays(reader)) {
        return false;
    }
    if (!read_EncoderArrays(reader)) {
        return false;
    }
    if (!read_SkinPatches(reader)) {
        return false;
    }
    if (!read_PositionSensors(reader)) {
        return false;
    }
    if (!read_LinearVelocitySensors(reader)) {
        return false;
    }
    if (!read_ThreeAxisAngularAccelerometers(reader)) {
        return false;
    }
    if (reader.isError()) {
        return false;
    }
    return true;
}
 
// Read structure on a Connection
bool SensorRPCData::read(yarp::os::ConnectionReader& connection)
{
    yarp::os::idl::WireReader reader(connection);
    if (!reader.readListHeader(12)) {
        return false;
    }
    if (!read(reader)) {
        return false;
    }
    return true;
}
 
// Write structure on a Wire
bool SensorRPCData::write(const yarp::os::idl::WireWriter& writer) const
{
    if (!write_ThreeAxisGyroscopes(writer)) {
        return false;
    }
    if (!write_ThreeAxisLinearAccelerometers(writer)) {
        return false;
    }
    if (!write_ThreeAxisMagnetometers(writer)) {
        return false;
    }
    if (!write_OrientationSensors(writer)) {
        return false;
    }
    if (!write_TemperatureSensors(writer)) {
        return false;
    }
    if (!write_SixAxisForceTorqueSensors(writer)) {
        return false;
    }
    if (!write_ContactLoadCellArrays(writer)) {
        return false;
    }
    if (!write_EncoderArrays(writer)) {
        return false;
    }
    if (!write_SkinPatches(writer)) {
        return false;
    }
    if (!write_PositionSensors(writer)) {
        return false;
    }
    if (!write_LinearVelocitySensors(writer)) {
        return false;
    }
    if (!write_ThreeAxisAngularAccelerometers(writer)) {
        return false;
    }
    if (writer.isError()) {
        return false;
    }
    return true;
}
 
// Write structure on a Connection
bool SensorRPCData::write(yarp::os::ConnectionWriter& connection) const
{
    yarp::os::idl::WireWriter writer(connection);
    if (!writer.writeListHeader(12)) {
        return false;
    }
    if (!write(writer)) {
        return false;
    }
    return true;
}
 
// Convert to a printable string
std::string SensorRPCData::toString() const
{
    yarp::os::Bottle b;
    if (!yarp::os::Portable::copyPortable(*this, b)) {
        return {};
    }
    return b.toString();
}
 
// read ThreeAxisGyroscopes field
bool SensorRPCData::read_ThreeAxisGyroscopes(yarp::os::idl::WireReader& reader)
{
    if (reader.noMore()) {
        reader.fail();
        return false;
    }
    size_t _csize;
    yarp::os::idl::WireState _etype;
    reader.readListBegin(_etype, _csize);
    // WireReader removes BOTTLE_TAG_LIST from the tag
    constexpr int expected_tag = ((BOTTLE_TAG_LIST) & (~BOTTLE_TAG_LIST));
    if constexpr (expected_tag != 0) {
        if (_csize != 0 && _etype.code != expected_tag) {
            return false;
        }
    }
    ThreeAxisGyroscopes.resize(_csize);
    for (size_t _i = 0; _i < _csize; ++_i) {
        if (reader.noMore()) {
            reader.fail();
            return false;
        }
        if (!reader.readNested(ThreeAxisGyroscopes[_i])) {
            reader.fail();
            return false;
        }
    }
    reader.readListEnd();
    return true;
}
 
// write ThreeAxisGyroscopes field
bool SensorRPCData::write_ThreeAxisGyroscopes(const yarp::os::idl::WireWriter& writer) const
{
    if (!writer.writeListBegin(BOTTLE_TAG_LIST, ThreeAxisGyroscopes.size())) {
        return false;
    }
    for (const auto& _item : ThreeAxisGyroscopes) {
        if (!writer.writeNested(_item)) {
            return false;
        }
    }
    if (!writer.writeListEnd()) {
        return false;
    }
    return true;
}
 
// read (nested) ThreeAxisGyroscopes field
bool SensorRPCData::nested_read_ThreeAxisGyroscopes(yarp::os::idl::WireReader& reader)
{
    if (reader.noMore()) {
        reader.fail();
        return false;
    }
    size_t _csize;
    yarp::os::idl::WireState _etype;
    reader.readListBegin(_etype, _csize);
    // WireReader removes BOTTLE_TAG_LIST from the tag
    constexpr int expected_tag = ((BOTTLE_TAG_LIST) & (~BOTTLE_TAG_LIST));
    if constexpr (expected_tag != 0) {
        if (_csize != 0 && _etype.code != expected_tag) {
            return false;
        }
    }
    ThreeAxisGyroscopes.resize(_csize);
    for (size_t _i = 0; _i < _csize; ++_i) {
        if (reader.noMore()) {
            reader.fail();
            return false;
        }
        if (!reader.readNested(ThreeAxisGyroscopes[_i])) {
            reader.fail();
            return false;
        }
    }
    reader.readListEnd();
    return true;
}
 
// write (nested) ThreeAxisGyroscopes field
bool SensorRPCData::nested_write_ThreeAxisGyroscopes(const yarp::os::idl::WireWriter& writer) const
{
    if (!writer.writeListBegin(BOTTLE_TAG_LIST, ThreeAxisGyroscopes.size())) {
        return false;
    }
    for (const auto& _item : ThreeAxisGyroscopes) {
        if (!writer.writeNested(_item)) {
            return false;
        }
    }
    if (!writer.writeListEnd()) {
        return false;
    }
    return true;
}
 
// read ThreeAxisLinearAccelerometers field
bool SensorRPCData::read_ThreeAxisLinearAccelerometers(yarp::os::idl::WireReader& reader)
{
    if (reader.noMore()) {
        reader.fail();
        return false;
    }
    size_t _csize;
    yarp::os::idl::WireState _etype;
    reader.readListBegin(_etype, _csize);
    // WireReader removes BOTTLE_TAG_LIST from the tag
    constexpr int expected_tag = ((BOTTLE_TAG_LIST) & (~BOTTLE_TAG_LIST));
    if constexpr (expected_tag != 0) {
        if (_csize != 0 && _etype.code != expected_tag) {
            return false;
        }
    }
    ThreeAxisLinearAccelerometers.resize(_csize);
    for (size_t _i = 0; _i < _csize; ++_i) {
        if (reader.noMore()) {
            reader.fail();
            return false;
        }
        if (!reader.readNested(ThreeAxisLinearAccelerometers[_i])) {
            reader.fail();
            return false;
        }
    }
    reader.readListEnd();
    return true;
}
 
// write ThreeAxisLinearAccelerometers field
bool SensorRPCData::write_ThreeAxisLinearAccelerometers(const yarp::os::idl::WireWriter& writer) const
{
    if (!writer.writeListBegin(BOTTLE_TAG_LIST, ThreeAxisLinearAccelerometers.size())) {
        return false;
    }
    for (const auto& _item : ThreeAxisLinearAccelerometers) {
        if (!writer.writeNested(_item)) {
            return false;
        }
    }
    if (!writer.writeListEnd()) {
        return false;
    }
    return true;
}
 
// read (nested) ThreeAxisLinearAccelerometers field
bool SensorRPCData::nested_read_ThreeAxisLinearAccelerometers(yarp::os::idl::WireReader& reader)
{
    if (reader.noMore()) {
        reader.fail();
        return false;
    }
    size_t _csize;
    yarp::os::idl::WireState _etype;
    reader.readListBegin(_etype, _csize);
    // WireReader removes BOTTLE_TAG_LIST from the tag
    constexpr int expected_tag = ((BOTTLE_TAG_LIST) & (~BOTTLE_TAG_LIST));
    if constexpr (expected_tag != 0) {
        if (_csize != 0 && _etype.code != expected_tag) {
            return false;
        }
    }
    ThreeAxisLinearAccelerometers.resize(_csize);
    for (size_t _i = 0; _i < _csize; ++_i) {
        if (reader.noMore()) {
            reader.fail();
            return false;
        }
        if (!reader.readNested(ThreeAxisLinearAccelerometers[_i])) {
            reader.fail();
            return false;
        }
    }
    reader.readListEnd();
    return true;
}
 
// write (nested) ThreeAxisLinearAccelerometers field
bool SensorRPCData::nested_write_ThreeAxisLinearAccelerometers(const yarp::os::idl::WireWriter& writer) const
{
    if (!writer.writeListBegin(BOTTLE_TAG_LIST, ThreeAxisLinearAccelerometers.size())) {
        return false;
    }
    for (const auto& _item : ThreeAxisLinearAccelerometers) {
        if (!writer.writeNested(_item)) {
            return false;
        }
    }
    if (!writer.writeListEnd()) {
        return false;
    }
    return true;
}
 
// read ThreeAxisMagnetometers field
bool SensorRPCData::read_ThreeAxisMagnetometers(yarp::os::idl::WireReader& reader)
{
    if (reader.noMore()) {
        reader.fail();
        return false;
    }
    size_t _csize;
    yarp::os::idl::WireState _etype;
    reader.readListBegin(_etype, _csize);
    // WireReader removes BOTTLE_TAG_LIST from the tag
    constexpr int expected_tag = ((BOTTLE_TAG_LIST) & (~BOTTLE_TAG_LIST));
    if constexpr (expected_tag != 0) {
        if (_csize != 0 && _etype.code != expected_tag) {
            return false;
        }
    }
    ThreeAxisMagnetometers.resize(_csize);
    for (size_t _i = 0; _i < _csize; ++_i) {
        if (reader.noMore()) {
            reader.fail();
            return false;
        }
        if (!reader.readNested(ThreeAxisMagnetometers[_i])) {
            reader.fail();
            return false;
        }
    }
    reader.readListEnd();
    return true;
}
 
// write ThreeAxisMagnetometers field
bool SensorRPCData::write_ThreeAxisMagnetometers(const yarp::os::idl::WireWriter& writer) const
{
    if (!writer.writeListBegin(BOTTLE_TAG_LIST, ThreeAxisMagnetometers.size())) {
        return false;
    }
    for (const auto& _item : ThreeAxisMagnetometers) {
        if (!writer.writeNested(_item)) {
            return false;
        }
    }
    if (!writer.writeListEnd()) {
        return false;
    }
    return true;
}
 
// read (nested) ThreeAxisMagnetometers field
bool SensorRPCData::nested_read_ThreeAxisMagnetometers(yarp::os::idl::WireReader& reader)
{
    if (reader.noMore()) {
        reader.fail();
        return false;
    }
    size_t _csize;
    yarp::os::idl::WireState _etype;
    reader.readListBegin(_etype, _csize);
    // WireReader removes BOTTLE_TAG_LIST from the tag
    constexpr int expected_tag = ((BOTTLE_TAG_LIST) & (~BOTTLE_TAG_LIST));
    if constexpr (expected_tag != 0) {
        if (_csize != 0 && _etype.code != expected_tag) {
            return false;
        }
    }
    ThreeAxisMagnetometers.resize(_csize);
    for (size_t _i = 0; _i < _csize; ++_i) {
        if (reader.noMore()) {
            reader.fail();
            return false;
        }
        if (!reader.readNested(ThreeAxisMagnetometers[_i])) {
            reader.fail();
            return false;
        }
    }
    reader.readListEnd();
    return true;
}
 
// write (nested) ThreeAxisMagnetometers field
bool SensorRPCData::nested_write_ThreeAxisMagnetometers(const yarp::os::idl::WireWriter& writer) const
{
    if (!writer.writeListBegin(BOTTLE_TAG_LIST, ThreeAxisMagnetometers.size())) {
        return false;
    }
    for (const auto& _item : ThreeAxisMagnetometers) {
        if (!writer.writeNested(_item)) {
            return false;
        }
    }
    if (!writer.writeListEnd()) {
        return false;
    }
    return true;
}
 
// read OrientationSensors field
bool SensorRPCData::read_OrientationSensors(yarp::os::idl::WireReader& reader)
{
    if (reader.noMore()) {
        reader.fail();
        return false;
    }
    size_t _csize;
    yarp::os::idl::WireState _etype;
    reader.readListBegin(_etype, _csize);
    // WireReader removes BOTTLE_TAG_LIST from the tag
    constexpr int expected_tag = ((BOTTLE_TAG_LIST) & (~BOTTLE_TAG_LIST));
    if constexpr (expected_tag != 0) {
        if (_csize != 0 && _etype.code != expected_tag) {
            return false;
        }
    }
    OrientationSensors.resize(_csize);
    for (size_t _i = 0; _i < _csize; ++_i) {
        if (reader.noMore()) {
            reader.fail();
            return false;
        }
        if (!reader.readNested(OrientationSensors[_i])) {
            reader.fail();
            return false;
        }
    }
    reader.readListEnd();
    return true;
}
 
// write OrientationSensors field
bool SensorRPCData::write_OrientationSensors(const yarp::os::idl::WireWriter& writer) const
{
    if (!writer.writeListBegin(BOTTLE_TAG_LIST, OrientationSensors.size())) {
        return false;
    }
    for (const auto& _item : OrientationSensors) {
        if (!writer.writeNested(_item)) {
            return false;
        }
    }
    if (!writer.writeListEnd()) {
        return false;
    }
    return true;
}
 
// read (nested) OrientationSensors field
bool SensorRPCData::nested_read_OrientationSensors(yarp::os::idl::WireReader& reader)
{
    if (reader.noMore()) {
        reader.fail();
        return false;
    }
    size_t _csize;
    yarp::os::idl::WireState _etype;
    reader.readListBegin(_etype, _csize);
    // WireReader removes BOTTLE_TAG_LIST from the tag
    constexpr int expected_tag = ((BOTTLE_TAG_LIST) & (~BOTTLE_TAG_LIST));
    if constexpr (expected_tag != 0) {
        if (_csize != 0 && _etype.code != expected_tag) {
            return false;
        }
    }
    OrientationSensors.resize(_csize);
    for (size_t _i = 0; _i < _csize; ++_i) {
        if (reader.noMore()) {
            reader.fail();
            return false;
        }
        if (!reader.readNested(OrientationSensors[_i])) {
            reader.fail();
            return false;
        }
    }
    reader.readListEnd();
    return true;
}
 
// write (nested) OrientationSensors field
bool SensorRPCData::nested_write_OrientationSensors(const yarp::os::idl::WireWriter& writer) const
{
    if (!writer.writeListBegin(BOTTLE_TAG_LIST, OrientationSensors.size())) {
        return false;
    }
    for (const auto& _item : OrientationSensors) {
        if (!writer.writeNested(_item)) {
            return false;
        }
    }
    if (!writer.writeListEnd()) {
        return false;
    }
    return true;
}
 
// read TemperatureSensors field
bool SensorRPCData::read_TemperatureSensors(yarp::os::idl::WireReader& reader)
{
    if (reader.noMore()) {
        reader.fail();
        return false;
    }
    size_t _csize;
    yarp::os::idl::WireState _etype;
    reader.readListBegin(_etype, _csize);
    // WireReader removes BOTTLE_TAG_LIST from the tag
    constexpr int expected_tag = ((BOTTLE_TAG_LIST) & (~BOTTLE_TAG_LIST));
    if constexpr (expected_tag != 0) {
        if (_csize != 0 && _etype.code != expected_tag) {
            return false;
        }
    }
    TemperatureSensors.resize(_csize);
    for (size_t _i = 0; _i < _csize; ++_i) {
        if (reader.noMore()) {
            reader.fail();
            return false;
        }
        if (!reader.readNested(TemperatureSensors[_i])) {
            reader.fail();
            return false;
        }
    }
    reader.readListEnd();
    return true;
}
 
// write TemperatureSensors field
bool SensorRPCData::write_TemperatureSensors(const yarp::os::idl::WireWriter& writer) const
{
    if (!writer.writeListBegin(BOTTLE_TAG_LIST, TemperatureSensors.size())) {
        return false;
    }
    for (const auto& _item : TemperatureSensors) {
        if (!writer.writeNested(_item)) {
            return false;
        }
    }
    if (!writer.writeListEnd()) {
        return false;
    }
    return true;
}
 
// read (nested) TemperatureSensors field
bool SensorRPCData::nested_read_TemperatureSensors(yarp::os::idl::WireReader& reader)
{
    if (reader.noMore()) {
        reader.fail();
        return false;
    }
    size_t _csize;
    yarp::os::idl::WireState _etype;
    reader.readListBegin(_etype, _csize);
    // WireReader removes BOTTLE_TAG_LIST from the tag
    constexpr int expected_tag = ((BOTTLE_TAG_LIST) & (~BOTTLE_TAG_LIST));
    if constexpr (expected_tag != 0) {
        if (_csize != 0 && _etype.code != expected_tag) {
            return false;
        }
    }
    TemperatureSensors.resize(_csize);
    for (size_t _i = 0; _i < _csize; ++_i) {
        if (reader.noMore()) {
            reader.fail();
            return false;
        }
        if (!reader.readNested(TemperatureSensors[_i])) {
            reader.fail();
            return false;
        }
    }
    reader.readListEnd();
    return true;
}
 
// write (nested) TemperatureSensors field
bool SensorRPCData::nested_write_TemperatureSensors(const yarp::os::idl::WireWriter& writer) const
{
    if (!writer.writeListBegin(BOTTLE_TAG_LIST, TemperatureSensors.size())) {
        return false;
    }
    for (const auto& _item : TemperatureSensors) {
        if (!writer.writeNested(_item)) {
            return false;
        }
    }
    if (!writer.writeListEnd()) {
        return false;
    }
    return true;
}
 
// read SixAxisForceTorqueSensors field
bool SensorRPCData::read_SixAxisForceTorqueSensors(yarp::os::idl::WireReader& reader)
{
    if (reader.noMore()) {
        reader.fail();
        return false;
    }
    size_t _csize;
    yarp::os::idl::WireState _etype;
    reader.readListBegin(_etype, _csize);
    // WireReader removes BOTTLE_TAG_LIST from the tag
    constexpr int expected_tag = ((BOTTLE_TAG_LIST) & (~BOTTLE_TAG_LIST));
    if constexpr (expected_tag != 0) {
        if (_csize != 0 && _etype.code != expected_tag) {
            return false;
        }
    }
    SixAxisForceTorqueSensors.resize(_csize);
    for (size_t _i = 0; _i < _csize; ++_i) {
        if (reader.noMore()) {
            reader.fail();
            return false;
        }
        if (!reader.readNested(SixAxisForceTorqueSensors[_i])) {
            reader.fail();
            return false;
        }
    }
    reader.readListEnd();
    return true;
}
 
// write SixAxisForceTorqueSensors field
bool SensorRPCData::write_SixAxisForceTorqueSensors(const yarp::os::idl::WireWriter& writer) const
{
    if (!writer.writeListBegin(BOTTLE_TAG_LIST, SixAxisForceTorqueSensors.size())) {
        return false;
    }
    for (const auto& _item : SixAxisForceTorqueSensors) {
        if (!writer.writeNested(_item)) {
            return false;
        }
    }
    if (!writer.writeListEnd()) {
        return false;
    }
    return true;
}
 
// read (nested) SixAxisForceTorqueSensors field
bool SensorRPCData::nested_read_SixAxisForceTorqueSensors(yarp::os::idl::WireReader& reader)
{
    if (reader.noMore()) {
        reader.fail();
        return false;
    }
    size_t _csize;
    yarp::os::idl::WireState _etype;
    reader.readListBegin(_etype, _csize);
    // WireReader removes BOTTLE_TAG_LIST from the tag
    constexpr int expected_tag = ((BOTTLE_TAG_LIST) & (~BOTTLE_TAG_LIST));
    if constexpr (expected_tag != 0) {
        if (_csize != 0 && _etype.code != expected_tag) {
            return false;
        }
    }
    SixAxisForceTorqueSensors.resize(_csize);
    for (size_t _i = 0; _i < _csize; ++_i) {
        if (reader.noMore()) {
            reader.fail();
            return false;
        }
        if (!reader.readNested(SixAxisForceTorqueSensors[_i])) {
            reader.fail();
            return false;
        }
    }
    reader.readListEnd();
    return true;
}
 
// write (nested) SixAxisForceTorqueSensors field
bool SensorRPCData::nested_write_SixAxisForceTorqueSensors(const yarp::os::idl::WireWriter& writer) const
{
    if (!writer.writeListBegin(BOTTLE_TAG_LIST, SixAxisForceTorqueSensors.size())) {
        return false;
    }
    for (const auto& _item : SixAxisForceTorqueSensors) {
        if (!writer.writeNested(_item)) {
            return false;
        }
    }
    if (!writer.writeListEnd()) {
        return false;
    }
    return true;
}
 
// read ContactLoadCellArrays field
bool SensorRPCData::read_ContactLoadCellArrays(yarp::os::idl::WireReader& reader)
{
    if (reader.noMore()) {
        reader.fail();
        return false;
    }
    size_t _csize;
    yarp::os::idl::WireState _etype;
    reader.readListBegin(_etype, _csize);
    // WireReader removes BOTTLE_TAG_LIST from the tag
    constexpr int expected_tag = ((BOTTLE_TAG_LIST) & (~BOTTLE_TAG_LIST));
    if constexpr (expected_tag != 0) {
        if (_csize != 0 && _etype.code != expected_tag) {
            return false;
        }
    }
    ContactLoadCellArrays.resize(_csize);
    for (size_t _i = 0; _i < _csize; ++_i) {
        if (reader.noMore()) {
            reader.fail();
            return false;
        }
        if (!reader.readNested(ContactLoadCellArrays[_i])) {
            reader.fail();
            return false;
        }
    }
    reader.readListEnd();
    return true;
}
 
// write ContactLoadCellArrays field
bool SensorRPCData::write_ContactLoadCellArrays(const yarp::os::idl::WireWriter& writer) const
{
    if (!writer.writeListBegin(BOTTLE_TAG_LIST, ContactLoadCellArrays.size())) {
        return false;
    }
    for (const auto& _item : ContactLoadCellArrays) {
        if (!writer.writeNested(_item)) {
            return false;
        }
    }
    if (!writer.writeListEnd()) {
        return false;
    }
    return true;
}
 
// read (nested) ContactLoadCellArrays field
bool SensorRPCData::nested_read_ContactLoadCellArrays(yarp::os::idl::WireReader& reader)
{
    if (reader.noMore()) {
        reader.fail();
        return false;
    }
    size_t _csize;
    yarp::os::idl::WireState _etype;
    reader.readListBegin(_etype, _csize);
    // WireReader removes BOTTLE_TAG_LIST from the tag
    constexpr int expected_tag = ((BOTTLE_TAG_LIST) & (~BOTTLE_TAG_LIST));
    if constexpr (expected_tag != 0) {
        if (_csize != 0 && _etype.code != expected_tag) {
            return false;
        }
    }
    ContactLoadCellArrays.resize(_csize);
    for (size_t _i = 0; _i < _csize; ++_i) {
        if (reader.noMore()) {
            reader.fail();
            return false;
        }
        if (!reader.readNested(ContactLoadCellArrays[_i])) {
            reader.fail();
            return false;
        }
    }
    reader.readListEnd();
    return true;
}
 
// write (nested) ContactLoadCellArrays field
bool SensorRPCData::nested_write_ContactLoadCellArrays(const yarp::os::idl::WireWriter& writer) const
{
    if (!writer.writeListBegin(BOTTLE_TAG_LIST, ContactLoadCellArrays.size())) {
        return false;
    }
    for (const auto& _item : ContactLoadCellArrays) {
        if (!writer.writeNested(_item)) {
            return false;
        }
    }
    if (!writer.writeListEnd()) {
        return false;
    }
    return true;
}
 
// read EncoderArrays field
bool SensorRPCData::read_EncoderArrays(yarp::os::idl::WireReader& reader)
{
    if (reader.noMore()) {
        reader.fail();
        return false;
    }
    size_t _csize;
    yarp::os::idl::WireState _etype;
    reader.readListBegin(_etype, _csize);
    // WireReader removes BOTTLE_TAG_LIST from the tag
    constexpr int expected_tag = ((BOTTLE_TAG_LIST) & (~BOTTLE_TAG_LIST));
    if constexpr (expected_tag != 0) {
        if (_csize != 0 && _etype.code != expected_tag) {
            return false;
        }
    }
    EncoderArrays.resize(_csize);
    for (size_t _i = 0; _i < _csize; ++_i) {
        if (reader.noMore()) {
            reader.fail();
            return false;
        }
        if (!reader.readNested(EncoderArrays[_i])) {
            reader.fail();
            return false;
        }
    }
    reader.readListEnd();
    return true;
}
 
// write EncoderArrays field
bool SensorRPCData::write_EncoderArrays(const yarp::os::idl::WireWriter& writer) const
{
    if (!writer.writeListBegin(BOTTLE_TAG_LIST, EncoderArrays.size())) {
        return false;
    }
    for (const auto& _item : EncoderArrays) {
        if (!writer.writeNested(_item)) {
            return false;
        }
    }
    if (!writer.writeListEnd()) {
        return false;
    }
    return true;
}
 
// read (nested) EncoderArrays field
bool SensorRPCData::nested_read_EncoderArrays(yarp::os::idl::WireReader& reader)
{
    if (reader.noMore()) {
        reader.fail();
        return false;
    }
    size_t _csize;
    yarp::os::idl::WireState _etype;
    reader.readListBegin(_etype, _csize);
    // WireReader removes BOTTLE_TAG_LIST from the tag
    constexpr int expected_tag = ((BOTTLE_TAG_LIST) & (~BOTTLE_TAG_LIST));
    if constexpr (expected_tag != 0) {
        if (_csize != 0 && _etype.code != expected_tag) {
            return false;
        }
    }
    EncoderArrays.resize(_csize);
    for (size_t _i = 0; _i < _csize; ++_i) {
        if (reader.noMore()) {
            reader.fail();
            return false;
        }
        if (!reader.readNested(EncoderArrays[_i])) {
            reader.fail();
            return false;
        }
    }
    reader.readListEnd();
    return true;
}
 
// write (nested) EncoderArrays field
bool SensorRPCData::nested_write_EncoderArrays(const yarp::os::idl::WireWriter& writer) const
{
    if (!writer.writeListBegin(BOTTLE_TAG_LIST, EncoderArrays.size())) {
        return false;
    }
    for (const auto& _item : EncoderArrays) {
        if (!writer.writeNested(_item)) {
            return false;
        }
    }
    if (!writer.writeListEnd()) {
        return false;
    }
    return true;
}
 
// read SkinPatches field
bool SensorRPCData::read_SkinPatches(yarp::os::idl::WireReader& reader)
{
    if (reader.noMore()) {
        reader.fail();
        return false;
    }
    size_t _csize;
    yarp::os::idl::WireState _etype;
    reader.readListBegin(_etype, _csize);
    // WireReader removes BOTTLE_TAG_LIST from the tag
    constexpr int expected_tag = ((BOTTLE_TAG_LIST) & (~BOTTLE_TAG_LIST));
    if constexpr (expected_tag != 0) {
        if (_csize != 0 && _etype.code != expected_tag) {
            return false;
        }
    }
    SkinPatches.resize(_csize);
    for (size_t _i = 0; _i < _csize; ++_i) {
        if (reader.noMore()) {
            reader.fail();
            return false;
        }
        if (!reader.readNested(SkinPatches[_i])) {
            reader.fail();
            return false;
        }
    }
    reader.readListEnd();
    return true;
}
 
// write SkinPatches field
bool SensorRPCData::write_SkinPatches(const yarp::os::idl::WireWriter& writer) const
{
    if (!writer.writeListBegin(BOTTLE_TAG_LIST, SkinPatches.size())) {
        return false;
    }
    for (const auto& _item : SkinPatches) {
        if (!writer.writeNested(_item)) {
            return false;
        }
    }
    if (!writer.writeListEnd()) {
        return false;
    }
    return true;
}
 
// read (nested) SkinPatches field
bool SensorRPCData::nested_read_SkinPatches(yarp::os::idl::WireReader& reader)
{
    if (reader.noMore()) {
        reader.fail();
        return false;
    }
    size_t _csize;
    yarp::os::idl::WireState _etype;
    reader.readListBegin(_etype, _csize);
    // WireReader removes BOTTLE_TAG_LIST from the tag
    constexpr int expected_tag = ((BOTTLE_TAG_LIST) & (~BOTTLE_TAG_LIST));
    if constexpr (expected_tag != 0) {
        if (_csize != 0 && _etype.code != expected_tag) {
            return false;
        }
    }
    SkinPatches.resize(_csize);
    for (size_t _i = 0; _i < _csize; ++_i) {
        if (reader.noMore()) {
            reader.fail();
            return false;
        }
        if (!reader.readNested(SkinPatches[_i])) {
            reader.fail();
            return false;
        }
    }
    reader.readListEnd();
    return true;
}
 
// write (nested) SkinPatches field
bool SensorRPCData::nested_write_SkinPatches(const yarp::os::idl::WireWriter& writer) const
{
    if (!writer.writeListBegin(BOTTLE_TAG_LIST, SkinPatches.size())) {
        return false;
    }
    for (const auto& _item : SkinPatches) {
        if (!writer.writeNested(_item)) {
            return false;
        }
    }
    if (!writer.writeListEnd()) {
        return false;
    }
    return true;
}
 
// read PositionSensors field
bool SensorRPCData::read_PositionSensors(yarp::os::idl::WireReader& reader)
{
    if (reader.noMore()) {
        reader.fail();
        return false;
    }
    size_t _csize;
    yarp::os::idl::WireState _etype;
    reader.readListBegin(_etype, _csize);
    // WireReader removes BOTTLE_TAG_LIST from the tag
    constexpr int expected_tag = ((BOTTLE_TAG_LIST) & (~BOTTLE_TAG_LIST));
    if constexpr (expected_tag != 0) {
        if (_csize != 0 && _etype.code != expected_tag) {
            return false;
        }
    }
    PositionSensors.resize(_csize);
    for (size_t _i = 0; _i < _csize; ++_i) {
        if (reader.noMore()) {
            reader.fail();
            return false;
        }
        if (!reader.readNested(PositionSensors[_i])) {
            reader.fail();
            return false;
        }
    }
    reader.readListEnd();
    return true;
}
 
// write PositionSensors field
bool SensorRPCData::write_PositionSensors(const yarp::os::idl::WireWriter& writer) const
{
    if (!writer.writeListBegin(BOTTLE_TAG_LIST, PositionSensors.size())) {
        return false;
    }
    for (const auto& _item : PositionSensors) {
        if (!writer.writeNested(_item)) {
            return false;
        }
    }
    if (!writer.writeListEnd()) {
        return false;
    }
    return true;
}
 
// read (nested) PositionSensors field
bool SensorRPCData::nested_read_PositionSensors(yarp::os::idl::WireReader& reader)
{
    if (reader.noMore()) {
        reader.fail();
        return false;
    }
    size_t _csize;
    yarp::os::idl::WireState _etype;
    reader.readListBegin(_etype, _csize);
    // WireReader removes BOTTLE_TAG_LIST from the tag
    constexpr int expected_tag = ((BOTTLE_TAG_LIST) & (~BOTTLE_TAG_LIST));
    if constexpr (expected_tag != 0) {
        if (_csize != 0 && _etype.code != expected_tag) {
            return false;
        }
    }
    PositionSensors.resize(_csize);
    for (size_t _i = 0; _i < _csize; ++_i) {
        if (reader.noMore()) {
            reader.fail();
            return false;
        }
        if (!reader.readNested(PositionSensors[_i])) {
            reader.fail();
            return false;
        }
    }
    reader.readListEnd();
    return true;
}
 
// write (nested) PositionSensors field
bool SensorRPCData::nested_write_PositionSensors(const yarp::os::idl::WireWriter& writer) const
{
    if (!writer.writeListBegin(BOTTLE_TAG_LIST, PositionSensors.size())) {
        return false;
    }
    for (const auto& _item : PositionSensors) {
        if (!writer.writeNested(_item)) {
            return false;
        }
    }
    if (!writer.writeListEnd()) {
        return false;
    }
    return true;
}
 
// read LinearVelocitySensors field
bool SensorRPCData::read_LinearVelocitySensors(yarp::os::idl::WireReader& reader)
{
    if (reader.noMore()) {
        reader.fail();
        return false;
    }
    size_t _csize;
    yarp::os::idl::WireState _etype;
    reader.readListBegin(_etype, _csize);
    // WireReader removes BOTTLE_TAG_LIST from the tag
    constexpr int expected_tag = ((BOTTLE_TAG_LIST) & (~BOTTLE_TAG_LIST));
    if constexpr (expected_tag != 0) {
        if (_csize != 0 && _etype.code != expected_tag) {
            return false;
        }
    }
    LinearVelocitySensors.resize(_csize);
    for (size_t _i = 0; _i < _csize; ++_i) {
        if (reader.noMore()) {
            reader.fail();
            return false;
        }
        if (!reader.readNested(LinearVelocitySensors[_i])) {
            reader.fail();
            return false;
        }
    }
    reader.readListEnd();
    return true;
}
 
// write LinearVelocitySensors field
bool SensorRPCData::write_LinearVelocitySensors(const yarp::os::idl::WireWriter& writer) const
{
    if (!writer.writeListBegin(BOTTLE_TAG_LIST, LinearVelocitySensors.size())) {
        return false;
    }
    for (const auto& _item : LinearVelocitySensors) {
        if (!writer.writeNested(_item)) {
            return false;
        }
    }
    if (!writer.writeListEnd()) {
        return false;
    }
    return true;
}
 
// read (nested) LinearVelocitySensors field
bool SensorRPCData::nested_read_LinearVelocitySensors(yarp::os::idl::WireReader& reader)
{
    if (reader.noMore()) {
        reader.fail();
        return false;
    }
    size_t _csize;
    yarp::os::idl::WireState _etype;
    reader.readListBegin(_etype, _csize);
    // WireReader removes BOTTLE_TAG_LIST from the tag
    constexpr int expected_tag = ((BOTTLE_TAG_LIST) & (~BOTTLE_TAG_LIST));
    if constexpr (expected_tag != 0) {
        if (_csize != 0 && _etype.code != expected_tag) {
            return false;
        }
    }
    LinearVelocitySensors.resize(_csize);
    for (size_t _i = 0; _i < _csize; ++_i) {
        if (reader.noMore()) {
            reader.fail();
            return false;
        }
        if (!reader.readNested(LinearVelocitySensors[_i])) {
            reader.fail();
            return false;
        }
    }
    reader.readListEnd();
    return true;
}
 
// write (nested) LinearVelocitySensors field
bool SensorRPCData::nested_write_LinearVelocitySensors(const yarp::os::idl::WireWriter& writer) const
{
    if (!writer.writeListBegin(BOTTLE_TAG_LIST, LinearVelocitySensors.size())) {
        return false;
    }
    for (const auto& _item : LinearVelocitySensors) {
        if (!writer.writeNested(_item)) {
            return false;
        }
    }
    if (!writer.writeListEnd()) {
        return false;
    }
    return true;
}
 
// read ThreeAxisAngularAccelerometers field
bool SensorRPCData::read_ThreeAxisAngularAccelerometers(yarp::os::idl::WireReader& reader)
{
    if (reader.noMore()) {
        reader.fail();
        return false;
    }
    size_t _csize;
    yarp::os::idl::WireState _etype;
    reader.readListBegin(_etype, _csize);
    // WireReader removes BOTTLE_TAG_LIST from the tag
    constexpr int expected_tag = ((BOTTLE_TAG_LIST) & (~BOTTLE_TAG_LIST));
    if constexpr (expected_tag != 0) {
        if (_csize != 0 && _etype.code != expected_tag) {
            return false;
        }
    }
    ThreeAxisAngularAccelerometers.resize(_csize);
    for (size_t _i = 0; _i < _csize; ++_i) {
        if (reader.noMore()) {
            reader.fail();
            return false;
        }
        if (!reader.readNested(ThreeAxisAngularAccelerometers[_i])) {
            reader.fail();
            return false;
        }
    }
    reader.readListEnd();
    return true;
}
 
// write ThreeAxisAngularAccelerometers field
bool SensorRPCData::write_ThreeAxisAngularAccelerometers(const yarp::os::idl::WireWriter& writer) const
{
    if (!writer.writeListBegin(BOTTLE_TAG_LIST, ThreeAxisAngularAccelerometers.size())) {
        return false;
    }
    for (const auto& _item : ThreeAxisAngularAccelerometers) {
        if (!writer.writeNested(_item)) {
            return false;
        }
    }
    if (!writer.writeListEnd()) {
        return false;
    }
    return true;
}
 
// read (nested) ThreeAxisAngularAccelerometers field
bool SensorRPCData::nested_read_ThreeAxisAngularAccelerometers(yarp::os::idl::WireReader& reader)
{
    if (reader.noMore()) {
        reader.fail();
        return false;
    }
    size_t _csize;
    yarp::os::idl::WireState _etype;
    reader.readListBegin(_etype, _csize);
    // WireReader removes BOTTLE_TAG_LIST from the tag
    constexpr int expected_tag = ((BOTTLE_TAG_LIST) & (~BOTTLE_TAG_LIST));
    if constexpr (expected_tag != 0) {
        if (_csize != 0 && _etype.code != expected_tag) {
            return false;
        }
    }
    ThreeAxisAngularAccelerometers.resize(_csize);
    for (size_t _i = 0; _i < _csize; ++_i) {
        if (reader.noMore()) {
            reader.fail();
            return false;
        }
        if (!reader.readNested(ThreeAxisAngularAccelerometers[_i])) {
            reader.fail();
            return false;
        }
    }
    reader.readListEnd();
    return true;
}
 
// write (nested) ThreeAxisAngularAccelerometers field
bool SensorRPCData::nested_write_ThreeAxisAngularAccelerometers(const yarp::os::idl::WireWriter& writer) const
{
    if (!writer.writeListBegin(BOTTLE_TAG_LIST, ThreeAxisAngularAccelerometers.size())) {
        return false;
    }
    for (const auto& _item : ThreeAxisAngularAccelerometers) {
        if (!writer.writeNested(_item)) {
            return false;
        }
    }
    if (!writer.writeListEnd()) {
        return false;
    }
    return true;
}