FakeSerialPort_ParamsParser.cpp

Go to the documentation of this file.

/*
 * SPDX-FileCopyrightText: 2023-2023 Istituto Italiano di Tecnologia (IIT)
 * SPDX-License-Identifier: LGPL-2.1-or-later
 */
 
 
// Generated by yarpDeviceParamParserGenerator (2.0)
// This is an automatically generated file. Please do not edit it.
// It will be re-generated if the cmake flag ALLOW_DEVICE_PARAM_PARSER_GERNERATION is ON.
 
// Generated on: Thu May 22 11:32:32 2025
 
 
#include "FakeSerialPort_ParamsParser.h"
#include <yarp/os/LogStream.h>
#include <yarp/os/Value.h>
 
namespace {
    YARP_LOG_COMPONENT(FakeSerialPortParamsCOMPONENT, "yarp.device.FakeSerialPort")
}
 
 
FakeSerialPort_ParamsParser::FakeSerialPort_ParamsParser()
{
}
 
 
std::vector<std::string> FakeSerialPort_ParamsParser::getListOfParams() const
{
    std::vector<std::string> params;
    params.push_back("comport");
    params.push_back("verbose");
    params.push_back("baudrate");
    params.push_back("xonlim");
    params.push_back("xofflim");
    params.push_back("readmincharacters");
    params.push_back("readtimeoutmsec");
    params.push_back("paritymode");
    params.push_back("ctsenb");
    params.push_back("rtsenb");
    params.push_back("xinenb");
    params.push_back("xoutenb");
    params.push_back("modem");
    params.push_back("rcvenb");
    params.push_back("dsrenb");
    params.push_back("dtrdisable");
    params.push_back("databits");
    params.push_back("stopbits");
    params.push_back("line_terminator_char1");
    params.push_back("line_terminator_char2");
    return params;
}
 
 
bool FakeSerialPort_ParamsParser::getParamValue(const std::string& paramName, std::string& paramValue) const
{
    if (paramName =="comport")
    {
        paramValue = m_comport;
        return true;
    }
    if (paramName =="verbose")
    {
        paramValue = std::to_string(m_verbose);
        return true;
    }
    if (paramName =="baudrate")
    {
        paramValue = std::to_string(m_baudrate);
        return true;
    }
    if (paramName =="xonlim")
    {
        paramValue = std::to_string(m_xonlim);
        return true;
    }
    if (paramName =="xofflim")
    {
        paramValue = std::to_string(m_xofflim);
        return true;
    }
    if (paramName =="readmincharacters")
    {
        paramValue = std::to_string(m_readmincharacters);
        return true;
    }
    if (paramName =="readtimeoutmsec")
    {
        paramValue = std::to_string(m_readtimeoutmsec);
        return true;
    }
    if (paramName =="paritymode")
    {
        paramValue = m_paritymode;
        return true;
    }
    if (paramName =="ctsenb")
    {
        paramValue = std::to_string(m_ctsenb);
        return true;
    }
    if (paramName =="rtsenb")
    {
        paramValue = std::to_string(m_rtsenb);
        return true;
    }
    if (paramName =="xinenb")
    {
        paramValue = std::to_string(m_xinenb);
        return true;
    }
    if (paramName =="xoutenb")
    {
        paramValue = std::to_string(m_xoutenb);
        return true;
    }
    if (paramName =="modem")
    {
        paramValue = std::to_string(m_modem);
        return true;
    }
    if (paramName =="rcvenb")
    {
        paramValue = std::to_string(m_rcvenb);
        return true;
    }
    if (paramName =="dsrenb")
    {
        paramValue = std::to_string(m_dsrenb);
        return true;
    }
    if (paramName =="dtrdisable")
    {
        paramValue = std::to_string(m_dtrdisable);
        return true;
    }
    if (paramName =="databits")
    {
        paramValue = std::to_string(m_databits);
        return true;
    }
    if (paramName =="stopbits")
    {
        paramValue = std::to_string(m_stopbits);
        return true;
    }
    if (paramName =="line_terminator_char1")
    {
        return false;
    }
    if (paramName =="line_terminator_char2")
    {
        return false;
    }
 
    yError() <<"parameter '" << paramName << "' was not found";
    return false;
 
}
 
 
std::string FakeSerialPort_ParamsParser::getConfiguration() const
{
    //This is a sub-optimal solution.
    //Ideally getConfiguration() should return all parameters but it is currently
    //returning only user provided parameters (excluding default values)
    //This behaviour will be fixed in the near future.
    std::string s_cfg = m_provided_configuration;
    return s_cfg;
}
 
bool      FakeSerialPort_ParamsParser::parseParams(const yarp::os::Searchable & config)
{
    //Check for --help option
    if (config.check("help"))
    {
        yCInfo(FakeSerialPortParamsCOMPONENT) << getDocumentationOfDeviceParams();
    }
 
    m_provided_configuration = config.toString();
    yarp::os::Property prop_check(m_provided_configuration.c_str());
    //Parser of parameter comport
    {
        if (config.check("comport"))
        {
            m_comport = config.find("comport").asString();
            yCInfo(FakeSerialPortParamsCOMPONENT) << "Parameter 'comport' using value:" << m_comport;
        }
        else
        {
            yCError(FakeSerialPortParamsCOMPONENT) << "Mandatory parameter 'comport' not found!";
            yCError(FakeSerialPortParamsCOMPONENT) << "Description of the parameter: name of the serial channel";
            return false;
        }
        prop_check.unput("comport");
    }
 
    //Parser of parameter verbose
    {
        if (config.check("verbose"))
        {
            m_verbose = config.find("verbose").asInt64();
            yCInfo(FakeSerialPortParamsCOMPONENT) << "Parameter 'verbose' using value:" << m_verbose;
        }
        else
        {
            yCInfo(FakeSerialPortParamsCOMPONENT) << "Parameter 'verbose' using DEFAULT value:" << m_verbose;
        }
        prop_check.unput("verbose");
    }
 
    //Parser of parameter baudrate
    {
        if (config.check("baudrate"))
        {
            m_baudrate = config.find("baudrate").asInt64();
            yCInfo(FakeSerialPortParamsCOMPONENT) << "Parameter 'baudrate' using value:" << m_baudrate;
        }
        else
        {
            yCError(FakeSerialPortParamsCOMPONENT) << "Mandatory parameter 'baudrate' not found!";
            yCError(FakeSerialPortParamsCOMPONENT) << "Description of the parameter: Specifies the baudrate at which the communication port operates";
            return false;
        }
        prop_check.unput("baudrate");
    }
 
    //Parser of parameter xonlim
    {
        if (config.check("xonlim"))
        {
            m_xonlim = config.find("xonlim").asInt64();
            yCInfo(FakeSerialPortParamsCOMPONENT) << "Parameter 'xonlim' using value:" << m_xonlim;
        }
        else
        {
            yCInfo(FakeSerialPortParamsCOMPONENT) << "Parameter 'xonlim' using DEFAULT value:" << m_xonlim;
        }
        prop_check.unput("xonlim");
    }
 
    //Parser of parameter xofflim
    {
        if (config.check("xofflim"))
        {
            m_xofflim = config.find("xofflim").asInt64();
            yCInfo(FakeSerialPortParamsCOMPONENT) << "Parameter 'xofflim' using value:" << m_xofflim;
        }
        else
        {
            yCInfo(FakeSerialPortParamsCOMPONENT) << "Parameter 'xofflim' using DEFAULT value:" << m_xofflim;
        }
        prop_check.unput("xofflim");
    }
 
    //Parser of parameter readmincharacters
    {
        if (config.check("readmincharacters"))
        {
            m_readmincharacters = config.find("readmincharacters").asInt64();
            yCInfo(FakeSerialPortParamsCOMPONENT) << "Parameter 'readmincharacters' using value:" << m_readmincharacters;
        }
        else
        {
            yCInfo(FakeSerialPortParamsCOMPONENT) << "Parameter 'readmincharacters' using DEFAULT value:" << m_readmincharacters;
        }
        prop_check.unput("readmincharacters");
    }
 
    //Parser of parameter readtimeoutmsec
    {
        if (config.check("readtimeoutmsec"))
        {
            m_readtimeoutmsec = config.find("readtimeoutmsec").asInt64();
            yCInfo(FakeSerialPortParamsCOMPONENT) << "Parameter 'readtimeoutmsec' using value:" << m_readtimeoutmsec;
        }
        else
        {
            yCInfo(FakeSerialPortParamsCOMPONENT) << "Parameter 'readtimeoutmsec' using DEFAULT value:" << m_readtimeoutmsec;
        }
        prop_check.unput("readtimeoutmsec");
    }
 
    //Parser of parameter paritymode
    {
        if (config.check("paritymode"))
        {
            m_paritymode = config.find("paritymode").asString();
            yCInfo(FakeSerialPortParamsCOMPONENT) << "Parameter 'paritymode' using value:" << m_paritymode;
        }
        else
        {
            yCInfo(FakeSerialPortParamsCOMPONENT) << "Parameter 'paritymode' using DEFAULT value:" << m_paritymode;
        }
        prop_check.unput("paritymode");
    }
 
    //Parser of parameter ctsenb
    {
        if (config.check("ctsenb"))
        {
            m_ctsenb = config.find("ctsenb").asInt64();
            yCInfo(FakeSerialPortParamsCOMPONENT) << "Parameter 'ctsenb' using value:" << m_ctsenb;
        }
        else
        {
            yCInfo(FakeSerialPortParamsCOMPONENT) << "Parameter 'ctsenb' using DEFAULT value:" << m_ctsenb;
        }
        prop_check.unput("ctsenb");
    }
 
    //Parser of parameter rtsenb
    {
        if (config.check("rtsenb"))
        {
            m_rtsenb = config.find("rtsenb").asInt64();
            yCInfo(FakeSerialPortParamsCOMPONENT) << "Parameter 'rtsenb' using value:" << m_rtsenb;
        }
        else
        {
            yCInfo(FakeSerialPortParamsCOMPONENT) << "Parameter 'rtsenb' using DEFAULT value:" << m_rtsenb;
        }
        prop_check.unput("rtsenb");
    }
 
    //Parser of parameter xinenb
    {
        if (config.check("xinenb"))
        {
            m_xinenb = config.find("xinenb").asInt64();
            yCInfo(FakeSerialPortParamsCOMPONENT) << "Parameter 'xinenb' using value:" << m_xinenb;
        }
        else
        {
            yCInfo(FakeSerialPortParamsCOMPONENT) << "Parameter 'xinenb' using DEFAULT value:" << m_xinenb;
        }
        prop_check.unput("xinenb");
    }
 
    //Parser of parameter xoutenb
    {
        if (config.check("xoutenb"))
        {
            m_xoutenb = config.find("xoutenb").asInt64();
            yCInfo(FakeSerialPortParamsCOMPONENT) << "Parameter 'xoutenb' using value:" << m_xoutenb;
        }
        else
        {
            yCInfo(FakeSerialPortParamsCOMPONENT) << "Parameter 'xoutenb' using DEFAULT value:" << m_xoutenb;
        }
        prop_check.unput("xoutenb");
    }
 
    //Parser of parameter modem
    {
        if (config.check("modem"))
        {
            m_modem = config.find("modem").asInt64();
            yCInfo(FakeSerialPortParamsCOMPONENT) << "Parameter 'modem' using value:" << m_modem;
        }
        else
        {
            yCInfo(FakeSerialPortParamsCOMPONENT) << "Parameter 'modem' using DEFAULT value:" << m_modem;
        }
        prop_check.unput("modem");
    }
 
    //Parser of parameter rcvenb
    {
        if (config.check("rcvenb"))
        {
            m_rcvenb = config.find("rcvenb").asInt64();
            yCInfo(FakeSerialPortParamsCOMPONENT) << "Parameter 'rcvenb' using value:" << m_rcvenb;
        }
        else
        {
            yCInfo(FakeSerialPortParamsCOMPONENT) << "Parameter 'rcvenb' using DEFAULT value:" << m_rcvenb;
        }
        prop_check.unput("rcvenb");
    }
 
    //Parser of parameter dsrenb
    {
        if (config.check("dsrenb"))
        {
            m_dsrenb = config.find("dsrenb").asInt64();
            yCInfo(FakeSerialPortParamsCOMPONENT) << "Parameter 'dsrenb' using value:" << m_dsrenb;
        }
        else
        {
            yCInfo(FakeSerialPortParamsCOMPONENT) << "Parameter 'dsrenb' using DEFAULT value:" << m_dsrenb;
        }
        prop_check.unput("dsrenb");
    }
 
    //Parser of parameter dtrdisable
    {
        if (config.check("dtrdisable"))
        {
            m_dtrdisable = config.find("dtrdisable").asInt64();
            yCInfo(FakeSerialPortParamsCOMPONENT) << "Parameter 'dtrdisable' using value:" << m_dtrdisable;
        }
        else
        {
            yCInfo(FakeSerialPortParamsCOMPONENT) << "Parameter 'dtrdisable' using DEFAULT value:" << m_dtrdisable;
        }
        prop_check.unput("dtrdisable");
    }
 
    //Parser of parameter databits
    {
        if (config.check("databits"))
        {
            m_databits = config.find("databits").asInt64();
            yCInfo(FakeSerialPortParamsCOMPONENT) << "Parameter 'databits' using value:" << m_databits;
        }
        else
        {
            yCInfo(FakeSerialPortParamsCOMPONENT) << "Parameter 'databits' using DEFAULT value:" << m_databits;
        }
        prop_check.unput("databits");
    }
 
    //Parser of parameter stopbits
    {
        if (config.check("stopbits"))
        {
            m_stopbits = config.find("stopbits").asInt64();
            yCInfo(FakeSerialPortParamsCOMPONENT) << "Parameter 'stopbits' using value:" << m_stopbits;
        }
        else
        {
            yCInfo(FakeSerialPortParamsCOMPONENT) << "Parameter 'stopbits' using DEFAULT value:" << m_stopbits;
        }
        prop_check.unput("stopbits");
    }
 
    //Parser of parameter line_terminator_char1
    {
        if (config.check("line_terminator_char1"))
        {
            m_line_terminator_char1 = config.find("line_terminator_char1").asInt8();
            yCInfo(FakeSerialPortParamsCOMPONENT) << "Parameter 'line_terminator_char1' using value:" << m_line_terminator_char1;
        }
        else
        {
            yCInfo(FakeSerialPortParamsCOMPONENT) << "Parameter 'line_terminator_char1' using DEFAULT value:" << m_line_terminator_char1;
        }
        prop_check.unput("line_terminator_char1");
    }
 
    //Parser of parameter line_terminator_char2
    {
        if (config.check("line_terminator_char2"))
        {
            m_line_terminator_char2 = config.find("line_terminator_char2").asInt8();
            yCInfo(FakeSerialPortParamsCOMPONENT) << "Parameter 'line_terminator_char2' using value:" << m_line_terminator_char2;
        }
        else
        {
            yCInfo(FakeSerialPortParamsCOMPONENT) << "Parameter 'line_terminator_char2' using DEFAULT value:" << m_line_terminator_char2;
        }
        prop_check.unput("line_terminator_char2");
    }
 
    /*
    //This code check if the user set some parameter which are not check by the parser
    //If the parser is set in strict mode, this will generate an error
    if (prop_check.size() > 0)
    {
        bool extra_params_found = false;
        for (auto it=prop_check.begin(); it!=prop_check.end(); it++)
        {
            if (m_parser_is_strict)
            {
                yCError(FakeSerialPortParamsCOMPONENT) << "User asking for parameter: "<<it->name <<" which is unknown to this parser!";
                extra_params_found = true;
            }
            else
            {
                yCWarning(FakeSerialPortParamsCOMPONENT) << "User asking for parameter: "<< it->name <<" which is unknown to this parser!";
            }
        }
 
       if (m_parser_is_strict && extra_params_found)
       {
           return false;
       }
    }
    */
    return true;
}
 
 
std::string      FakeSerialPort_ParamsParser::getDocumentationOfDeviceParams() const
{
    std::string doc;
    doc = doc + std::string("\n=============================================\n");
    doc = doc + std::string("This is the help for device: FakeSerialPort\n");
    doc = doc + std::string("\n");
    doc = doc + std::string("This is the list of the parameters accepted by the device:\n");
    doc = doc + std::string("'comport': name of the serial channel\n");
    doc = doc + std::string("'verbose': Specifies if the device is in verbose mode (0/1)\n");
    doc = doc + std::string("'baudrate': Specifies the baudrate at which the communication port operates\n");
    doc = doc + std::string("'xonlim': Specifies the minimum number of bytes in input buffer before XON char is sent\n");
    doc = doc + std::string("'xofflim': Specifies the maximum number of bytes in input buffer before XOFF char is sent\n");
    doc = doc + std::string("'readmincharacters': Specifies the minimum number of characters for non-canonical read (POSIX)\n");
    doc = doc + std::string("'readtimeoutmsec': Specifies the time to wait before returning from read. Negative value means infinite timeout\n");
    doc = doc + std::string("'paritymode': Specifies the parity mode (EVEN, ODD, NONE\n");
    doc = doc + std::string("'ctsenb': Enable & set CTS mode\n");
    doc = doc + std::string("'rtsenb': Enable & set RTS mode\n");
    doc = doc + std::string("'xinenb': Enable/disable software flow control on input\n");
    doc = doc + std::string("'xoutenb': Enable/disable software flow control on output.\n");
    doc = doc + std::string("'modem': Specifies if device is a modem (POSIX). If not set modem status lines are ignored.\n");
    doc = doc + std::string("'rcvenb': Enable/disable receiver (POSIX).\n");
    doc = doc + std::string("'dsrenb': Controls whether DSR is disabled or enabled (Win32).\n");
    doc = doc + std::string("'dtrdisable': Controls whether DTR is disabled or enabled\n");
    doc = doc + std::string("'databits': Data bits. Valid values 5, 6, 7 and 8 data bits. Additionally Win32 supports 4 data bits.\n");
    doc = doc + std::string("'stopbits': Stop bits. Valid values are 1 and 2.\n");
    doc = doc + std::string("'line_terminator_char1': line terminator character for receiveLine()\n");
    doc = doc + std::string("'line_terminator_char2': line terminator character for receiveLine()\n");
    doc = doc + std::string("\n");
    doc = doc + std::string("Here are some examples of invocation command with yarpdev, with all params:\n");
    doc = doc + " yarpdev --device fakeSerialPort --comport COM3 --verbose 1 --baudrate 9600 --xonlim 0 --xofflim 0 --readmincharacters 1 --readtimeoutmsec 100 --paritymode EVEN --ctsenb 0 --rtsenb 0 --xinenb 0 --xoutenb 0 --modem 0 --rcvenb 0 --dsrenb 0 --dtrdisable 0 --databits 7 --stopbits 1 --line_terminator_char1 '\r' --line_terminator_char2 '\n'\n";
    doc = doc + std::string("Using only mandatory params:\n");
    doc = doc + " yarpdev --device fakeSerialPort --comport COM3 --baudrate 9600\n";
    doc = doc + std::string("=============================================\n\n");    return doc;
}