yarpActionsPlayer_IDL.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/conf/version.h>
#include <yarpActionsPlayer_IDL.h>
#include <yarp/os/LogComponent.h>
#include <yarp/os/LogStream.h>
 
#include <yarp/os/idl/WireTypes.h>
 
#include <algorithm>
 
namespace
{
    YARP_LOG_COMPONENT(SERVICE_LOG_COMPONENT, "yarpActionsPlayer_IDL")
}
 
//yarpActionsPlayer_IDL_getRemoteProtocolVersion_helper declaration
class yarpActionsPlayer_IDL_getRemoteProtocolVersion_helper :
public yarp::os::Portable
{
public:
    yarpActionsPlayer_IDL_getRemoteProtocolVersion_helper() = default;
    bool write(yarp::os::ConnectionWriter& connection) const override;
    bool read(yarp::os::ConnectionReader& connection) override;
 
    yarp::os::ApplicationNetworkProtocolVersion helper_proto;
};
 
bool yarpActionsPlayer_IDL_getRemoteProtocolVersion_helper::write(yarp::os::ConnectionWriter& connection) const
{
    yarp::os::idl::WireWriter writer(connection);
    if (!writer.writeListHeader(1)) {
        return false;
    }
    if (!writer.writeString("getRemoteProtocolVersion")) {
        return false;
    }
    return true;
}
 
bool yarpActionsPlayer_IDL_getRemoteProtocolVersion_helper ::read(yarp::os::ConnectionReader & connection)
 {
    yarp::os::idl::WireReader reader(connection);
    if (!reader.readListHeader()) {
        reader.fail();
        return false;
    }
 
    if (!helper_proto.read(connection)) {
        reader.fail();
        return false;
    }
    return true;
}
 
//ProtocolVersion, client side
yarp::os::ApplicationNetworkProtocolVersion yarpActionsPlayer_IDL::getRemoteProtocolVersion()
 {
    if(!yarp().canWrite()) {
        yError(" Missing server method yarpActionsPlayer_IDL::getRemoteProtocolVersion");
    }
    yarpActionsPlayer_IDL_getRemoteProtocolVersion_helper helper{};
    bool ok = yarp().write(helper, helper);
    if (ok) {
        return helper.helper_proto;}
    else {
        yarp::os::ApplicationNetworkProtocolVersion failureproto;
        return failureproto;}
}
 
//ProtocolVersion, client side
bool yarpActionsPlayer_IDL::checkProtocolVersion()
 {
        auto locproto = this->getLocalProtocolVersion();
        auto remproto = this->getRemoteProtocolVersion();
        if (remproto.protocol_version != locproto.protocol_version)
        {
            yCError(SERVICE_LOG_COMPONENT) << "Invalid communication protocol.";
            yCError(SERVICE_LOG_COMPONENT) << "Local Protocol Version: " << locproto.toString();
            yCError(SERVICE_LOG_COMPONENT) << "Remote Protocol Version: " << remproto.toString();
            return false;
        }
        return true;
}
 
//ProtocolVersion, server side
yarp::os::ApplicationNetworkProtocolVersion yarpActionsPlayer_IDL::getLocalProtocolVersion()
{
    yarp::os::ApplicationNetworkProtocolVersion myproto;
    //myproto.protocol_version using default value = 0
    //to change this value add the following line to the .thrift file:
    //const i16 protocol_version = <your_number_here>
    myproto.protocol_version = 0;
    myproto.yarp_major = YARP_VERSION_MAJOR;
    myproto.yarp_minor = YARP_VERSION_MINOR;
    myproto.yarp_patch = YARP_VERSION_PATCH;
    return myproto;
}
 
// start helper class declaration
class yarpActionsPlayer_IDL_start_helper :
        public yarp::os::Portable
{
public:
    yarpActionsPlayer_IDL_start_helper() = default;
    bool write(yarp::os::ConnectionWriter& connection) const override;
    bool read(yarp::os::ConnectionReader& connection) override;
 
    class Command :
            public yarp::os::idl::WirePortable
    {
    public:
        Command() = default;
        ~Command() override = default;
 
        bool write(yarp::os::ConnectionWriter& connection) const override;
        bool read(yarp::os::ConnectionReader& connection) override;
 
        bool write(const yarp::os::idl::WireWriter& writer) const override;
        bool writeTag(const yarp::os::idl::WireWriter& writer) const;
        bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
 
        bool read(yarp::os::idl::WireReader& reader) override;
        bool readTag(yarp::os::idl::WireReader& reader);
        bool readArgs(yarp::os::idl::WireReader& reader);
    };
 
    class Reply :
            public yarp::os::idl::WirePortable
    {
    public:
        Reply() = default;
        ~Reply() override = default;
 
        bool write(yarp::os::ConnectionWriter& connection) const override;
        bool read(yarp::os::ConnectionReader& connection) override;
 
        bool write(const yarp::os::idl::WireWriter& writer) const override;
        bool read(yarp::os::idl::WireReader& reader) override;
 
        bool return_helper{false};
    };
 
    using funcptr_t = bool (*)();
    void call(yarpActionsPlayer_IDL* ptr);
 
    Command cmd;
    Reply reply;
 
    static constexpr const char* s_tag{"start"};
    static constexpr size_t s_tag_len{1};
    static constexpr size_t s_cmd_len{1};
    static constexpr size_t s_reply_len{1};
    static constexpr const char* s_prototype{"bool yarpActionsPlayer_IDL::start()"};
    static constexpr const char* s_help{
        "Start (or resumes, if stopped) the currently selected action.\n"
        "It will stop when the last frame is reached.\n"
        "@return true/false on success/failure"
    };
};
 
// stop helper class declaration
class yarpActionsPlayer_IDL_stop_helper :
        public yarp::os::Portable
{
public:
    yarpActionsPlayer_IDL_stop_helper() = default;
    bool write(yarp::os::ConnectionWriter& connection) const override;
    bool read(yarp::os::ConnectionReader& connection) override;
 
    class Command :
            public yarp::os::idl::WirePortable
    {
    public:
        Command() = default;
        ~Command() override = default;
 
        bool write(yarp::os::ConnectionWriter& connection) const override;
        bool read(yarp::os::ConnectionReader& connection) override;
 
        bool write(const yarp::os::idl::WireWriter& writer) const override;
        bool writeTag(const yarp::os::idl::WireWriter& writer) const;
        bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
 
        bool read(yarp::os::idl::WireReader& reader) override;
        bool readTag(yarp::os::idl::WireReader& reader);
        bool readArgs(yarp::os::idl::WireReader& reader);
    };
 
    class Reply :
            public yarp::os::idl::WirePortable
    {
    public:
        Reply() = default;
        ~Reply() override = default;
 
        bool write(yarp::os::ConnectionWriter& connection) const override;
        bool read(yarp::os::ConnectionReader& connection) override;
 
        bool write(const yarp::os::idl::WireWriter& writer) const override;
        bool read(yarp::os::idl::WireReader& reader) override;
 
        bool return_helper{false};
    };
 
    using funcptr_t = bool (*)();
    void call(yarpActionsPlayer_IDL* ptr);
 
    Command cmd;
    Reply reply;
 
    static constexpr const char* s_tag{"stop"};
    static constexpr size_t s_tag_len{1};
    static constexpr size_t s_cmd_len{1};
    static constexpr size_t s_reply_len{1};
    static constexpr const char* s_prototype{"bool yarpActionsPlayer_IDL::stop()"};
    static constexpr const char* s_help{
        "Stops the currently selected (running) action. Can be resumed by start.\n"
        "@return true/false on success/failure"
    };
};
 
// reset helper class declaration
class yarpActionsPlayer_IDL_reset_helper :
        public yarp::os::Portable
{
public:
    yarpActionsPlayer_IDL_reset_helper() = default;
    bool write(yarp::os::ConnectionWriter& connection) const override;
    bool read(yarp::os::ConnectionReader& connection) override;
 
    class Command :
            public yarp::os::idl::WirePortable
    {
    public:
        Command() = default;
        ~Command() override = default;
 
        bool write(yarp::os::ConnectionWriter& connection) const override;
        bool read(yarp::os::ConnectionReader& connection) override;
 
        bool write(const yarp::os::idl::WireWriter& writer) const override;
        bool writeTag(const yarp::os::idl::WireWriter& writer) const;
        bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
 
        bool read(yarp::os::idl::WireReader& reader) override;
        bool readTag(yarp::os::idl::WireReader& reader);
        bool readArgs(yarp::os::idl::WireReader& reader);
    };
 
    class Reply :
            public yarp::os::idl::WirePortable
    {
    public:
        Reply() = default;
        ~Reply() override = default;
 
        bool write(yarp::os::ConnectionWriter& connection) const override;
        bool read(yarp::os::ConnectionReader& connection) override;
 
        bool write(const yarp::os::idl::WireWriter& writer) const override;
        bool read(yarp::os::idl::WireReader& reader) override;
 
        bool return_helper{false};
    };
 
    using funcptr_t = bool (*)();
    void call(yarpActionsPlayer_IDL* ptr);
 
    Command cmd;
    Reply reply;
 
    static constexpr const char* s_tag{"reset"};
    static constexpr size_t s_tag_len{1};
    static constexpr size_t s_cmd_len{1};
    static constexpr size_t s_reply_len{1};
    static constexpr const char* s_prototype{"bool yarpActionsPlayer_IDL::reset()"};
    static constexpr const char* s_help{
        "Rewinds the currently selected action.\n"
        "@return true/false on success/failure"
    };
};
 
// forever helper class declaration
class yarpActionsPlayer_IDL_forever_helper :
        public yarp::os::Portable
{
public:
    yarpActionsPlayer_IDL_forever_helper() = default;
    bool write(yarp::os::ConnectionWriter& connection) const override;
    bool read(yarp::os::ConnectionReader& connection) override;
 
    class Command :
            public yarp::os::idl::WirePortable
    {
    public:
        Command() = default;
        ~Command() override = default;
 
        bool write(yarp::os::ConnectionWriter& connection) const override;
        bool read(yarp::os::ConnectionReader& connection) override;
 
        bool write(const yarp::os::idl::WireWriter& writer) const override;
        bool writeTag(const yarp::os::idl::WireWriter& writer) const;
        bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
 
        bool read(yarp::os::idl::WireReader& reader) override;
        bool readTag(yarp::os::idl::WireReader& reader);
        bool readArgs(yarp::os::idl::WireReader& reader);
    };
 
    class Reply :
            public yarp::os::idl::WirePortable
    {
    public:
        Reply() = default;
        ~Reply() override = default;
 
        bool write(yarp::os::ConnectionWriter& connection) const override;
        bool read(yarp::os::ConnectionReader& connection) override;
 
        bool write(const yarp::os::idl::WireWriter& writer) const override;
        bool read(yarp::os::idl::WireReader& reader) override;
 
        bool return_helper{false};
    };
 
    using funcptr_t = bool (*)();
    void call(yarpActionsPlayer_IDL* ptr);
 
    Command cmd;
    Reply reply;
 
    static constexpr const char* s_tag{"forever"};
    static constexpr size_t s_tag_len{1};
    static constexpr size_t s_cmd_len{1};
    static constexpr size_t s_reply_len{1};
    static constexpr const char* s_prototype{"bool yarpActionsPlayer_IDL::forever()"};
    static constexpr const char* s_help{
        "Similar to play, but it will automatically restart the playback when the last\n"
        "frame is reached.\n"
        "@return true/false on success/failure"
    };
};
 
// print_frames helper class declaration
class yarpActionsPlayer_IDL_print_frames_helper :
        public yarp::os::Portable
{
public:
    yarpActionsPlayer_IDL_print_frames_helper() = default;
    bool write(yarp::os::ConnectionWriter& connection) const override;
    bool read(yarp::os::ConnectionReader& connection) override;
 
    class Command :
            public yarp::os::idl::WirePortable
    {
    public:
        Command() = default;
        ~Command() override = default;
 
        bool write(yarp::os::ConnectionWriter& connection) const override;
        bool read(yarp::os::ConnectionReader& connection) override;
 
        bool write(const yarp::os::idl::WireWriter& writer) const override;
        bool writeTag(const yarp::os::idl::WireWriter& writer) const;
        bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
 
        bool read(yarp::os::idl::WireReader& reader) override;
        bool readTag(yarp::os::idl::WireReader& reader);
        bool readArgs(yarp::os::idl::WireReader& reader);
    };
 
    class Reply :
            public yarp::os::idl::WirePortable
    {
    public:
        Reply() = default;
        ~Reply() override = default;
 
        bool write(yarp::os::ConnectionWriter& connection) const override;
        bool read(yarp::os::ConnectionReader& connection) override;
 
        bool write(const yarp::os::idl::WireWriter& writer) const override;
        bool read(yarp::os::idl::WireReader& reader) override;
 
        bool return_helper{false};
    };
 
    using funcptr_t = bool (*)();
    void call(yarpActionsPlayer_IDL* ptr);
 
    Command cmd;
    Reply reply;
 
    static constexpr const char* s_tag{"print_frames"};
    static constexpr size_t s_tag_len{2};
    static constexpr size_t s_cmd_len{2};
    static constexpr size_t s_reply_len{1};
    static constexpr const char* s_prototype{"bool yarpActionsPlayer_IDL::print_frames()"};
    static constexpr const char* s_help{
        "Prints all the frames of the currently selected action.\n"
        "@return true/false on success/failure"
    };
};
 
// speed_factor helper class declaration
class yarpActionsPlayer_IDL_speed_factor_helper :
        public yarp::os::Portable
{
public:
    yarpActionsPlayer_IDL_speed_factor_helper() = default;
    explicit yarpActionsPlayer_IDL_speed_factor_helper(const double value);
    bool write(yarp::os::ConnectionWriter& connection) const override;
    bool read(yarp::os::ConnectionReader& connection) override;
 
    class Command :
            public yarp::os::idl::WirePortable
    {
    public:
        Command() = default;
        explicit Command(const double value);
 
        ~Command() override = default;
 
        bool write(yarp::os::ConnectionWriter& connection) const override;
        bool read(yarp::os::ConnectionReader& connection) override;
 
        bool write(const yarp::os::idl::WireWriter& writer) const override;
        bool writeTag(const yarp::os::idl::WireWriter& writer) const;
        bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
 
        bool read(yarp::os::idl::WireReader& reader) override;
        bool readTag(yarp::os::idl::WireReader& reader);
        bool readArgs(yarp::os::idl::WireReader& reader);
 
        double value{0.0};
    };
 
    class Reply :
            public yarp::os::idl::WirePortable
    {
    public:
        Reply() = default;
        ~Reply() override = default;
 
        bool write(yarp::os::ConnectionWriter& connection) const override;
        bool read(yarp::os::ConnectionReader& connection) override;
 
        bool write(const yarp::os::idl::WireWriter& writer) const override;
        bool read(yarp::os::idl::WireReader& reader) override;
 
        bool return_helper{false};
    };
 
    using funcptr_t = bool (*)(const double);
    void call(yarpActionsPlayer_IDL* ptr);
 
    Command cmd;
    Reply reply;
 
    static constexpr const char* s_tag{"speed_factor"};
    static constexpr size_t s_tag_len{2};
    static constexpr size_t s_cmd_len{3};
    static constexpr size_t s_reply_len{1};
    static constexpr const char* s_prototype{"bool yarpActionsPlayer_IDL::speed_factor(const double value)"};
    static constexpr const char* s_help{
        "Sets the playback speed factor for the currently selected action (default value: 1.0).\n"
        "@return true/false on success/failure"
    };
};
 
// resample helper class declaration
class yarpActionsPlayer_IDL_resample_helper :
        public yarp::os::Portable
{
public:
    yarpActionsPlayer_IDL_resample_helper() = default;
    explicit yarpActionsPlayer_IDL_resample_helper(const double value);
    bool write(yarp::os::ConnectionWriter& connection) const override;
    bool read(yarp::os::ConnectionReader& connection) override;
 
    class Command :
            public yarp::os::idl::WirePortable
    {
    public:
        Command() = default;
        explicit Command(const double value);
 
        ~Command() override = default;
 
        bool write(yarp::os::ConnectionWriter& connection) const override;
        bool read(yarp::os::ConnectionReader& connection) override;
 
        bool write(const yarp::os::idl::WireWriter& writer) const override;
        bool writeTag(const yarp::os::idl::WireWriter& writer) const;
        bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
 
        bool read(yarp::os::idl::WireReader& reader) override;
        bool readTag(yarp::os::idl::WireReader& reader);
        bool readArgs(yarp::os::idl::WireReader& reader);
 
        double value{0.0};
    };
 
    class Reply :
            public yarp::os::idl::WirePortable
    {
    public:
        Reply() = default;
        ~Reply() override = default;
 
        bool write(yarp::os::ConnectionWriter& connection) const override;
        bool read(yarp::os::ConnectionReader& connection) override;
 
        bool write(const yarp::os::idl::WireWriter& writer) const override;
        bool read(yarp::os::idl::WireReader& reader) override;
 
        bool return_helper{false};
    };
 
    using funcptr_t = bool (*)(const double);
    void call(yarpActionsPlayer_IDL* ptr);
 
    Command cmd;
    Reply reply;
 
    static constexpr const char* s_tag{"resample"};
    static constexpr size_t s_tag_len{1};
    static constexpr size_t s_cmd_len{2};
    static constexpr size_t s_reply_len{1};
    static constexpr const char* s_prototype{"bool yarpActionsPlayer_IDL::resample(const double value)"};
    static constexpr const char* s_help{
        "Resamples the currently selected action (in seconds, recommended value 0.010s).\n"
        "@return true/false on success/failure"
    };
};
 
// choose_action helper class declaration
class yarpActionsPlayer_IDL_choose_action_helper :
        public yarp::os::Portable
{
public:
    yarpActionsPlayer_IDL_choose_action_helper() = default;
    explicit yarpActionsPlayer_IDL_choose_action_helper(const std::string& action_name);
    bool write(yarp::os::ConnectionWriter& connection) const override;
    bool read(yarp::os::ConnectionReader& connection) override;
 
    class Command :
            public yarp::os::idl::WirePortable
    {
    public:
        Command() = default;
        explicit Command(const std::string& action_name);
 
        ~Command() override = default;
 
        bool write(yarp::os::ConnectionWriter& connection) const override;
        bool read(yarp::os::ConnectionReader& connection) override;
 
        bool write(const yarp::os::idl::WireWriter& writer) const override;
        bool writeTag(const yarp::os::idl::WireWriter& writer) const;
        bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
 
        bool read(yarp::os::idl::WireReader& reader) override;
        bool readTag(yarp::os::idl::WireReader& reader);
        bool readArgs(yarp::os::idl::WireReader& reader);
 
        std::string action_name{};
    };
 
    class Reply :
            public yarp::os::idl::WirePortable
    {
    public:
        Reply() = default;
        ~Reply() override = default;
 
        bool write(yarp::os::ConnectionWriter& connection) const override;
        bool read(yarp::os::ConnectionReader& connection) override;
 
        bool write(const yarp::os::idl::WireWriter& writer) const override;
        bool read(yarp::os::idl::WireReader& reader) override;
 
        bool return_helper{false};
    };
 
    using funcptr_t = bool (*)(const std::string&);
    void call(yarpActionsPlayer_IDL* ptr);
 
    Command cmd;
    Reply reply;
 
    static constexpr const char* s_tag{"choose_action"};
    static constexpr size_t s_tag_len{2};
    static constexpr size_t s_cmd_len{3};
    static constexpr size_t s_reply_len{1};
    static constexpr const char* s_prototype{"bool yarpActionsPlayer_IDL::choose_action(const std::string& action_name)"};
    static constexpr const char* s_help{
        "Choose the current action and wait for further commands.\n"
        "@return true/false on success/failure"
    };
};
 
// play_action helper class declaration
class yarpActionsPlayer_IDL_play_action_helper :
        public yarp::os::Portable
{
public:
    yarpActionsPlayer_IDL_play_action_helper() = default;
    explicit yarpActionsPlayer_IDL_play_action_helper(const std::string& action_name);
    bool write(yarp::os::ConnectionWriter& connection) const override;
    bool read(yarp::os::ConnectionReader& connection) override;
 
    class Command :
            public yarp::os::idl::WirePortable
    {
    public:
        Command() = default;
        explicit Command(const std::string& action_name);
 
        ~Command() override = default;
 
        bool write(yarp::os::ConnectionWriter& connection) const override;
        bool read(yarp::os::ConnectionReader& connection) override;
 
        bool write(const yarp::os::idl::WireWriter& writer) const override;
        bool writeTag(const yarp::os::idl::WireWriter& writer) const;
        bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
 
        bool read(yarp::os::idl::WireReader& reader) override;
        bool readTag(yarp::os::idl::WireReader& reader);
        bool readArgs(yarp::os::idl::WireReader& reader);
 
        std::string action_name{};
    };
 
    class Reply :
            public yarp::os::idl::WirePortable
    {
    public:
        Reply() = default;
        ~Reply() override = default;
 
        bool write(yarp::os::ConnectionWriter& connection) const override;
        bool read(yarp::os::ConnectionReader& connection) override;
 
        bool write(const yarp::os::idl::WireWriter& writer) const override;
        bool read(yarp::os::idl::WireReader& reader) override;
 
        bool return_helper{false};
    };
 
    using funcptr_t = bool (*)(const std::string&);
    void call(yarpActionsPlayer_IDL* ptr);
 
    Command cmd;
    Reply reply;
 
    static constexpr const char* s_tag{"play_action"};
    static constexpr size_t s_tag_len{2};
    static constexpr size_t s_cmd_len{3};
    static constexpr size_t s_reply_len{1};
    static constexpr const char* s_prototype{"bool yarpActionsPlayer_IDL::play_action(const std::string& action_name)"};
    static constexpr const char* s_help{
        "Play an action one single time. The call blocks untils the playback is complete.\n"
        "@return true/false on success/failure"
    };
};
 
// show_actions helper class declaration
class yarpActionsPlayer_IDL_show_actions_helper :
        public yarp::os::Portable
{
public:
    yarpActionsPlayer_IDL_show_actions_helper() = default;
    bool write(yarp::os::ConnectionWriter& connection) const override;
    bool read(yarp::os::ConnectionReader& connection) override;
 
    class Command :
            public yarp::os::idl::WirePortable
    {
    public:
        Command() = default;
        ~Command() override = default;
 
        bool write(yarp::os::ConnectionWriter& connection) const override;
        bool read(yarp::os::ConnectionReader& connection) override;
 
        bool write(const yarp::os::idl::WireWriter& writer) const override;
        bool writeTag(const yarp::os::idl::WireWriter& writer) const;
        bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
 
        bool read(yarp::os::idl::WireReader& reader) override;
        bool readTag(yarp::os::idl::WireReader& reader);
        bool readArgs(yarp::os::idl::WireReader& reader);
    };
 
    class Reply :
            public yarp::os::idl::WirePortable
    {
    public:
        Reply() = default;
        ~Reply() override = default;
 
        bool write(yarp::os::ConnectionWriter& connection) const override;
        bool read(yarp::os::ConnectionReader& connection) override;
 
        bool write(const yarp::os::idl::WireWriter& writer) const override;
        bool read(yarp::os::idl::WireReader& reader) override;
 
        bool return_helper{false};
    };
 
    using funcptr_t = bool (*)();
    void call(yarpActionsPlayer_IDL* ptr);
 
    Command cmd;
    Reply reply;
 
    static constexpr const char* s_tag{"show_actions"};
    static constexpr size_t s_tag_len{2};
    static constexpr size_t s_cmd_len{2};
    static constexpr size_t s_reply_len{1};
    static constexpr const char* s_prototype{"bool yarpActionsPlayer_IDL::show_actions()"};
    static constexpr const char* s_help{
        "Prints all the loaded actions.\n"
        "@return true/false on success/failure"
    };
};
 
// set_thread_period helper class declaration
class yarpActionsPlayer_IDL_set_thread_period_helper :
        public yarp::os::Portable
{
public:
    yarpActionsPlayer_IDL_set_thread_period_helper() = default;
    explicit yarpActionsPlayer_IDL_set_thread_period_helper(const double value);
    bool write(yarp::os::ConnectionWriter& connection) const override;
    bool read(yarp::os::ConnectionReader& connection) override;
 
    class Command :
            public yarp::os::idl::WirePortable
    {
    public:
        Command() = default;
        explicit Command(const double value);
 
        ~Command() override = default;
 
        bool write(yarp::os::ConnectionWriter& connection) const override;
        bool read(yarp::os::ConnectionReader& connection) override;
 
        bool write(const yarp::os::idl::WireWriter& writer) const override;
        bool writeTag(const yarp::os::idl::WireWriter& writer) const;
        bool writeArgs(const yarp::os::idl::WireWriter& writer) const;
 
        bool read(yarp::os::idl::WireReader& reader) override;
        bool readTag(yarp::os::idl::WireReader& reader);
        bool readArgs(yarp::os::idl::WireReader& reader);
 
        double value{0.0};
    };
 
    class Reply :
            public yarp::os::idl::WirePortable
    {
    public:
        Reply() = default;
        ~Reply() override = default;
 
        bool write(yarp::os::ConnectionWriter& connection) const override;
        bool read(yarp::os::ConnectionReader& connection) override;
 
        bool write(const yarp::os::idl::WireWriter& writer) const override;
        bool read(yarp::os::idl::WireReader& reader) override;
 
        bool return_helper{false};
    };
 
    using funcptr_t = bool (*)(const double);
    void call(yarpActionsPlayer_IDL* ptr);
 
    Command cmd;
    Reply reply;
 
    static constexpr const char* s_tag{"set_thread_period"};
    static constexpr size_t s_tag_len{3};
    static constexpr size_t s_cmd_len{4};
    static constexpr size_t s_reply_len{1};
    static constexpr const char* s_prototype{"bool yarpActionsPlayer_IDL::set_thread_period(const double value)"};
    static constexpr const char* s_help{
        "Sets the period of the sampling thread (for advanced use only, default value: 0.010s).\n"
        "@return true/false on success/failure"
    };
};
 
// start helper class implementation
bool yarpActionsPlayer_IDL_start_helper::write(yarp::os::ConnectionWriter& connection) const
{
    return cmd.write(connection);
}
 
bool yarpActionsPlayer_IDL_start_helper::read(yarp::os::ConnectionReader& connection)
{
    return reply.read(connection);
}
 
bool yarpActionsPlayer_IDL_start_helper::Command::write(yarp::os::ConnectionWriter& connection) const
{
    yarp::os::idl::WireWriter writer(connection);
    if (!writer.writeListHeader(s_cmd_len)) {
        return false;
    }
    return write(writer);
}
 
bool yarpActionsPlayer_IDL_start_helper::Command::read(yarp::os::ConnectionReader& connection)
{
    yarp::os::idl::WireReader reader(connection);
    if (!reader.readListHeader()) {
        reader.fail();
        return false;
    }
    return read(reader);
}
 
bool yarpActionsPlayer_IDL_start_helper::Command::write(const yarp::os::idl::WireWriter& writer) const
{
    if (!writeTag(writer)) {
        return false;
    }
    if (!writeArgs(writer)) {
        return false;
    }
    return true;
}
 
bool yarpActionsPlayer_IDL_start_helper::Command::writeTag(const yarp::os::idl::WireWriter& writer) const
{
    if (!writer.writeTag(s_tag, 1, s_tag_len)) {
        return false;
    }
    return true;
}
 
bool yarpActionsPlayer_IDL_start_helper::Command::writeArgs(const yarp::os::idl::WireWriter& writer [[maybe_unused]]) const
{
    return true;
}
 
bool yarpActionsPlayer_IDL_start_helper::Command::read(yarp::os::idl::WireReader& reader)
{
    if (!readTag(reader)) {
        return false;
    }
    if (!readArgs(reader)) {
        return false;
    }
    return true;
}
 
bool yarpActionsPlayer_IDL_start_helper::Command::readTag(yarp::os::idl::WireReader& reader)
{
    std::string tag = reader.readTag(s_tag_len);
    if (reader.isError()) {
        return false;
    }
    if (tag != s_tag) {
        reader.fail();
        return false;
    }
    return true;
}
 
bool yarpActionsPlayer_IDL_start_helper::Command::readArgs(yarp::os::idl::WireReader& reader)
{
    if (!reader.noMore()) {
        reader.fail();
        return false;
    }
    return true;
}
 
bool yarpActionsPlayer_IDL_start_helper::Reply::write(yarp::os::ConnectionWriter& connection) const
{
    yarp::os::idl::WireWriter writer(connection);
    return write(writer);
}
 
bool yarpActionsPlayer_IDL_start_helper::Reply::read(yarp::os::ConnectionReader& connection)
{
    yarp::os::idl::WireReader reader(connection);
    return read(reader);
}
 
bool yarpActionsPlayer_IDL_start_helper::Reply::write(const yarp::os::idl::WireWriter& writer) const
{
    if (!writer.isNull()) {
        if (!writer.writeListHeader(s_reply_len)) {
            return false;
        }
        if (!writer.writeBool(return_helper)) {
            return false;
        }
    }
    return true;
}
 
bool yarpActionsPlayer_IDL_start_helper::Reply::read(yarp::os::idl::WireReader& reader)
{
    if (!reader.readListReturn()) {
        return false;
    }
    if (reader.noMore()) {
        reader.fail();
        return false;
    }
    if (!reader.readBool(return_helper)) {
        reader.fail();
        return false;
    }
    return true;
}
 
void yarpActionsPlayer_IDL_start_helper::call(yarpActionsPlayer_IDL* ptr)
{
    reply.return_helper = ptr->start();
}
 
// stop helper class implementation
bool yarpActionsPlayer_IDL_stop_helper::write(yarp::os::ConnectionWriter& connection) const
{
    return cmd.write(connection);
}
 
bool yarpActionsPlayer_IDL_stop_helper::read(yarp::os::ConnectionReader& connection)
{
    return reply.read(connection);
}
 
bool yarpActionsPlayer_IDL_stop_helper::Command::write(yarp::os::ConnectionWriter& connection) const
{
    yarp::os::idl::WireWriter writer(connection);
    if (!writer.writeListHeader(s_cmd_len)) {
        return false;
    }
    return write(writer);
}
 
bool yarpActionsPlayer_IDL_stop_helper::Command::read(yarp::os::ConnectionReader& connection)
{
    yarp::os::idl::WireReader reader(connection);
    if (!reader.readListHeader()) {
        reader.fail();
        return false;
    }
    return read(reader);
}
 
bool yarpActionsPlayer_IDL_stop_helper::Command::write(const yarp::os::idl::WireWriter& writer) const
{
    if (!writeTag(writer)) {
        return false;
    }
    if (!writeArgs(writer)) {
        return false;
    }
    return true;
}
 
bool yarpActionsPlayer_IDL_stop_helper::Command::writeTag(const yarp::os::idl::WireWriter& writer) const
{
    if (!writer.writeTag(s_tag, 1, s_tag_len)) {
        return false;
    }
    return true;
}
 
bool yarpActionsPlayer_IDL_stop_helper::Command::writeArgs(const yarp::os::idl::WireWriter& writer [[maybe_unused]]) const
{
    return true;
}
 
bool yarpActionsPlayer_IDL_stop_helper::Command::read(yarp::os::idl::WireReader& reader)
{
    if (!readTag(reader)) {
        return false;
    }
    if (!readArgs(reader)) {
        return false;
    }
    return true;
}
 
bool yarpActionsPlayer_IDL_stop_helper::Command::readTag(yarp::os::idl::WireReader& reader)
{
    std::string tag = reader.readTag(s_tag_len);
    if (reader.isError()) {
        return false;
    }
    if (tag != s_tag) {
        reader.fail();
        return false;
    }
    return true;
}
 
bool yarpActionsPlayer_IDL_stop_helper::Command::readArgs(yarp::os::idl::WireReader& reader)
{
    if (!reader.noMore()) {
        reader.fail();
        return false;
    }
    return true;
}
 
bool yarpActionsPlayer_IDL_stop_helper::Reply::write(yarp::os::ConnectionWriter& connection) const
{
    yarp::os::idl::WireWriter writer(connection);
    return write(writer);
}
 
bool yarpActionsPlayer_IDL_stop_helper::Reply::read(yarp::os::ConnectionReader& connection)
{
    yarp::os::idl::WireReader reader(connection);
    return read(reader);
}
 
bool yarpActionsPlayer_IDL_stop_helper::Reply::write(const yarp::os::idl::WireWriter& writer) const
{
    if (!writer.isNull()) {
        if (!writer.writeListHeader(s_reply_len)) {
            return false;
        }
        if (!writer.writeBool(return_helper)) {
            return false;
        }
    }
    return true;
}
 
bool yarpActionsPlayer_IDL_stop_helper::Reply::read(yarp::os::idl::WireReader& reader)
{
    if (!reader.readListReturn()) {
        return false;
    }
    if (reader.noMore()) {
        reader.fail();
        return false;
    }
    if (!reader.readBool(return_helper)) {
        reader.fail();
        return false;
    }
    return true;
}
 
void yarpActionsPlayer_IDL_stop_helper::call(yarpActionsPlayer_IDL* ptr)
{
    reply.return_helper = ptr->stop();
}
 
// reset helper class implementation
bool yarpActionsPlayer_IDL_reset_helper::write(yarp::os::ConnectionWriter& connection) const
{
    return cmd.write(connection);
}
 
bool yarpActionsPlayer_IDL_reset_helper::read(yarp::os::ConnectionReader& connection)
{
    return reply.read(connection);
}
 
bool yarpActionsPlayer_IDL_reset_helper::Command::write(yarp::os::ConnectionWriter& connection) const
{
    yarp::os::idl::WireWriter writer(connection);
    if (!writer.writeListHeader(s_cmd_len)) {
        return false;
    }
    return write(writer);
}
 
bool yarpActionsPlayer_IDL_reset_helper::Command::read(yarp::os::ConnectionReader& connection)
{
    yarp::os::idl::WireReader reader(connection);
    if (!reader.readListHeader()) {
        reader.fail();
        return false;
    }
    return read(reader);
}
 
bool yarpActionsPlayer_IDL_reset_helper::Command::write(const yarp::os::idl::WireWriter& writer) const
{
    if (!writeTag(writer)) {
        return false;
    }
    if (!writeArgs(writer)) {
        return false;
    }
    return true;
}
 
bool yarpActionsPlayer_IDL_reset_helper::Command::writeTag(const yarp::os::idl::WireWriter& writer) const
{
    if (!writer.writeTag(s_tag, 1, s_tag_len)) {
        return false;
    }
    return true;
}
 
bool yarpActionsPlayer_IDL_reset_helper::Command::writeArgs(const yarp::os::idl::WireWriter& writer [[maybe_unused]]) const
{
    return true;
}
 
bool yarpActionsPlayer_IDL_reset_helper::Command::read(yarp::os::idl::WireReader& reader)
{
    if (!readTag(reader)) {
        return false;
    }
    if (!readArgs(reader)) {
        return false;
    }
    return true;
}
 
bool yarpActionsPlayer_IDL_reset_helper::Command::readTag(yarp::os::idl::WireReader& reader)
{
    std::string tag = reader.readTag(s_tag_len);
    if (reader.isError()) {
        return false;
    }
    if (tag != s_tag) {
        reader.fail();
        return false;
    }
    return true;
}
 
bool yarpActionsPlayer_IDL_reset_helper::Command::readArgs(yarp::os::idl::WireReader& reader)
{
    if (!reader.noMore()) {
        reader.fail();
        return false;
    }
    return true;
}
 
bool yarpActionsPlayer_IDL_reset_helper::Reply::write(yarp::os::ConnectionWriter& connection) const
{
    yarp::os::idl::WireWriter writer(connection);
    return write(writer);
}
 
bool yarpActionsPlayer_IDL_reset_helper::Reply::read(yarp::os::ConnectionReader& connection)
{
    yarp::os::idl::WireReader reader(connection);
    return read(reader);
}
 
bool yarpActionsPlayer_IDL_reset_helper::Reply::write(const yarp::os::idl::WireWriter& writer) const
{
    if (!writer.isNull()) {
        if (!writer.writeListHeader(s_reply_len)) {
            return false;
        }
        if (!writer.writeBool(return_helper)) {
            return false;
        }
    }
    return true;
}
 
bool yarpActionsPlayer_IDL_reset_helper::Reply::read(yarp::os::idl::WireReader& reader)
{
    if (!reader.readListReturn()) {
        return false;
    }
    if (reader.noMore()) {
        reader.fail();
        return false;
    }
    if (!reader.readBool(return_helper)) {
        reader.fail();
        return false;
    }
    return true;
}
 
void yarpActionsPlayer_IDL_reset_helper::call(yarpActionsPlayer_IDL* ptr)
{
    reply.return_helper = ptr->reset();
}
 
// forever helper class implementation
bool yarpActionsPlayer_IDL_forever_helper::write(yarp::os::ConnectionWriter& connection) const
{
    return cmd.write(connection);
}
 
bool yarpActionsPlayer_IDL_forever_helper::read(yarp::os::ConnectionReader& connection)
{
    return reply.read(connection);
}
 
bool yarpActionsPlayer_IDL_forever_helper::Command::write(yarp::os::ConnectionWriter& connection) const
{
    yarp::os::idl::WireWriter writer(connection);
    if (!writer.writeListHeader(s_cmd_len)) {
        return false;
    }
    return write(writer);
}
 
bool yarpActionsPlayer_IDL_forever_helper::Command::read(yarp::os::ConnectionReader& connection)
{
    yarp::os::idl::WireReader reader(connection);
    if (!reader.readListHeader()) {
        reader.fail();
        return false;
    }
    return read(reader);
}
 
bool yarpActionsPlayer_IDL_forever_helper::Command::write(const yarp::os::idl::WireWriter& writer) const
{
    if (!writeTag(writer)) {
        return false;
    }
    if (!writeArgs(writer)) {
        return false;
    }
    return true;
}
 
bool yarpActionsPlayer_IDL_forever_helper::Command::writeTag(const yarp::os::idl::WireWriter& writer) const
{
    if (!writer.writeTag(s_tag, 1, s_tag_len)) {
        return false;
    }
    return true;
}
 
bool yarpActionsPlayer_IDL_forever_helper::Command::writeArgs(const yarp::os::idl::WireWriter& writer [[maybe_unused]]) const
{
    return true;
}
 
bool yarpActionsPlayer_IDL_forever_helper::Command::read(yarp::os::idl::WireReader& reader)
{
    if (!readTag(reader)) {
        return false;
    }
    if (!readArgs(reader)) {
        return false;
    }
    return true;
}
 
bool yarpActionsPlayer_IDL_forever_helper::Command::readTag(yarp::os::idl::WireReader& reader)
{
    std::string tag = reader.readTag(s_tag_len);
    if (reader.isError()) {
        return false;
    }
    if (tag != s_tag) {
        reader.fail();
        return false;
    }
    return true;
}
 
bool yarpActionsPlayer_IDL_forever_helper::Command::readArgs(yarp::os::idl::WireReader& reader)
{
    if (!reader.noMore()) {
        reader.fail();
        return false;
    }
    return true;
}
 
bool yarpActionsPlayer_IDL_forever_helper::Reply::write(yarp::os::ConnectionWriter& connection) const
{
    yarp::os::idl::WireWriter writer(connection);
    return write(writer);
}
 
bool yarpActionsPlayer_IDL_forever_helper::Reply::read(yarp::os::ConnectionReader& connection)
{
    yarp::os::idl::WireReader reader(connection);
    return read(reader);
}
 
bool yarpActionsPlayer_IDL_forever_helper::Reply::write(const yarp::os::idl::WireWriter& writer) const
{
    if (!writer.isNull()) {
        if (!writer.writeListHeader(s_reply_len)) {
            return false;
        }
        if (!writer.writeBool(return_helper)) {
            return false;
        }
    }
    return true;
}
 
bool yarpActionsPlayer_IDL_forever_helper::Reply::read(yarp::os::idl::WireReader& reader)
{
    if (!reader.readListReturn()) {
        return false;
    }
    if (reader.noMore()) {
        reader.fail();
        return false;
    }
    if (!reader.readBool(return_helper)) {
        reader.fail();
        return false;
    }
    return true;
}
 
void yarpActionsPlayer_IDL_forever_helper::call(yarpActionsPlayer_IDL* ptr)
{
    reply.return_helper = ptr->forever();
}
 
// print_frames helper class implementation
bool yarpActionsPlayer_IDL_print_frames_helper::write(yarp::os::ConnectionWriter& connection) const
{
    return cmd.write(connection);
}
 
bool yarpActionsPlayer_IDL_print_frames_helper::read(yarp::os::ConnectionReader& connection)
{
    return reply.read(connection);
}
 
bool yarpActionsPlayer_IDL_print_frames_helper::Command::write(yarp::os::ConnectionWriter& connection) const
{
    yarp::os::idl::WireWriter writer(connection);
    if (!writer.writeListHeader(s_cmd_len)) {
        return false;
    }
    return write(writer);
}
 
bool yarpActionsPlayer_IDL_print_frames_helper::Command::read(yarp::os::ConnectionReader& connection)
{
    yarp::os::idl::WireReader reader(connection);
    if (!reader.readListHeader()) {
        reader.fail();
        return false;
    }
    return read(reader);
}
 
bool yarpActionsPlayer_IDL_print_frames_helper::Command::write(const yarp::os::idl::WireWriter& writer) const
{
    if (!writeTag(writer)) {
        return false;
    }
    if (!writeArgs(writer)) {
        return false;
    }
    return true;
}
 
bool yarpActionsPlayer_IDL_print_frames_helper::Command::writeTag(const yarp::os::idl::WireWriter& writer) const
{
    if (!writer.writeTag(s_tag, 1, s_tag_len)) {
        return false;
    }
    return true;
}
 
bool yarpActionsPlayer_IDL_print_frames_helper::Command::writeArgs(const yarp::os::idl::WireWriter& writer [[maybe_unused]]) const
{
    return true;
}
 
bool yarpActionsPlayer_IDL_print_frames_helper::Command::read(yarp::os::idl::WireReader& reader)
{
    if (!readTag(reader)) {
        return false;
    }
    if (!readArgs(reader)) {
        return false;
    }
    return true;
}
 
bool yarpActionsPlayer_IDL_print_frames_helper::Command::readTag(yarp::os::idl::WireReader& reader)
{
    std::string tag = reader.readTag(s_tag_len);
    if (reader.isError()) {
        return false;
    }
    if (tag != s_tag) {
        reader.fail();
        return false;
    }
    return true;
}
 
bool yarpActionsPlayer_IDL_print_frames_helper::Command::readArgs(yarp::os::idl::WireReader& reader)
{
    if (!reader.noMore()) {
        reader.fail();
        return false;
    }
    return true;
}
 
bool yarpActionsPlayer_IDL_print_frames_helper::Reply::write(yarp::os::ConnectionWriter& connection) const
{
    yarp::os::idl::WireWriter writer(connection);
    return write(writer);
}
 
bool yarpActionsPlayer_IDL_print_frames_helper::Reply::read(yarp::os::ConnectionReader& connection)
{
    yarp::os::idl::WireReader reader(connection);
    return read(reader);
}
 
bool yarpActionsPlayer_IDL_print_frames_helper::Reply::write(const yarp::os::idl::WireWriter& writer) const
{
    if (!writer.isNull()) {
        if (!writer.writeListHeader(s_reply_len)) {
            return false;
        }
        if (!writer.writeBool(return_helper)) {
            return false;
        }
    }
    return true;
}
 
bool yarpActionsPlayer_IDL_print_frames_helper::Reply::read(yarp::os::idl::WireReader& reader)
{
    if (!reader.readListReturn()) {
        return false;
    }
    if (reader.noMore()) {
        reader.fail();
        return false;
    }
    if (!reader.readBool(return_helper)) {
        reader.fail();
        return false;
    }
    return true;
}
 
void yarpActionsPlayer_IDL_print_frames_helper::call(yarpActionsPlayer_IDL* ptr)
{
    reply.return_helper = ptr->print_frames();
}
 
// speed_factor helper class implementation
yarpActionsPlayer_IDL_speed_factor_helper::yarpActionsPlayer_IDL_speed_factor_helper(const double value) :
        cmd{value}
{
}
 
bool yarpActionsPlayer_IDL_speed_factor_helper::write(yarp::os::ConnectionWriter& connection) const
{
    return cmd.write(connection);
}
 
bool yarpActionsPlayer_IDL_speed_factor_helper::read(yarp::os::ConnectionReader& connection)
{
    return reply.read(connection);
}
 
yarpActionsPlayer_IDL_speed_factor_helper::Command::Command(const double value) :
        value{value}
{
}
 
bool yarpActionsPlayer_IDL_speed_factor_helper::Command::write(yarp::os::ConnectionWriter& connection) const
{
    yarp::os::idl::WireWriter writer(connection);
    if (!writer.writeListHeader(s_cmd_len)) {
        return false;
    }
    return write(writer);
}
 
bool yarpActionsPlayer_IDL_speed_factor_helper::Command::read(yarp::os::ConnectionReader& connection)
{
    yarp::os::idl::WireReader reader(connection);
    if (!reader.readListHeader()) {
        reader.fail();
        return false;
    }
    return read(reader);
}
 
bool yarpActionsPlayer_IDL_speed_factor_helper::Command::write(const yarp::os::idl::WireWriter& writer) const
{
    if (!writeTag(writer)) {
        return false;
    }
    if (!writeArgs(writer)) {
        return false;
    }
    return true;
}
 
bool yarpActionsPlayer_IDL_speed_factor_helper::Command::writeTag(const yarp::os::idl::WireWriter& writer) const
{
    if (!writer.writeTag(s_tag, 1, s_tag_len)) {
        return false;
    }
    return true;
}
 
bool yarpActionsPlayer_IDL_speed_factor_helper::Command::writeArgs(const yarp::os::idl::WireWriter& writer) const
{
    if (!writer.writeFloat64(value)) {
        return false;
    }
    return true;
}
 
bool yarpActionsPlayer_IDL_speed_factor_helper::Command::read(yarp::os::idl::WireReader& reader)
{
    if (!readTag(reader)) {
        return false;
    }
    if (!readArgs(reader)) {
        return false;
    }
    return true;
}
 
bool yarpActionsPlayer_IDL_speed_factor_helper::Command::readTag(yarp::os::idl::WireReader& reader)
{
    std::string tag = reader.readTag(s_tag_len);
    if (reader.isError()) {
        return false;
    }
    if (tag != s_tag) {
        reader.fail();
        return false;
    }
    return true;
}
 
bool yarpActionsPlayer_IDL_speed_factor_helper::Command::readArgs(yarp::os::idl::WireReader& reader)
{
    if (reader.noMore()) {
        reader.fail();
        return false;
    }
    if (!reader.readFloat64(value)) {
        reader.fail();
        return false;
    }
    if (!reader.noMore()) {
        reader.fail();
        return false;
    }
    return true;
}
 
bool yarpActionsPlayer_IDL_speed_factor_helper::Reply::write(yarp::os::ConnectionWriter& connection) const
{
    yarp::os::idl::WireWriter writer(connection);
    return write(writer);
}
 
bool yarpActionsPlayer_IDL_speed_factor_helper::Reply::read(yarp::os::ConnectionReader& connection)
{
    yarp::os::idl::WireReader reader(connection);
    return read(reader);
}
 
bool yarpActionsPlayer_IDL_speed_factor_helper::Reply::write(const yarp::os::idl::WireWriter& writer) const
{
    if (!writer.isNull()) {
        if (!writer.writeListHeader(s_reply_len)) {
            return false;
        }
        if (!writer.writeBool(return_helper)) {
            return false;
        }
    }
    return true;
}
 
bool yarpActionsPlayer_IDL_speed_factor_helper::Reply::read(yarp::os::idl::WireReader& reader)
{
    if (!reader.readListReturn()) {
        return false;
    }
    if (reader.noMore()) {
        reader.fail();
        return false;
    }
    if (!reader.readBool(return_helper)) {
        reader.fail();
        return false;
    }
    return true;
}
 
void yarpActionsPlayer_IDL_speed_factor_helper::call(yarpActionsPlayer_IDL* ptr)
{
    reply.return_helper = ptr->speed_factor(cmd.value);
}
 
// resample helper class implementation
yarpActionsPlayer_IDL_resample_helper::yarpActionsPlayer_IDL_resample_helper(const double value) :
        cmd{value}
{
}
 
bool yarpActionsPlayer_IDL_resample_helper::write(yarp::os::ConnectionWriter& connection) const
{
    return cmd.write(connection);
}
 
bool yarpActionsPlayer_IDL_resample_helper::read(yarp::os::ConnectionReader& connection)
{
    return reply.read(connection);
}
 
yarpActionsPlayer_IDL_resample_helper::Command::Command(const double value) :
        value{value}
{
}
 
bool yarpActionsPlayer_IDL_resample_helper::Command::write(yarp::os::ConnectionWriter& connection) const
{
    yarp::os::idl::WireWriter writer(connection);
    if (!writer.writeListHeader(s_cmd_len)) {
        return false;
    }
    return write(writer);
}
 
bool yarpActionsPlayer_IDL_resample_helper::Command::read(yarp::os::ConnectionReader& connection)
{
    yarp::os::idl::WireReader reader(connection);
    if (!reader.readListHeader()) {
        reader.fail();
        return false;
    }
    return read(reader);
}
 
bool yarpActionsPlayer_IDL_resample_helper::Command::write(const yarp::os::idl::WireWriter& writer) const
{
    if (!writeTag(writer)) {
        return false;
    }
    if (!writeArgs(writer)) {
        return false;
    }
    return true;
}
 
bool yarpActionsPlayer_IDL_resample_helper::Command::writeTag(const yarp::os::idl::WireWriter& writer) const
{
    if (!writer.writeTag(s_tag, 1, s_tag_len)) {
        return false;
    }
    return true;
}
 
bool yarpActionsPlayer_IDL_resample_helper::Command::writeArgs(const yarp::os::idl::WireWriter& writer) const
{
    if (!writer.writeFloat64(value)) {
        return false;
    }
    return true;
}
 
bool yarpActionsPlayer_IDL_resample_helper::Command::read(yarp::os::idl::WireReader& reader)
{
    if (!readTag(reader)) {
        return false;
    }
    if (!readArgs(reader)) {
        return false;
    }
    return true;
}
 
bool yarpActionsPlayer_IDL_resample_helper::Command::readTag(yarp::os::idl::WireReader& reader)
{
    std::string tag = reader.readTag(s_tag_len);
    if (reader.isError()) {
        return false;
    }
    if (tag != s_tag) {
        reader.fail();
        return false;
    }
    return true;
}
 
bool yarpActionsPlayer_IDL_resample_helper::Command::readArgs(yarp::os::idl::WireReader& reader)
{
    if (reader.noMore()) {
        reader.fail();
        return false;
    }
    if (!reader.readFloat64(value)) {
        reader.fail();
        return false;
    }
    if (!reader.noMore()) {
        reader.fail();
        return false;
    }
    return true;
}
 
bool yarpActionsPlayer_IDL_resample_helper::Reply::write(yarp::os::ConnectionWriter& connection) const
{
    yarp::os::idl::WireWriter writer(connection);
    return write(writer);
}
 
bool yarpActionsPlayer_IDL_resample_helper::Reply::read(yarp::os::ConnectionReader& connection)
{
    yarp::os::idl::WireReader reader(connection);
    return read(reader);
}
 
bool yarpActionsPlayer_IDL_resample_helper::Reply::write(const yarp::os::idl::WireWriter& writer) const
{
    if (!writer.isNull()) {
        if (!writer.writeListHeader(s_reply_len)) {
            return false;
        }
        if (!writer.writeBool(return_helper)) {
            return false;
        }
    }
    return true;
}
 
bool yarpActionsPlayer_IDL_resample_helper::Reply::read(yarp::os::idl::WireReader& reader)
{
    if (!reader.readListReturn()) {
        return false;
    }
    if (reader.noMore()) {
        reader.fail();
        return false;
    }
    if (!reader.readBool(return_helper)) {
        reader.fail();
        return false;
    }
    return true;
}
 
void yarpActionsPlayer_IDL_resample_helper::call(yarpActionsPlayer_IDL* ptr)
{
    reply.return_helper = ptr->resample(cmd.value);
}
 
// choose_action helper class implementation
yarpActionsPlayer_IDL_choose_action_helper::yarpActionsPlayer_IDL_choose_action_helper(const std::string& action_name) :
        cmd{action_name}
{
}
 
bool yarpActionsPlayer_IDL_choose_action_helper::write(yarp::os::ConnectionWriter& connection) const
{
    return cmd.write(connection);
}
 
bool yarpActionsPlayer_IDL_choose_action_helper::read(yarp::os::ConnectionReader& connection)
{
    return reply.read(connection);
}
 
yarpActionsPlayer_IDL_choose_action_helper::Command::Command(const std::string& action_name) :
        action_name{action_name}
{
}
 
bool yarpActionsPlayer_IDL_choose_action_helper::Command::write(yarp::os::ConnectionWriter& connection) const
{
    yarp::os::idl::WireWriter writer(connection);
    if (!writer.writeListHeader(s_cmd_len)) {
        return false;
    }
    return write(writer);
}
 
bool yarpActionsPlayer_IDL_choose_action_helper::Command::read(yarp::os::ConnectionReader& connection)
{
    yarp::os::idl::WireReader reader(connection);
    if (!reader.readListHeader()) {
        reader.fail();
        return false;
    }
    return read(reader);
}
 
bool yarpActionsPlayer_IDL_choose_action_helper::Command::write(const yarp::os::idl::WireWriter& writer) const
{
    if (!writeTag(writer)) {
        return false;
    }
    if (!writeArgs(writer)) {
        return false;
    }
    return true;
}
 
bool yarpActionsPlayer_IDL_choose_action_helper::Command::writeTag(const yarp::os::idl::WireWriter& writer) const
{
    if (!writer.writeTag(s_tag, 1, s_tag_len)) {
        return false;
    }
    return true;
}
 
bool yarpActionsPlayer_IDL_choose_action_helper::Command::writeArgs(const yarp::os::idl::WireWriter& writer) const
{
    if (!writer.writeString(action_name)) {
        return false;
    }
    return true;
}
 
bool yarpActionsPlayer_IDL_choose_action_helper::Command::read(yarp::os::idl::WireReader& reader)
{
    if (!readTag(reader)) {
        return false;
    }
    if (!readArgs(reader)) {
        return false;
    }
    return true;
}
 
bool yarpActionsPlayer_IDL_choose_action_helper::Command::readTag(yarp::os::idl::WireReader& reader)
{
    std::string tag = reader.readTag(s_tag_len);
    if (reader.isError()) {
        return false;
    }
    if (tag != s_tag) {
        reader.fail();
        return false;
    }
    return true;
}
 
bool yarpActionsPlayer_IDL_choose_action_helper::Command::readArgs(yarp::os::idl::WireReader& reader)
{
    if (reader.noMore()) {
        reader.fail();
        return false;
    }
    if (!reader.readString(action_name)) {
        reader.fail();
        return false;
    }
    if (!reader.noMore()) {
        reader.fail();
        return false;
    }
    return true;
}
 
bool yarpActionsPlayer_IDL_choose_action_helper::Reply::write(yarp::os::ConnectionWriter& connection) const
{
    yarp::os::idl::WireWriter writer(connection);
    return write(writer);
}
 
bool yarpActionsPlayer_IDL_choose_action_helper::Reply::read(yarp::os::ConnectionReader& connection)
{
    yarp::os::idl::WireReader reader(connection);
    return read(reader);
}
 
bool yarpActionsPlayer_IDL_choose_action_helper::Reply::write(const yarp::os::idl::WireWriter& writer) const
{
    if (!writer.isNull()) {
        if (!writer.writeListHeader(s_reply_len)) {
            return false;
        }
        if (!writer.writeBool(return_helper)) {
            return false;
        }
    }
    return true;
}
 
bool yarpActionsPlayer_IDL_choose_action_helper::Reply::read(yarp::os::idl::WireReader& reader)
{
    if (!reader.readListReturn()) {
        return false;
    }
    if (reader.noMore()) {
        reader.fail();
        return false;
    }
    if (!reader.readBool(return_helper)) {
        reader.fail();
        return false;
    }
    return true;
}
 
void yarpActionsPlayer_IDL_choose_action_helper::call(yarpActionsPlayer_IDL* ptr)
{
    reply.return_helper = ptr->choose_action(cmd.action_name);
}
 
// play_action helper class implementation
yarpActionsPlayer_IDL_play_action_helper::yarpActionsPlayer_IDL_play_action_helper(const std::string& action_name) :
        cmd{action_name}
{
}
 
bool yarpActionsPlayer_IDL_play_action_helper::write(yarp::os::ConnectionWriter& connection) const
{
    return cmd.write(connection);
}
 
bool yarpActionsPlayer_IDL_play_action_helper::read(yarp::os::ConnectionReader& connection)
{
    return reply.read(connection);
}
 
yarpActionsPlayer_IDL_play_action_helper::Command::Command(const std::string& action_name) :
        action_name{action_name}
{
}
 
bool yarpActionsPlayer_IDL_play_action_helper::Command::write(yarp::os::ConnectionWriter& connection) const
{
    yarp::os::idl::WireWriter writer(connection);
    if (!writer.writeListHeader(s_cmd_len)) {
        return false;
    }
    return write(writer);
}
 
bool yarpActionsPlayer_IDL_play_action_helper::Command::read(yarp::os::ConnectionReader& connection)
{
    yarp::os::idl::WireReader reader(connection);
    if (!reader.readListHeader()) {
        reader.fail();
        return false;
    }
    return read(reader);
}
 
bool yarpActionsPlayer_IDL_play_action_helper::Command::write(const yarp::os::idl::WireWriter& writer) const
{
    if (!writeTag(writer)) {
        return false;
    }
    if (!writeArgs(writer)) {
        return false;
    }
    return true;
}
 
bool yarpActionsPlayer_IDL_play_action_helper::Command::writeTag(const yarp::os::idl::WireWriter& writer) const
{
    if (!writer.writeTag(s_tag, 1, s_tag_len)) {
        return false;
    }
    return true;
}
 
bool yarpActionsPlayer_IDL_play_action_helper::Command::writeArgs(const yarp::os::idl::WireWriter& writer) const
{
    if (!writer.writeString(action_name)) {
        return false;
    }
    return true;
}
 
bool yarpActionsPlayer_IDL_play_action_helper::Command::read(yarp::os::idl::WireReader& reader)
{
    if (!readTag(reader)) {
        return false;
    }
    if (!readArgs(reader)) {
        return false;
    }
    return true;
}
 
bool yarpActionsPlayer_IDL_play_action_helper::Command::readTag(yarp::os::idl::WireReader& reader)
{
    std::string tag = reader.readTag(s_tag_len);
    if (reader.isError()) {
        return false;
    }
    if (tag != s_tag) {
        reader.fail();
        return false;
    }
    return true;
}
 
bool yarpActionsPlayer_IDL_play_action_helper::Command::readArgs(yarp::os::idl::WireReader& reader)
{
    if (reader.noMore()) {
        reader.fail();
        return false;
    }
    if (!reader.readString(action_name)) {
        reader.fail();
        return false;
    }
    if (!reader.noMore()) {
        reader.fail();
        return false;
    }
    return true;
}
 
bool yarpActionsPlayer_IDL_play_action_helper::Reply::write(yarp::os::ConnectionWriter& connection) const
{
    yarp::os::idl::WireWriter writer(connection);
    return write(writer);
}
 
bool yarpActionsPlayer_IDL_play_action_helper::Reply::read(yarp::os::ConnectionReader& connection)
{
    yarp::os::idl::WireReader reader(connection);
    return read(reader);
}
 
bool yarpActionsPlayer_IDL_play_action_helper::Reply::write(const yarp::os::idl::WireWriter& writer) const
{
    if (!writer.isNull()) {
        if (!writer.writeListHeader(s_reply_len)) {
            return false;
        }
        if (!writer.writeBool(return_helper)) {
            return false;
        }
    }
    return true;
}
 
bool yarpActionsPlayer_IDL_play_action_helper::Reply::read(yarp::os::idl::WireReader& reader)
{
    if (!reader.readListReturn()) {
        return false;
    }
    if (reader.noMore()) {
        reader.fail();
        return false;
    }
    if (!reader.readBool(return_helper)) {
        reader.fail();
        return false;
    }
    return true;
}
 
void yarpActionsPlayer_IDL_play_action_helper::call(yarpActionsPlayer_IDL* ptr)
{
    reply.return_helper = ptr->play_action(cmd.action_name);
}
 
// show_actions helper class implementation
bool yarpActionsPlayer_IDL_show_actions_helper::write(yarp::os::ConnectionWriter& connection) const
{
    return cmd.write(connection);
}
 
bool yarpActionsPlayer_IDL_show_actions_helper::read(yarp::os::ConnectionReader& connection)
{
    return reply.read(connection);
}
 
bool yarpActionsPlayer_IDL_show_actions_helper::Command::write(yarp::os::ConnectionWriter& connection) const
{
    yarp::os::idl::WireWriter writer(connection);
    if (!writer.writeListHeader(s_cmd_len)) {
        return false;
    }
    return write(writer);
}
 
bool yarpActionsPlayer_IDL_show_actions_helper::Command::read(yarp::os::ConnectionReader& connection)
{
    yarp::os::idl::WireReader reader(connection);
    if (!reader.readListHeader()) {
        reader.fail();
        return false;
    }
    return read(reader);
}
 
bool yarpActionsPlayer_IDL_show_actions_helper::Command::write(const yarp::os::idl::WireWriter& writer) const
{
    if (!writeTag(writer)) {
        return false;
    }
    if (!writeArgs(writer)) {
        return false;
    }
    return true;
}
 
bool yarpActionsPlayer_IDL_show_actions_helper::Command::writeTag(const yarp::os::idl::WireWriter& writer) const
{
    if (!writer.writeTag(s_tag, 1, s_tag_len)) {
        return false;
    }
    return true;
}
 
bool yarpActionsPlayer_IDL_show_actions_helper::Command::writeArgs(const yarp::os::idl::WireWriter& writer [[maybe_unused]]) const
{
    return true;
}
 
bool yarpActionsPlayer_IDL_show_actions_helper::Command::read(yarp::os::idl::WireReader& reader)
{
    if (!readTag(reader)) {
        return false;
    }
    if (!readArgs(reader)) {
        return false;
    }
    return true;
}
 
bool yarpActionsPlayer_IDL_show_actions_helper::Command::readTag(yarp::os::idl::WireReader& reader)
{
    std::string tag = reader.readTag(s_tag_len);
    if (reader.isError()) {
        return false;
    }
    if (tag != s_tag) {
        reader.fail();
        return false;
    }
    return true;
}
 
bool yarpActionsPlayer_IDL_show_actions_helper::Command::readArgs(yarp::os::idl::WireReader& reader)
{
    if (!reader.noMore()) {
        reader.fail();
        return false;
    }
    return true;
}
 
bool yarpActionsPlayer_IDL_show_actions_helper::Reply::write(yarp::os::ConnectionWriter& connection) const
{
    yarp::os::idl::WireWriter writer(connection);
    return write(writer);
}
 
bool yarpActionsPlayer_IDL_show_actions_helper::Reply::read(yarp::os::ConnectionReader& connection)
{
    yarp::os::idl::WireReader reader(connection);
    return read(reader);
}
 
bool yarpActionsPlayer_IDL_show_actions_helper::Reply::write(const yarp::os::idl::WireWriter& writer) const
{
    if (!writer.isNull()) {
        if (!writer.writeListHeader(s_reply_len)) {
            return false;
        }
        if (!writer.writeBool(return_helper)) {
            return false;
        }
    }
    return true;
}
 
bool yarpActionsPlayer_IDL_show_actions_helper::Reply::read(yarp::os::idl::WireReader& reader)
{
    if (!reader.readListReturn()) {
        return false;
    }
    if (reader.noMore()) {
        reader.fail();
        return false;
    }
    if (!reader.readBool(return_helper)) {
        reader.fail();
        return false;
    }
    return true;
}
 
void yarpActionsPlayer_IDL_show_actions_helper::call(yarpActionsPlayer_IDL* ptr)
{
    reply.return_helper = ptr->show_actions();
}
 
// set_thread_period helper class implementation
yarpActionsPlayer_IDL_set_thread_period_helper::yarpActionsPlayer_IDL_set_thread_period_helper(const double value) :
        cmd{value}
{
}
 
bool yarpActionsPlayer_IDL_set_thread_period_helper::write(yarp::os::ConnectionWriter& connection) const
{
    return cmd.write(connection);
}
 
bool yarpActionsPlayer_IDL_set_thread_period_helper::read(yarp::os::ConnectionReader& connection)
{
    return reply.read(connection);
}
 
yarpActionsPlayer_IDL_set_thread_period_helper::Command::Command(const double value) :
        value{value}
{
}
 
bool yarpActionsPlayer_IDL_set_thread_period_helper::Command::write(yarp::os::ConnectionWriter& connection) const
{
    yarp::os::idl::WireWriter writer(connection);
    if (!writer.writeListHeader(s_cmd_len)) {
        return false;
    }
    return write(writer);
}
 
bool yarpActionsPlayer_IDL_set_thread_period_helper::Command::read(yarp::os::ConnectionReader& connection)
{
    yarp::os::idl::WireReader reader(connection);
    if (!reader.readListHeader()) {
        reader.fail();
        return false;
    }
    return read(reader);
}
 
bool yarpActionsPlayer_IDL_set_thread_period_helper::Command::write(const yarp::os::idl::WireWriter& writer) const
{
    if (!writeTag(writer)) {
        return false;
    }
    if (!writeArgs(writer)) {
        return false;
    }
    return true;
}
 
bool yarpActionsPlayer_IDL_set_thread_period_helper::Command::writeTag(const yarp::os::idl::WireWriter& writer) const
{
    if (!writer.writeTag(s_tag, 1, s_tag_len)) {
        return false;
    }
    return true;
}
 
bool yarpActionsPlayer_IDL_set_thread_period_helper::Command::writeArgs(const yarp::os::idl::WireWriter& writer) const
{
    if (!writer.writeFloat64(value)) {
        return false;
    }
    return true;
}
 
bool yarpActionsPlayer_IDL_set_thread_period_helper::Command::read(yarp::os::idl::WireReader& reader)
{
    if (!readTag(reader)) {
        return false;
    }
    if (!readArgs(reader)) {
        return false;
    }
    return true;
}
 
bool yarpActionsPlayer_IDL_set_thread_period_helper::Command::readTag(yarp::os::idl::WireReader& reader)
{
    std::string tag = reader.readTag(s_tag_len);
    if (reader.isError()) {
        return false;
    }
    if (tag != s_tag) {
        reader.fail();
        return false;
    }
    return true;
}
 
bool yarpActionsPlayer_IDL_set_thread_period_helper::Command::readArgs(yarp::os::idl::WireReader& reader)
{
    if (reader.noMore()) {
        reader.fail();
        return false;
    }
    if (!reader.readFloat64(value)) {
        reader.fail();
        return false;
    }
    if (!reader.noMore()) {
        reader.fail();
        return false;
    }
    return true;
}
 
bool yarpActionsPlayer_IDL_set_thread_period_helper::Reply::write(yarp::os::ConnectionWriter& connection) const
{
    yarp::os::idl::WireWriter writer(connection);
    return write(writer);
}
 
bool yarpActionsPlayer_IDL_set_thread_period_helper::Reply::read(yarp::os::ConnectionReader& connection)
{
    yarp::os::idl::WireReader reader(connection);
    return read(reader);
}
 
bool yarpActionsPlayer_IDL_set_thread_period_helper::Reply::write(const yarp::os::idl::WireWriter& writer) const
{
    if (!writer.isNull()) {
        if (!writer.writeListHeader(s_reply_len)) {
            return false;
        }
        if (!writer.writeBool(return_helper)) {
            return false;
        }
    }
    return true;
}
 
bool yarpActionsPlayer_IDL_set_thread_period_helper::Reply::read(yarp::os::idl::WireReader& reader)
{
    if (!reader.readListReturn()) {
        return false;
    }
    if (reader.noMore()) {
        reader.fail();
        return false;
    }
    if (!reader.readBool(return_helper)) {
        reader.fail();
        return false;
    }
    return true;
}
 
void yarpActionsPlayer_IDL_set_thread_period_helper::call(yarpActionsPlayer_IDL* ptr)
{
    reply.return_helper = ptr->set_thread_period(cmd.value);
}
 
// Constructor
yarpActionsPlayer_IDL::yarpActionsPlayer_IDL()
{
    yarp().setOwner(*this);
}
 
bool yarpActionsPlayer_IDL::start()
{
    if (!yarp().canWrite()) {
        yError("Missing server method '%s'?", yarpActionsPlayer_IDL_start_helper::s_prototype);
    }
    yarpActionsPlayer_IDL_start_helper helper{};
    bool ok = yarp().write(helper, helper);
    return ok ? helper.reply.return_helper : bool{};
}
 
bool yarpActionsPlayer_IDL::stop()
{
    if (!yarp().canWrite()) {
        yError("Missing server method '%s'?", yarpActionsPlayer_IDL_stop_helper::s_prototype);
    }
    yarpActionsPlayer_IDL_stop_helper helper{};
    bool ok = yarp().write(helper, helper);
    return ok ? helper.reply.return_helper : bool{};
}
 
bool yarpActionsPlayer_IDL::reset()
{
    if (!yarp().canWrite()) {
        yError("Missing server method '%s'?", yarpActionsPlayer_IDL_reset_helper::s_prototype);
    }
    yarpActionsPlayer_IDL_reset_helper helper{};
    bool ok = yarp().write(helper, helper);
    return ok ? helper.reply.return_helper : bool{};
}
 
bool yarpActionsPlayer_IDL::forever()
{
    if (!yarp().canWrite()) {
        yError("Missing server method '%s'?", yarpActionsPlayer_IDL_forever_helper::s_prototype);
    }
    yarpActionsPlayer_IDL_forever_helper helper{};
    bool ok = yarp().write(helper, helper);
    return ok ? helper.reply.return_helper : bool{};
}
 
bool yarpActionsPlayer_IDL::print_frames()
{
    if (!yarp().canWrite()) {
        yError("Missing server method '%s'?", yarpActionsPlayer_IDL_print_frames_helper::s_prototype);
    }
    yarpActionsPlayer_IDL_print_frames_helper helper{};
    bool ok = yarp().write(helper, helper);
    return ok ? helper.reply.return_helper : bool{};
}
 
bool yarpActionsPlayer_IDL::speed_factor(const double value)
{
    if (!yarp().canWrite()) {
        yError("Missing server method '%s'?", yarpActionsPlayer_IDL_speed_factor_helper::s_prototype);
    }
    yarpActionsPlayer_IDL_speed_factor_helper helper{value};
    bool ok = yarp().write(helper, helper);
    return ok ? helper.reply.return_helper : bool{};
}
 
bool yarpActionsPlayer_IDL::resample(const double value)
{
    if (!yarp().canWrite()) {
        yError("Missing server method '%s'?", yarpActionsPlayer_IDL_resample_helper::s_prototype);
    }
    yarpActionsPlayer_IDL_resample_helper helper{value};
    bool ok = yarp().write(helper, helper);
    return ok ? helper.reply.return_helper : bool{};
}
 
bool yarpActionsPlayer_IDL::choose_action(const std::string& action_name)
{
    if (!yarp().canWrite()) {
        yError("Missing server method '%s'?", yarpActionsPlayer_IDL_choose_action_helper::s_prototype);
    }
    yarpActionsPlayer_IDL_choose_action_helper helper{action_name};
    bool ok = yarp().write(helper, helper);
    return ok ? helper.reply.return_helper : bool{};
}
 
bool yarpActionsPlayer_IDL::play_action(const std::string& action_name)
{
    if (!yarp().canWrite()) {
        yError("Missing server method '%s'?", yarpActionsPlayer_IDL_play_action_helper::s_prototype);
    }
    yarpActionsPlayer_IDL_play_action_helper helper{action_name};
    bool ok = yarp().write(helper, helper);
    return ok ? helper.reply.return_helper : bool{};
}
 
bool yarpActionsPlayer_IDL::show_actions()
{
    if (!yarp().canWrite()) {
        yError("Missing server method '%s'?", yarpActionsPlayer_IDL_show_actions_helper::s_prototype);
    }
    yarpActionsPlayer_IDL_show_actions_helper helper{};
    bool ok = yarp().write(helper, helper);
    return ok ? helper.reply.return_helper : bool{};
}
 
bool yarpActionsPlayer_IDL::set_thread_period(const double value)
{
    if (!yarp().canWrite()) {
        yError("Missing server method '%s'?", yarpActionsPlayer_IDL_set_thread_period_helper::s_prototype);
    }
    yarpActionsPlayer_IDL_set_thread_period_helper helper{value};
    bool ok = yarp().write(helper, helper);
    return ok ? helper.reply.return_helper : bool{};
}
 
// help method
std::vector<std::string> yarpActionsPlayer_IDL::help(const std::string& functionName)
{
    bool showAll = (functionName == "--all");
    std::vector<std::string> helpString;
    if (showAll) {
        helpString.emplace_back("*** Available commands:");
        helpString.emplace_back(yarpActionsPlayer_IDL_start_helper::s_tag);
        helpString.emplace_back(yarpActionsPlayer_IDL_stop_helper::s_tag);
        helpString.emplace_back(yarpActionsPlayer_IDL_reset_helper::s_tag);
        helpString.emplace_back(yarpActionsPlayer_IDL_forever_helper::s_tag);
        helpString.emplace_back(yarpActionsPlayer_IDL_print_frames_helper::s_tag);
        helpString.emplace_back(yarpActionsPlayer_IDL_speed_factor_helper::s_tag);
        helpString.emplace_back(yarpActionsPlayer_IDL_resample_helper::s_tag);
        helpString.emplace_back(yarpActionsPlayer_IDL_choose_action_helper::s_tag);
        helpString.emplace_back(yarpActionsPlayer_IDL_play_action_helper::s_tag);
        helpString.emplace_back(yarpActionsPlayer_IDL_show_actions_helper::s_tag);
        helpString.emplace_back(yarpActionsPlayer_IDL_set_thread_period_helper::s_tag);
        helpString.emplace_back("help");
    } else {
        if (functionName == yarpActionsPlayer_IDL_start_helper::s_tag) {
            helpString.emplace_back(yarpActionsPlayer_IDL_start_helper::s_prototype);
            helpString.emplace_back(yarpActionsPlayer_IDL_start_helper::s_help);
        }
        if (functionName == yarpActionsPlayer_IDL_stop_helper::s_tag) {
            helpString.emplace_back(yarpActionsPlayer_IDL_stop_helper::s_prototype);
            helpString.emplace_back(yarpActionsPlayer_IDL_stop_helper::s_help);
        }
        if (functionName == yarpActionsPlayer_IDL_reset_helper::s_tag) {
            helpString.emplace_back(yarpActionsPlayer_IDL_reset_helper::s_prototype);
            helpString.emplace_back(yarpActionsPlayer_IDL_reset_helper::s_help);
        }
        if (functionName == yarpActionsPlayer_IDL_forever_helper::s_tag) {
            helpString.emplace_back(yarpActionsPlayer_IDL_forever_helper::s_prototype);
            helpString.emplace_back(yarpActionsPlayer_IDL_forever_helper::s_help);
        }
        if (functionName == yarpActionsPlayer_IDL_print_frames_helper::s_tag) {
            helpString.emplace_back(yarpActionsPlayer_IDL_print_frames_helper::s_prototype);
            helpString.emplace_back(yarpActionsPlayer_IDL_print_frames_helper::s_help);
        }
        if (functionName == yarpActionsPlayer_IDL_speed_factor_helper::s_tag) {
            helpString.emplace_back(yarpActionsPlayer_IDL_speed_factor_helper::s_prototype);
            helpString.emplace_back(yarpActionsPlayer_IDL_speed_factor_helper::s_help);
        }
        if (functionName == yarpActionsPlayer_IDL_resample_helper::s_tag) {
            helpString.emplace_back(yarpActionsPlayer_IDL_resample_helper::s_prototype);
            helpString.emplace_back(yarpActionsPlayer_IDL_resample_helper::s_help);
        }
        if (functionName == yarpActionsPlayer_IDL_choose_action_helper::s_tag) {
            helpString.emplace_back(yarpActionsPlayer_IDL_choose_action_helper::s_prototype);
            helpString.emplace_back(yarpActionsPlayer_IDL_choose_action_helper::s_help);
        }
        if (functionName == yarpActionsPlayer_IDL_play_action_helper::s_tag) {
            helpString.emplace_back(yarpActionsPlayer_IDL_play_action_helper::s_prototype);
            helpString.emplace_back(yarpActionsPlayer_IDL_play_action_helper::s_help);
        }
        if (functionName == yarpActionsPlayer_IDL_show_actions_helper::s_tag) {
            helpString.emplace_back(yarpActionsPlayer_IDL_show_actions_helper::s_prototype);
            helpString.emplace_back(yarpActionsPlayer_IDL_show_actions_helper::s_help);
        }
        if (functionName == yarpActionsPlayer_IDL_set_thread_period_helper::s_tag) {
            helpString.emplace_back(yarpActionsPlayer_IDL_set_thread_period_helper::s_prototype);
            helpString.emplace_back(yarpActionsPlayer_IDL_set_thread_period_helper::s_help);
        }
        if (functionName == "help") {
            helpString.emplace_back("std::vector<std::string> help(const std::string& functionName = \"--all\")");
            helpString.emplace_back("Return list of available commands, or help message for a specific function");
            helpString.emplace_back("@param functionName name of command for which to get a detailed description. If none or '--all' is provided, print list of available commands");
            helpString.emplace_back("@return list of strings (one string per line)");
        }
    }
    if (helpString.empty()) {
        helpString.emplace_back("Command not found");
    }
    return helpString;
}
 
// read from ConnectionReader
bool yarpActionsPlayer_IDL::read(yarp::os::ConnectionReader& connection)
{
    constexpr size_t max_tag_len = 3;
    size_t tag_len = 1;
 
    yarp::os::idl::WireReader reader(connection);
    reader.expectAccept();
    if (!reader.readListHeader()) {
        reader.fail();
        return false;
    }
 
    std::string tag = reader.readTag(1);
    bool direct = (tag == "__direct__");
    if (direct) {
        tag = reader.readTag(1);
    }
    while (tag_len <= max_tag_len && !reader.isError()) {
        if(tag == "getRemoteProtocolVersion") {
            if (!reader.noMore()) {
                yError("Reader invalid protocol?! %s:%d - %s", __FILE__, __LINE__, __YFUNCTION__);
                reader.fail();
                return false;
            }
 
            auto proto = getLocalProtocolVersion();
 
            yarp::os::idl::WireWriter writer(reader);
           if (!writer.writeListHeader(1)) {
                yWarning("Writer invalid protocol?! %s:%d - %s", __FILE__, __LINE__, __YFUNCTION__);
               return false;}
            if (!writer.write(proto)) {
                yWarning("Writer invalid protocol?! %s:%d - %s", __FILE__, __LINE__, __YFUNCTION__);
                return false;
            }
            reader.accept();
            return true;
        }
        if (tag == yarpActionsPlayer_IDL_start_helper::s_tag) {
            yarpActionsPlayer_IDL_start_helper helper;
            if (!helper.cmd.readArgs(reader)) {
                return false;
            }
 
            helper.call(this);
 
            yarp::os::idl::WireWriter writer(reader);
            if (!helper.reply.write(writer)) {
                return false;
            }
            reader.accept();
            return true;
        }
        if (tag == yarpActionsPlayer_IDL_stop_helper::s_tag) {
            yarpActionsPlayer_IDL_stop_helper helper;
            if (!helper.cmd.readArgs(reader)) {
                return false;
            }
 
            helper.call(this);
 
            yarp::os::idl::WireWriter writer(reader);
            if (!helper.reply.write(writer)) {
                return false;
            }
            reader.accept();
            return true;
        }
        if (tag == yarpActionsPlayer_IDL_reset_helper::s_tag) {
            yarpActionsPlayer_IDL_reset_helper helper;
            if (!helper.cmd.readArgs(reader)) {
                return false;
            }
 
            helper.call(this);
 
            yarp::os::idl::WireWriter writer(reader);
            if (!helper.reply.write(writer)) {
                return false;
            }
            reader.accept();
            return true;
        }
        if (tag == yarpActionsPlayer_IDL_forever_helper::s_tag) {
            yarpActionsPlayer_IDL_forever_helper helper;
            if (!helper.cmd.readArgs(reader)) {
                return false;
            }
 
            helper.call(this);
 
            yarp::os::idl::WireWriter writer(reader);
            if (!helper.reply.write(writer)) {
                return false;
            }
            reader.accept();
            return true;
        }
        if (tag == yarpActionsPlayer_IDL_print_frames_helper::s_tag) {
            yarpActionsPlayer_IDL_print_frames_helper helper;
            if (!helper.cmd.readArgs(reader)) {
                return false;
            }
 
            helper.call(this);
 
            yarp::os::idl::WireWriter writer(reader);
            if (!helper.reply.write(writer)) {
                return false;
            }
            reader.accept();
            return true;
        }
        if (tag == yarpActionsPlayer_IDL_speed_factor_helper::s_tag) {
            yarpActionsPlayer_IDL_speed_factor_helper helper;
            if (!helper.cmd.readArgs(reader)) {
                return false;
            }
 
            helper.call(this);
 
            yarp::os::idl::WireWriter writer(reader);
            if (!helper.reply.write(writer)) {
                return false;
            }
            reader.accept();
            return true;
        }
        if (tag == yarpActionsPlayer_IDL_resample_helper::s_tag) {
            yarpActionsPlayer_IDL_resample_helper helper;
            if (!helper.cmd.readArgs(reader)) {
                return false;
            }
 
            helper.call(this);
 
            yarp::os::idl::WireWriter writer(reader);
            if (!helper.reply.write(writer)) {
                return false;
            }
            reader.accept();
            return true;
        }
        if (tag == yarpActionsPlayer_IDL_choose_action_helper::s_tag) {
            yarpActionsPlayer_IDL_choose_action_helper helper;
            if (!helper.cmd.readArgs(reader)) {
                return false;
            }
 
            helper.call(this);
 
            yarp::os::idl::WireWriter writer(reader);
            if (!helper.reply.write(writer)) {
                return false;
            }
            reader.accept();
            return true;
        }
        if (tag == yarpActionsPlayer_IDL_play_action_helper::s_tag) {
            yarpActionsPlayer_IDL_play_action_helper helper;
            if (!helper.cmd.readArgs(reader)) {
                return false;
            }
 
            helper.call(this);
 
            yarp::os::idl::WireWriter writer(reader);
            if (!helper.reply.write(writer)) {
                return false;
            }
            reader.accept();
            return true;
        }
        if (tag == yarpActionsPlayer_IDL_show_actions_helper::s_tag) {
            yarpActionsPlayer_IDL_show_actions_helper helper;
            if (!helper.cmd.readArgs(reader)) {
                return false;
            }
 
            helper.call(this);
 
            yarp::os::idl::WireWriter writer(reader);
            if (!helper.reply.write(writer)) {
                return false;
            }
            reader.accept();
            return true;
        }
        if (tag == yarpActionsPlayer_IDL_set_thread_period_helper::s_tag) {
            yarpActionsPlayer_IDL_set_thread_period_helper helper;
            if (!helper.cmd.readArgs(reader)) {
                return false;
            }
 
            helper.call(this);
 
            yarp::os::idl::WireWriter writer(reader);
            if (!helper.reply.write(writer)) {
                return false;
            }
            reader.accept();
            return true;
        }
        if (tag == "help") {
            std::string functionName;
            if (!reader.readString(functionName)) {
                functionName = "--all";
            }
            auto help_strings = help(functionName);
            yarp::os::idl::WireWriter writer(reader);
            if (!writer.isNull()) {
                if (!writer.writeListHeader(2)) {
                    return false;
                }
                if (!writer.writeTag("many", 1, 0)) {
                    return false;
                }
                if (!writer.writeListBegin(0, help_strings.size())) {
                    return false;
                }
                for (const auto& help_string : help_strings) {
                    if (!writer.writeString(help_string)) {
                        return false;
                    }
                }
                if (!writer.writeListEnd()) {
                    return false;
                }
            }
            reader.accept();
            return true;
        }
        if (reader.noMore()) {
            reader.fail();
            return false;
        }
        std::string next_tag = reader.readTag(1);
        if (next_tag.empty()) {
            break;
        }
        tag.append("_").append(next_tag);
        tag_len = std::count(tag.begin(), tag.end(), '_') + 1;
    }
    return false;
}