GoalStatusArray.h

Go to the documentation of this file.

/*
 * SPDX-FileCopyrightText: 2006-2021 Istituto Italiano di Tecnologia (IIT)
 * SPDX-License-Identifier: BSD-3-Clause
 */
 
// This is an automatically generated file.
 
// Generated from the following "actionlib_msgs/GoalStatusArray" msg definition:
//   # Stores the statuses for goals that are currently being tracked
//   # by an action server
//   Header header
//   GoalStatus[] status_list
//   
// Instances of this class can be read and written with YARP ports,
// using a ROS-compatible format.
 
#ifndef YARP_ROSMSG_actionlib_msgs_GoalStatusArray_h
#define YARP_ROSMSG_actionlib_msgs_GoalStatusArray_h
 
#include <yarp/os/Wire.h>
#include <yarp/os/Type.h>
#include <yarp/os/idl/WireTypes.h>
#include <string>
#include <vector>
#include <yarp/rosmsg/std_msgs/Header.h>
#include <yarp/rosmsg/actionlib_msgs/GoalStatus.h>
 
namespace yarp {
namespace rosmsg {
namespace actionlib_msgs {
 
class GoalStatusArray : public yarp::os::idl::WirePortable
{
public:
    yarp::rosmsg::std_msgs::Header header;
    std::vector<yarp::rosmsg::actionlib_msgs::GoalStatus> status_list;
 
    GoalStatusArray() :
            header(),
            status_list()
    {
    }
 
    void clear()
    {
        // *** header ***
        header.clear();
 
        // *** status_list ***
        status_list.clear();
    }
 
    bool readBare(yarp::os::ConnectionReader& connection) override
    {
        // *** header ***
        if (!header.read(connection)) {
            return false;
        }
 
        // *** status_list ***
        int len = connection.expectInt32();
        status_list.resize(len);
        for (int i=0; i<len; i++) {
            if (!status_list[i].read(connection)) {
                return false;
            }
        }
 
        return !connection.isError();
    }
 
    bool readBottle(yarp::os::ConnectionReader& connection) override
    {
        connection.convertTextMode();
        yarp::os::idl::WireReader reader(connection);
        if (!reader.readListHeader(2)) {
            return false;
        }
 
        // *** header ***
        if (!header.read(connection)) {
            return false;
        }
 
        // *** status_list ***
        if (connection.expectInt32() != BOTTLE_TAG_LIST) {
            return false;
        }
        int len = connection.expectInt32();
        status_list.resize(len);
        for (int i=0; i<len; i++) {
            if (!status_list[i].read(connection)) {
                return false;
            }
        }
 
        return !connection.isError();
    }
 
    using yarp::os::idl::WirePortable::read;
    bool read(yarp::os::ConnectionReader& connection) override
    {
        return (connection.isBareMode() ? readBare(connection)
                                        : readBottle(connection));
    }
 
    bool writeBare(yarp::os::ConnectionWriter& connection) const override
    {
        // *** header ***
        if (!header.write(connection)) {
            return false;
        }
 
        // *** status_list ***
        connection.appendInt32(status_list.size());
        for (size_t i=0; i<status_list.size(); i++) {
            if (!status_list[i].write(connection)) {
                return false;
            }
        }
 
        return !connection.isError();
    }
 
    bool writeBottle(yarp::os::ConnectionWriter& connection) const override
    {
        connection.appendInt32(BOTTLE_TAG_LIST);
        connection.appendInt32(2);
 
        // *** header ***
        if (!header.write(connection)) {
            return false;
        }
 
        // *** status_list ***
        connection.appendInt32(BOTTLE_TAG_LIST);
        connection.appendInt32(status_list.size());
        for (size_t i=0; i<status_list.size(); i++) {
            if (!status_list[i].write(connection)) {
                return false;
            }
        }
 
        connection.convertTextMode();
        return !connection.isError();
    }
 
    using yarp::os::idl::WirePortable::write;
    bool write(yarp::os::ConnectionWriter& connection) const override
    {
        return (connection.isBareMode() ? writeBare(connection)
                                        : writeBottle(connection));
    }
 
    // This class will serialize ROS style or YARP style depending on protocol.
    // If you need to force a serialization style, use one of these classes:
    typedef yarp::os::idl::BareStyle<yarp::rosmsg::actionlib_msgs::GoalStatusArray> rosStyle;
    typedef yarp::os::idl::BottleStyle<yarp::rosmsg::actionlib_msgs::GoalStatusArray> bottleStyle;
 
    // The name for this message, ROS will need this
    static constexpr const char* typeName = "actionlib_msgs/GoalStatusArray";
 
    // The checksum for this message, ROS will need this
    static constexpr const char* typeChecksum = "8b2b82f13216d0a8ea88bd3af735e619";
 
    // The source text for this message, ROS will need this
    static constexpr const char* typeText = "\
# Stores the statuses for goals that are currently being tracked\n\
# by an action server\n\
Header header\n\
GoalStatus[] status_list\n\
\n\
\n\
================================================================================\n\
MSG: std_msgs/Header\n\
# Standard metadata for higher-level stamped data types.\n\
# This is generally used to communicate timestamped data \n\
# in a particular coordinate frame.\n\
# \n\
# sequence ID: consecutively increasing ID \n\
uint32 seq\n\
#Two-integer timestamp that is expressed as:\n\
# * stamp.sec: seconds (stamp_secs) since epoch (in Python the variable is called 'secs')\n\
# * stamp.nsec: nanoseconds since stamp_secs (in Python the variable is called 'nsecs')\n\
# time-handling sugar is provided by the client library\n\
time stamp\n\
#Frame this data is associated with\n\
# 0: no frame\n\
# 1: global frame\n\
string frame_id\n\
\n\
================================================================================\n\
MSG: actionlib_msgs/GoalStatus\n\
GoalID goal_id\n\
uint8 status\n\
uint8 PENDING         = 0   # The goal has yet to be processed by the action server\n\
uint8 ACTIVE          = 1   # The goal is currently being processed by the action server\n\
uint8 PREEMPTED       = 2   # The goal received a cancel request after it started executing\n\
                            #   and has since completed its execution (Terminal State)\n\
uint8 SUCCEEDED       = 3   # The goal was achieved successfully by the action server (Terminal State)\n\
uint8 ABORTED         = 4   # The goal was aborted during execution by the action server due\n\
                            #    to some failure (Terminal State)\n\
uint8 REJECTED        = 5   # The goal was rejected by the action server without being processed,\n\
                            #    because the goal was unattainable or invalid (Terminal State)\n\
uint8 PREEMPTING      = 6   # The goal received a cancel request after it started executing\n\
                            #    and has not yet completed execution\n\
uint8 RECALLING       = 7   # The goal received a cancel request before it started executing,\n\
                            #    but the action server has not yet confirmed that the goal is canceled\n\
uint8 RECALLED        = 8   # The goal received a cancel request before it started executing\n\
                            #    and was successfully cancelled (Terminal State)\n\
uint8 LOST            = 9   # An action client can determine that a goal is LOST. This should not be\n\
                            #    sent over the wire by an action server\n\
\n\
#Allow for the user to associate a string with GoalStatus for debugging\n\
string text\n\
\n\
\n\
================================================================================\n\
MSG: actionlib_msgs/GoalID\n\
# The stamp should store the time at which this goal was requested.\n\
# It is used by an action server when it tries to preempt all\n\
# goals that were requested before a certain time\n\
time stamp\n\
\n\
# The id provides a way to associate feedback and\n\
# result message with specific goal requests. The id\n\
# specified must be unique.\n\
string id\n\
\n\
";
 
    yarp::os::Type getType() const override
    {
        yarp::os::Type typ = yarp::os::Type::byName(typeName, typeName);
        typ.addProperty("md5sum", yarp::os::Value(typeChecksum));
        typ.addProperty("message_definition", yarp::os::Value(typeText));
        return typ;
    }
};
 
} // namespace actionlib_msgs
} // namespace rosmsg
} // namespace yarp
 
#endif // YARP_ROSMSG_actionlib_msgs_GoalStatusArray_h