SensorStreamingData.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 <SensorStreamingData.h>
 
// Constructor with field values
SensorStreamingData::SensorStreamingData(const SensorMeasurements& ThreeAxisGyroscopes,
                                         const SensorMeasurements& ThreeAxisLinearAccelerometers,
                                         const SensorMeasurements& ThreeAxisMagnetometers,
                                         const SensorMeasurements& OrientationSensors,
                                         const SensorMeasurements& TemperatureSensors,
                                         const SensorMeasurements& SixAxisForceTorqueSensors,
                                         const SensorMeasurements& ContactLoadCellArrays,
                                         const SensorMeasurements& EncoderArrays,
                                         const SensorMeasurements& SkinPatches,
                                         const SensorMeasurements& PositionSensors,
                                         const SensorMeasurements& LinearVelocitySensors,
                                         const SensorMeasurements& 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 SensorStreamingData::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 SensorStreamingData::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 SensorStreamingData::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 SensorStreamingData::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 SensorStreamingData::toString() const
{
    yarp::os::Bottle b;
    if (!yarp::os::Portable::copyPortable(*this, b)) {
        return {};
    }
    return b.toString();
}
 
// read ThreeAxisGyroscopes field
bool SensorStreamingData::read_ThreeAxisGyroscopes(yarp::os::idl::WireReader& reader)
{
    if (reader.noMore()) {
        reader.fail();
        return false;
    }
    if (!reader.read(ThreeAxisGyroscopes)) {
        reader.fail();
        return false;
    }
    return true;
}
 
// write ThreeAxisGyroscopes field
bool SensorStreamingData::write_ThreeAxisGyroscopes(const yarp::os::idl::WireWriter& writer) const
{
    if (!writer.write(ThreeAxisGyroscopes)) {
        return false;
    }
    return true;
}
 
// read (nested) ThreeAxisGyroscopes field
bool SensorStreamingData::nested_read_ThreeAxisGyroscopes(yarp::os::idl::WireReader& reader)
{
    if (reader.noMore()) {
        reader.fail();
        return false;
    }
    if (!reader.readNested(ThreeAxisGyroscopes)) {
        reader.fail();
        return false;
    }
    return true;
}
 
// write (nested) ThreeAxisGyroscopes field
bool SensorStreamingData::nested_write_ThreeAxisGyroscopes(const yarp::os::idl::WireWriter& writer) const
{
    if (!writer.writeNested(ThreeAxisGyroscopes)) {
        return false;
    }
    return true;
}
 
// read ThreeAxisLinearAccelerometers field
bool SensorStreamingData::read_ThreeAxisLinearAccelerometers(yarp::os::idl::WireReader& reader)
{
    if (reader.noMore()) {
        reader.fail();
        return false;
    }
    if (!reader.read(ThreeAxisLinearAccelerometers)) {
        reader.fail();
        return false;
    }
    return true;
}
 
// write ThreeAxisLinearAccelerometers field
bool SensorStreamingData::write_ThreeAxisLinearAccelerometers(const yarp::os::idl::WireWriter& writer) const
{
    if (!writer.write(ThreeAxisLinearAccelerometers)) {
        return false;
    }
    return true;
}
 
// read (nested) ThreeAxisLinearAccelerometers field
bool SensorStreamingData::nested_read_ThreeAxisLinearAccelerometers(yarp::os::idl::WireReader& reader)
{
    if (reader.noMore()) {
        reader.fail();
        return false;
    }
    if (!reader.readNested(ThreeAxisLinearAccelerometers)) {
        reader.fail();
        return false;
    }
    return true;
}
 
// write (nested) ThreeAxisLinearAccelerometers field
bool SensorStreamingData::nested_write_ThreeAxisLinearAccelerometers(const yarp::os::idl::WireWriter& writer) const
{
    if (!writer.writeNested(ThreeAxisLinearAccelerometers)) {
        return false;
    }
    return true;
}
 
// read ThreeAxisMagnetometers field
bool SensorStreamingData::read_ThreeAxisMagnetometers(yarp::os::idl::WireReader& reader)
{
    if (reader.noMore()) {
        reader.fail();
        return false;
    }
    if (!reader.read(ThreeAxisMagnetometers)) {
        reader.fail();
        return false;
    }
    return true;
}
 
// write ThreeAxisMagnetometers field
bool SensorStreamingData::write_ThreeAxisMagnetometers(const yarp::os::idl::WireWriter& writer) const
{
    if (!writer.write(ThreeAxisMagnetometers)) {
        return false;
    }
    return true;
}
 
// read (nested) ThreeAxisMagnetometers field
bool SensorStreamingData::nested_read_ThreeAxisMagnetometers(yarp::os::idl::WireReader& reader)
{
    if (reader.noMore()) {
        reader.fail();
        return false;
    }
    if (!reader.readNested(ThreeAxisMagnetometers)) {
        reader.fail();
        return false;
    }
    return true;
}
 
// write (nested) ThreeAxisMagnetometers field
bool SensorStreamingData::nested_write_ThreeAxisMagnetometers(const yarp::os::idl::WireWriter& writer) const
{
    if (!writer.writeNested(ThreeAxisMagnetometers)) {
        return false;
    }
    return true;
}
 
// read OrientationSensors field
bool SensorStreamingData::read_OrientationSensors(yarp::os::idl::WireReader& reader)
{
    if (reader.noMore()) {
        reader.fail();
        return false;
    }
    if (!reader.read(OrientationSensors)) {
        reader.fail();
        return false;
    }
    return true;
}
 
// write OrientationSensors field
bool SensorStreamingData::write_OrientationSensors(const yarp::os::idl::WireWriter& writer) const
{
    if (!writer.write(OrientationSensors)) {
        return false;
    }
    return true;
}
 
// read (nested) OrientationSensors field
bool SensorStreamingData::nested_read_OrientationSensors(yarp::os::idl::WireReader& reader)
{
    if (reader.noMore()) {
        reader.fail();
        return false;
    }
    if (!reader.readNested(OrientationSensors)) {
        reader.fail();
        return false;
    }
    return true;
}
 
// write (nested) OrientationSensors field
bool SensorStreamingData::nested_write_OrientationSensors(const yarp::os::idl::WireWriter& writer) const
{
    if (!writer.writeNested(OrientationSensors)) {
        return false;
    }
    return true;
}
 
// read TemperatureSensors field
bool SensorStreamingData::read_TemperatureSensors(yarp::os::idl::WireReader& reader)
{
    if (reader.noMore()) {
        reader.fail();
        return false;
    }
    if (!reader.read(TemperatureSensors)) {
        reader.fail();
        return false;
    }
    return true;
}
 
// write TemperatureSensors field
bool SensorStreamingData::write_TemperatureSensors(const yarp::os::idl::WireWriter& writer) const
{
    if (!writer.write(TemperatureSensors)) {
        return false;
    }
    return true;
}
 
// read (nested) TemperatureSensors field
bool SensorStreamingData::nested_read_TemperatureSensors(yarp::os::idl::WireReader& reader)
{
    if (reader.noMore()) {
        reader.fail();
        return false;
    }
    if (!reader.readNested(TemperatureSensors)) {
        reader.fail();
        return false;
    }
    return true;
}
 
// write (nested) TemperatureSensors field
bool SensorStreamingData::nested_write_TemperatureSensors(const yarp::os::idl::WireWriter& writer) const
{
    if (!writer.writeNested(TemperatureSensors)) {
        return false;
    }
    return true;
}
 
// read SixAxisForceTorqueSensors field
bool SensorStreamingData::read_SixAxisForceTorqueSensors(yarp::os::idl::WireReader& reader)
{
    if (reader.noMore()) {
        reader.fail();
        return false;
    }
    if (!reader.read(SixAxisForceTorqueSensors)) {
        reader.fail();
        return false;
    }
    return true;
}
 
// write SixAxisForceTorqueSensors field
bool SensorStreamingData::write_SixAxisForceTorqueSensors(const yarp::os::idl::WireWriter& writer) const
{
    if (!writer.write(SixAxisForceTorqueSensors)) {
        return false;
    }
    return true;
}
 
// read (nested) SixAxisForceTorqueSensors field
bool SensorStreamingData::nested_read_SixAxisForceTorqueSensors(yarp::os::idl::WireReader& reader)
{
    if (reader.noMore()) {
        reader.fail();
        return false;
    }
    if (!reader.readNested(SixAxisForceTorqueSensors)) {
        reader.fail();
        return false;
    }
    return true;
}
 
// write (nested) SixAxisForceTorqueSensors field
bool SensorStreamingData::nested_write_SixAxisForceTorqueSensors(const yarp::os::idl::WireWriter& writer) const
{
    if (!writer.writeNested(SixAxisForceTorqueSensors)) {
        return false;
    }
    return true;
}
 
// read ContactLoadCellArrays field
bool SensorStreamingData::read_ContactLoadCellArrays(yarp::os::idl::WireReader& reader)
{
    if (reader.noMore()) {
        reader.fail();
        return false;
    }
    if (!reader.read(ContactLoadCellArrays)) {
        reader.fail();
        return false;
    }
    return true;
}
 
// write ContactLoadCellArrays field
bool SensorStreamingData::write_ContactLoadCellArrays(const yarp::os::idl::WireWriter& writer) const
{
    if (!writer.write(ContactLoadCellArrays)) {
        return false;
    }
    return true;
}
 
// read (nested) ContactLoadCellArrays field
bool SensorStreamingData::nested_read_ContactLoadCellArrays(yarp::os::idl::WireReader& reader)
{
    if (reader.noMore()) {
        reader.fail();
        return false;
    }
    if (!reader.readNested(ContactLoadCellArrays)) {
        reader.fail();
        return false;
    }
    return true;
}
 
// write (nested) ContactLoadCellArrays field
bool SensorStreamingData::nested_write_ContactLoadCellArrays(const yarp::os::idl::WireWriter& writer) const
{
    if (!writer.writeNested(ContactLoadCellArrays)) {
        return false;
    }
    return true;
}
 
// read EncoderArrays field
bool SensorStreamingData::read_EncoderArrays(yarp::os::idl::WireReader& reader)
{
    if (reader.noMore()) {
        reader.fail();
        return false;
    }
    if (!reader.read(EncoderArrays)) {
        reader.fail();
        return false;
    }
    return true;
}
 
// write EncoderArrays field
bool SensorStreamingData::write_EncoderArrays(const yarp::os::idl::WireWriter& writer) const
{
    if (!writer.write(EncoderArrays)) {
        return false;
    }
    return true;
}
 
// read (nested) EncoderArrays field
bool SensorStreamingData::nested_read_EncoderArrays(yarp::os::idl::WireReader& reader)
{
    if (reader.noMore()) {
        reader.fail();
        return false;
    }
    if (!reader.readNested(EncoderArrays)) {
        reader.fail();
        return false;
    }
    return true;
}
 
// write (nested) EncoderArrays field
bool SensorStreamingData::nested_write_EncoderArrays(const yarp::os::idl::WireWriter& writer) const
{
    if (!writer.writeNested(EncoderArrays)) {
        return false;
    }
    return true;
}
 
// read SkinPatches field
bool SensorStreamingData::read_SkinPatches(yarp::os::idl::WireReader& reader)
{
    if (reader.noMore()) {
        reader.fail();
        return false;
    }
    if (!reader.read(SkinPatches)) {
        reader.fail();
        return false;
    }
    return true;
}
 
// write SkinPatches field
bool SensorStreamingData::write_SkinPatches(const yarp::os::idl::WireWriter& writer) const
{
    if (!writer.write(SkinPatches)) {
        return false;
    }
    return true;
}
 
// read (nested) SkinPatches field
bool SensorStreamingData::nested_read_SkinPatches(yarp::os::idl::WireReader& reader)
{
    if (reader.noMore()) {
        reader.fail();
        return false;
    }
    if (!reader.readNested(SkinPatches)) {
        reader.fail();
        return false;
    }
    return true;
}
 
// write (nested) SkinPatches field
bool SensorStreamingData::nested_write_SkinPatches(const yarp::os::idl::WireWriter& writer) const
{
    if (!writer.writeNested(SkinPatches)) {
        return false;
    }
    return true;
}
 
// read PositionSensors field
bool SensorStreamingData::read_PositionSensors(yarp::os::idl::WireReader& reader)
{
    if (reader.noMore()) {
        reader.fail();
        return false;
    }
    if (!reader.read(PositionSensors)) {
        reader.fail();
        return false;
    }
    return true;
}
 
// write PositionSensors field
bool SensorStreamingData::write_PositionSensors(const yarp::os::idl::WireWriter& writer) const
{
    if (!writer.write(PositionSensors)) {
        return false;
    }
    return true;
}
 
// read (nested) PositionSensors field
bool SensorStreamingData::nested_read_PositionSensors(yarp::os::idl::WireReader& reader)
{
    if (reader.noMore()) {
        reader.fail();
        return false;
    }
    if (!reader.readNested(PositionSensors)) {
        reader.fail();
        return false;
    }
    return true;
}
 
// write (nested) PositionSensors field
bool SensorStreamingData::nested_write_PositionSensors(const yarp::os::idl::WireWriter& writer) const
{
    if (!writer.writeNested(PositionSensors)) {
        return false;
    }
    return true;
}
 
// read LinearVelocitySensors field
bool SensorStreamingData::read_LinearVelocitySensors(yarp::os::idl::WireReader& reader)
{
    if (reader.noMore()) {
        reader.fail();
        return false;
    }
    if (!reader.read(LinearVelocitySensors)) {
        reader.fail();
        return false;
    }
    return true;
}
 
// write LinearVelocitySensors field
bool SensorStreamingData::write_LinearVelocitySensors(const yarp::os::idl::WireWriter& writer) const
{
    if (!writer.write(LinearVelocitySensors)) {
        return false;
    }
    return true;
}
 
// read (nested) LinearVelocitySensors field
bool SensorStreamingData::nested_read_LinearVelocitySensors(yarp::os::idl::WireReader& reader)
{
    if (reader.noMore()) {
        reader.fail();
        return false;
    }
    if (!reader.readNested(LinearVelocitySensors)) {
        reader.fail();
        return false;
    }
    return true;
}
 
// write (nested) LinearVelocitySensors field
bool SensorStreamingData::nested_write_LinearVelocitySensors(const yarp::os::idl::WireWriter& writer) const
{
    if (!writer.writeNested(LinearVelocitySensors)) {
        return false;
    }
    return true;
}
 
// read ThreeAxisAngularAccelerometers field
bool SensorStreamingData::read_ThreeAxisAngularAccelerometers(yarp::os::idl::WireReader& reader)
{
    if (reader.noMore()) {
        reader.fail();
        return false;
    }
    if (!reader.read(ThreeAxisAngularAccelerometers)) {
        reader.fail();
        return false;
    }
    return true;
}
 
// write ThreeAxisAngularAccelerometers field
bool SensorStreamingData::write_ThreeAxisAngularAccelerometers(const yarp::os::idl::WireWriter& writer) const
{
    if (!writer.write(ThreeAxisAngularAccelerometers)) {
        return false;
    }
    return true;
}
 
// read (nested) ThreeAxisAngularAccelerometers field
bool SensorStreamingData::nested_read_ThreeAxisAngularAccelerometers(yarp::os::idl::WireReader& reader)
{
    if (reader.noMore()) {
        reader.fail();
        return false;
    }
    if (!reader.readNested(ThreeAxisAngularAccelerometers)) {
        reader.fail();
        return false;
    }
    return true;
}
 
// write (nested) ThreeAxisAngularAccelerometers field
bool SensorStreamingData::nested_write_ThreeAxisAngularAccelerometers(const yarp::os::idl::WireWriter& writer) const
{
    if (!writer.writeNested(ThreeAxisAngularAccelerometers)) {
        return false;
    }
    return true;
}