IRpcServer.cpp

Go to the documentation of this file.

/*
 * Copyright (C) 2006-2019 Istituto Italiano di Tecnologia (IIT)
 * All rights reserved.
 *
 * This software may be modified and distributed under the terms of the
 * BSD-3-Clause license. See the accompanying LICENSE file for details.
 */
 
// Autogenerated by Thrift Compiler (0.12.0-yarped)
//
// This is an automatically generated file.
// It could get re-generated if the ALLOW_IDL_GENERATION flag is on.
 
#include <IRpcServer.h>
 
#include <yarp/os/idl/WireTypes.h>
 
class IRpcServer_get_answer_helper :
        public yarp::os::Portable
{
public:
    explicit IRpcServer_get_answer_helper();
    bool write(yarp::os::ConnectionWriter& connection) const override;
    bool read(yarp::os::ConnectionReader& connection) override;
 
    thread_local static std::int32_t s_return_helper;
};
 
thread_local std::int32_t IRpcServer_get_answer_helper::s_return_helper = {};
 
IRpcServer_get_answer_helper::IRpcServer_get_answer_helper()
{
    s_return_helper = {};
}
 
bool IRpcServer_get_answer_helper::write(yarp::os::ConnectionWriter& connection) const
{
    yarp::os::idl::WireWriter writer(connection);
    if (!writer.writeListHeader(2)) {
        return false;
    }
    if (!writer.writeTag("get_answer", 1, 2)) {
        return false;
    }
    return true;
}
 
bool IRpcServer_get_answer_helper::read(yarp::os::ConnectionReader& connection)
{
    yarp::os::idl::WireReader reader(connection);
    if (!reader.readListReturn()) {
        return false;
    }
    if (!reader.readI32(s_return_helper)) {
        reader.fail();
        return false;
    }
    return true;
}
 
class IRpcServer_set_answer_helper :
        public yarp::os::Portable
{
public:
    explicit IRpcServer_set_answer_helper(const std::int32_t rightAnswer);
    bool write(yarp::os::ConnectionWriter& connection) const override;
    bool read(yarp::os::ConnectionReader& connection) override;
 
    std::int32_t m_rightAnswer;
 
    thread_local static bool s_return_helper;
};
 
thread_local bool IRpcServer_set_answer_helper::s_return_helper = {};
 
IRpcServer_set_answer_helper::IRpcServer_set_answer_helper(const std::int32_t rightAnswer) :
        m_rightAnswer{rightAnswer}
{
    s_return_helper = {};
}
 
bool IRpcServer_set_answer_helper::write(yarp::os::ConnectionWriter& connection) const
{
    yarp::os::idl::WireWriter writer(connection);
    if (!writer.writeListHeader(3)) {
        return false;
    }
    if (!writer.writeTag("set_answer", 1, 2)) {
        return false;
    }
    if (!writer.writeI32(m_rightAnswer)) {
        return false;
    }
    return true;
}
 
bool IRpcServer_set_answer_helper::read(yarp::os::ConnectionReader& connection)
{
    yarp::os::idl::WireReader reader(connection);
    if (!reader.readListReturn()) {
        return false;
    }
    if (!reader.readBool(s_return_helper)) {
        reader.fail();
        return false;
    }
    return true;
}
 
class IRpcServer_add_int_helper :
        public yarp::os::Portable
{
public:
    explicit IRpcServer_add_int_helper(const std::int32_t x);
    bool write(yarp::os::ConnectionWriter& connection) const override;
    bool read(yarp::os::ConnectionReader& connection) override;
 
    std::int32_t m_x;
 
    thread_local static std::int32_t s_return_helper;
};
 
thread_local std::int32_t IRpcServer_add_int_helper::s_return_helper = {};
 
IRpcServer_add_int_helper::IRpcServer_add_int_helper(const std::int32_t x) :
        m_x{x}
{
    s_return_helper = {};
}
 
bool IRpcServer_add_int_helper::write(yarp::os::ConnectionWriter& connection) const
{
    yarp::os::idl::WireWriter writer(connection);
    if (!writer.writeListHeader(3)) {
        return false;
    }
    if (!writer.writeTag("add_int", 1, 2)) {
        return false;
    }
    if (!writer.writeI32(m_x)) {
        return false;
    }
    return true;
}
 
bool IRpcServer_add_int_helper::read(yarp::os::ConnectionReader& connection)
{
    yarp::os::idl::WireReader reader(connection);
    if (!reader.readListReturn()) {
        return false;
    }
    if (!reader.readI32(s_return_helper)) {
        reader.fail();
        return false;
    }
    return true;
}
 
class IRpcServer_start_helper :
        public yarp::os::Portable
{
public:
    explicit IRpcServer_start_helper();
    bool write(yarp::os::ConnectionWriter& connection) const override;
    bool read(yarp::os::ConnectionReader& connection) override;
 
    thread_local static bool s_return_helper;
};
 
thread_local bool IRpcServer_start_helper::s_return_helper = {};
 
IRpcServer_start_helper::IRpcServer_start_helper()
{
    s_return_helper = {};
}
 
bool IRpcServer_start_helper::write(yarp::os::ConnectionWriter& connection) const
{
    yarp::os::idl::WireWriter writer(connection);
    if (!writer.writeListHeader(1)) {
        return false;
    }
    if (!writer.writeTag("start", 1, 1)) {
        return false;
    }
    return true;
}
 
bool IRpcServer_start_helper::read(yarp::os::ConnectionReader& connection)
{
    yarp::os::idl::WireReader reader(connection);
    if (!reader.readListReturn()) {
        return false;
    }
    if (!reader.readBool(s_return_helper)) {
        reader.fail();
        return false;
    }
    return true;
}
 
class IRpcServer_stop_helper :
        public yarp::os::Portable
{
public:
    explicit IRpcServer_stop_helper();
    bool write(yarp::os::ConnectionWriter& connection) const override;
    bool read(yarp::os::ConnectionReader& connection) override;
 
    thread_local static bool s_return_helper;
};
 
thread_local bool IRpcServer_stop_helper::s_return_helper = {};
 
IRpcServer_stop_helper::IRpcServer_stop_helper()
{
    s_return_helper = {};
}
 
bool IRpcServer_stop_helper::write(yarp::os::ConnectionWriter& connection) const
{
    yarp::os::idl::WireWriter writer(connection);
    if (!writer.writeListHeader(1)) {
        return false;
    }
    if (!writer.writeTag("stop", 1, 1)) {
        return false;
    }
    return true;
}
 
bool IRpcServer_stop_helper::read(yarp::os::ConnectionReader& connection)
{
    yarp::os::idl::WireReader reader(connection);
    if (!reader.readListReturn()) {
        return false;
    }
    if (!reader.readBool(s_return_helper)) {
        reader.fail();
        return false;
    }
    return true;
}
 
class IRpcServer_is_running_helper :
        public yarp::os::Portable
{
public:
    explicit IRpcServer_is_running_helper();
    bool write(yarp::os::ConnectionWriter& connection) const override;
    bool read(yarp::os::ConnectionReader& connection) override;
 
    thread_local static bool s_return_helper;
};
 
thread_local bool IRpcServer_is_running_helper::s_return_helper = {};
 
IRpcServer_is_running_helper::IRpcServer_is_running_helper()
{
    s_return_helper = {};
}
 
bool IRpcServer_is_running_helper::write(yarp::os::ConnectionWriter& connection) const
{
    yarp::os::idl::WireWriter writer(connection);
    if (!writer.writeListHeader(2)) {
        return false;
    }
    if (!writer.writeTag("is_running", 1, 2)) {
        return false;
    }
    return true;
}
 
bool IRpcServer_is_running_helper::read(yarp::os::ConnectionReader& connection)
{
    yarp::os::idl::WireReader reader(connection);
    if (!reader.readListReturn()) {
        return false;
    }
    if (!reader.readBool(s_return_helper)) {
        reader.fail();
        return false;
    }
    return true;
}
 
// Constructor
IRpcServer::IRpcServer()
{
    yarp().setOwner(*this);
}
 
std::int32_t IRpcServer::get_answer()
{
    IRpcServer_get_answer_helper helper{};
    if (!yarp().canWrite()) {
        yError("Missing server method '%s'?", "std::int32_t IRpcServer::get_answer()");
    }
    bool ok = yarp().write(helper, helper);
    return ok ? IRpcServer_get_answer_helper::s_return_helper : std::int32_t{};
}
 
bool IRpcServer::set_answer(const std::int32_t rightAnswer)
{
    IRpcServer_set_answer_helper helper{rightAnswer};
    if (!yarp().canWrite()) {
        yError("Missing server method '%s'?", "bool IRpcServer::set_answer(const std::int32_t rightAnswer)");
    }
    bool ok = yarp().write(helper, helper);
    return ok ? IRpcServer_set_answer_helper::s_return_helper : bool{};
}
 
std::int32_t IRpcServer::add_int(const std::int32_t x)
{
    IRpcServer_add_int_helper helper{x};
    if (!yarp().canWrite()) {
        yError("Missing server method '%s'?", "std::int32_t IRpcServer::add_int(const std::int32_t x)");
    }
    bool ok = yarp().write(helper, helper);
    return ok ? IRpcServer_add_int_helper::s_return_helper : std::int32_t{};
}
 
bool IRpcServer::start()
{
    IRpcServer_start_helper helper{};
    if (!yarp().canWrite()) {
        yError("Missing server method '%s'?", "bool IRpcServer::start()");
    }
    bool ok = yarp().write(helper, helper);
    return ok ? IRpcServer_start_helper::s_return_helper : bool{};
}
 
bool IRpcServer::stop()
{
    IRpcServer_stop_helper helper{};
    if (!yarp().canWrite()) {
        yError("Missing server method '%s'?", "bool IRpcServer::stop()");
    }
    bool ok = yarp().write(helper, helper);
    return ok ? IRpcServer_stop_helper::s_return_helper : bool{};
}
 
bool IRpcServer::is_running()
{
    IRpcServer_is_running_helper helper{};
    if (!yarp().canWrite()) {
        yError("Missing server method '%s'?", "bool IRpcServer::is_running()");
    }
    bool ok = yarp().write(helper, helper);
    return ok ? IRpcServer_is_running_helper::s_return_helper : bool{};
}
 
// help method
std::vector<std::string> IRpcServer::help(const std::string& functionName)
{
    bool showAll = (functionName == "--all");
    std::vector<std::string> helpString;
    if (showAll) {
        helpString.emplace_back("*** Available commands:");
        helpString.emplace_back("get_answer");
        helpString.emplace_back("set_answer");
        helpString.emplace_back("add_int");
        helpString.emplace_back("start");
        helpString.emplace_back("stop");
        helpString.emplace_back("is_running");
        helpString.emplace_back("help");
    } else {
        if (functionName == "get_answer") {
            helpString.emplace_back("std::int32_t get_answer() ");
            helpString.emplace_back("Get answer from server ");
            helpString.emplace_back("@return the answer ");
        }
        if (functionName == "set_answer") {
            helpString.emplace_back("bool set_answer(const std::int32_t rightAnswer) ");
            helpString.emplace_back("Set value for future answers. ");
            helpString.emplace_back("@param rightAnswer new answer ");
            helpString.emplace_back("@return true if connection was successful ");
        }
        if (functionName == "add_int") {
            helpString.emplace_back("std::int32_t add_int(const std::int32_t x) ");
            helpString.emplace_back("Add one integer to future answers. ");
            helpString.emplace_back("@param x value to add ");
            helpString.emplace_back("@return new value ");
        }
        if (functionName == "start") {
            helpString.emplace_back("bool start() ");
            helpString.emplace_back("Start service ");
            helpString.emplace_back("@return true if service started correctly ");
        }
        if (functionName == "stop") {
            helpString.emplace_back("bool stop() ");
            helpString.emplace_back("Stop service ");
            helpString.emplace_back("@return true if service stopped correctly ");
        }
        if (functionName == "is_running") {
            helpString.emplace_back("bool is_running() ");
            helpString.emplace_back("Check is service is running ");
            helpString.emplace_back("@return true/false if service is/is not running ");
        }
        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 IRpcServer::read(yarp::os::ConnectionReader& connection)
{
    yarp::os::idl::WireReader reader(connection);
    reader.expectAccept();
    if (!reader.readListHeader()) {
        reader.fail();
        return false;
    }
 
    std::string tag = reader.readTag();
    bool direct = (tag == "__direct__");
    if (direct) {
        tag = reader.readTag();
    }
    while (!reader.isError()) {
        if (tag == "get_answer") {
            IRpcServer_get_answer_helper::s_return_helper = get_answer();
            yarp::os::idl::WireWriter writer(reader);
            if (!writer.isNull()) {
                if (!writer.writeListHeader(1)) {
                    return false;
                }
                if (!writer.writeI32(IRpcServer_get_answer_helper::s_return_helper)) {
                    return false;
                }
            }
            reader.accept();
            return true;
        }
        if (tag == "set_answer") {
            std::int32_t rightAnswer;
            if (!reader.readI32(rightAnswer)) {
                reader.fail();
                return false;
            }
            IRpcServer_set_answer_helper::s_return_helper = set_answer(rightAnswer);
            yarp::os::idl::WireWriter writer(reader);
            if (!writer.isNull()) {
                if (!writer.writeListHeader(1)) {
                    return false;
                }
                if (!writer.writeBool(IRpcServer_set_answer_helper::s_return_helper)) {
                    return false;
                }
            }
            reader.accept();
            return true;
        }
        if (tag == "add_int") {
            std::int32_t x;
            if (!reader.readI32(x)) {
                reader.fail();
                return false;
            }
            IRpcServer_add_int_helper::s_return_helper = add_int(x);
            yarp::os::idl::WireWriter writer(reader);
            if (!writer.isNull()) {
                if (!writer.writeListHeader(1)) {
                    return false;
                }
                if (!writer.writeI32(IRpcServer_add_int_helper::s_return_helper)) {
                    return false;
                }
            }
            reader.accept();
            return true;
        }
        if (tag == "start") {
            IRpcServer_start_helper::s_return_helper = start();
            yarp::os::idl::WireWriter writer(reader);
            if (!writer.isNull()) {
                if (!writer.writeListHeader(1)) {
                    return false;
                }
                if (!writer.writeBool(IRpcServer_start_helper::s_return_helper)) {
                    return false;
                }
            }
            reader.accept();
            return true;
        }
        if (tag == "stop") {
            IRpcServer_stop_helper::s_return_helper = stop();
            yarp::os::idl::WireWriter writer(reader);
            if (!writer.isNull()) {
                if (!writer.writeListHeader(1)) {
                    return false;
                }
                if (!writer.writeBool(IRpcServer_stop_helper::s_return_helper)) {
                    return false;
                }
            }
            reader.accept();
            return true;
        }
        if (tag == "is_running") {
            IRpcServer_is_running_helper::s_return_helper = is_running();
            yarp::os::idl::WireWriter writer(reader);
            if (!writer.isNull()) {
                if (!writer.writeListHeader(1)) {
                    return false;
                }
                if (!writer.writeBool(IRpcServer_is_running_helper::s_return_helper)) {
                    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(BOTTLE_TAG_INT32, static_cast<uint32_t>(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();
        if (next_tag == "") {
            break;
        }
        tag.append("_").append(next_tag);
    }
    return false;
}