StringUtilities.cpp

Go to the documentation of this file.

#include "robot_instance/StringUtilities.h"

using namespace std;


bool StringUtilities::isFullyQualifiedRobonetNode(const std::string& name)
{
    return boost::regex_match(name, VALID_ROBONET_NODE);
}

bool StringUtilities::isFullyQualifiedRobonetElement(const std::string& name)
{
    return boost::regex_match(name, VALID_ROBONET_ELEMENT);
}

std::string StringUtilities::getRobonetChannel(const std::string& name)
{
    if (isFullyQualifiedRobonetNode(name) || isFullyQualifiedRobonetElement(name))
    {
        boost::match_results<std::string::const_iterator> matches;
        boost::regex_search(name.begin(), name.end(), matches, VALID_ROBONET_NODE);
        return std::string(matches[1].first, matches[1].second);
    }
    else
    {
        throw std::runtime_error(name + " is not a valid node or element name.");
    }

    return std::string();
}

std::string StringUtilities::getRobonetNode(const std::string& name)
{
    if (isFullyQualifiedRobonetNode(name) || isFullyQualifiedRobonetElement(name))
    {
        boost::match_results<std::string::const_iterator> matches;
        boost::regex_search(name.begin(), name.end(), matches, VALID_ROBONET_NODE);
        return std::string(matches[2].first, matches[2].second);
    }
    else
    {
        throw std::runtime_error(name + " is not a valid node or element name.");
    }

    return std::string();
}

std::string StringUtilities::getFullyQualifiedRobonetNode(const std::string& name)
{
    if (isFullyQualifiedRobonetNode(name) || isFullyQualifiedRobonetElement(name))
    {
        boost::match_results<std::string::const_iterator> matches;
        boost::regex_search(name.begin(), name.end(), matches, VALID_ROBONET_NODE);
        return std::string(TOKEN_DELIMITER) + std::string(matches[1].first, matches[2].second);
    }
    else
    {
        throw std::runtime_error(name + " is not a valid node or element name.");
    }

    return std::string();
}

std::string StringUtilities::getRobonetElement(const std::string& name)
{
    if (isFullyQualifiedRobonetElement(name))
    {
        boost::match_results<std::string::const_iterator> matches;
        boost::regex_search(name.begin(), name.end(), matches, VALID_ROBONET_ELEMENT);
        return std::string(matches[3].first, matches[3].second);
    }
    else
    {
        throw std::runtime_error(name + " is not a valid element name.");
    }

    return std::string();
}

std::string StringUtilities::makeFullyQualifiedRobonetNode(const std::string& channel, const std::string& node)
{
    string output = TOKEN_DELIMITER + channel + TOKEN_DELIMITER + node;

    if (isFullyQualifiedRobonetNode(output))
    {
        return output;
    }
    else
    {
        throw std::runtime_error("Unable to create valid fully qualified Robonet node from inputs [" + channel + "] and [" + node + "]");
    }

    return string();
}

std::string StringUtilities::makeFullyQualifiedRobonetElement(const std::string& fqNode, const std::string& element)
{
    string output = fqNode + TOKEN_DELIMITER + element;

    if (isFullyQualifiedRobonetElement(output))
    {
        return output;
    }
    else
    {
        throw std::runtime_error("Unable to create valid fully qualified Robonet node from inputs [" + fqNode + "] and [" + element + "]");
    }

    return string();
}

std::string StringUtilities::makeFullyQualifiedRobonetElement(const std::string& channel, const std::string& node, const std::string& element)
{
    string output = TOKEN_DELIMITER + channel + TOKEN_DELIMITER + node + TOKEN_DELIMITER + element;

    if (isFullyQualifiedRobonetElement(output))
    {
        return output;
    }
    else
    {
        throw std::runtime_error("Unable to create valid fully qualified Robonet node from inputs [" + channel + "], [" + node + "], and [" + element + "]");
    }

    return string();
}

bool StringUtilities::isFullyQualifiedRoboDynChain(const std::string& name)
{
    return boost::regex_match(name, VALID_ROBODYN_CHAIN);
}

bool StringUtilities::isFullyQualifiedRoboDynJoint(const std::string& name)
{
    return boost::regex_match(name, VALID_ROBODYN_JOINT);
}

bool StringUtilities::isFullyQualifiedRoboDynJointWithGroup(const std::string& name)
{
    return boost::regex_match(name, VALID_ROBODYN_JOINT_WITH_GROUP);
}

std::string StringUtilities::getRoboDynChain(const std::string& name)
{
    if (isFullyQualifiedRoboDynChain(name) || isFullyQualifiedRoboDynJoint(name) || isFullyQualifiedRoboDynJointWithGroup(name))
    {
        boost::match_results<std::string::const_iterator> matches;
        boost::regex_search(name.begin(), name.end(), matches, VALID_ROBODYN_CHAIN);
        return std::string(matches[1].first, matches[1].second);
    }
    else
    {
        throw std::runtime_error(name + " is not a valid chain or joint name.");
    }

    return std::string();
}

std::string StringUtilities::getFullyQualifiedRoboDynChain(const std::string& name)
{
    return string(TOKEN_DELIMITER + ROBODYN_PREFIX + TOKEN_DELIMITER) + getRoboDynChain(name);
}

std::string StringUtilities::getRoboDynJoint(const std::string& name)
{
    if (isFullyQualifiedRoboDynJoint(name))
    {
        boost::match_results<std::string::const_iterator> matches;
        boost::regex_search(name.begin(), name.end(), matches, VALID_ROBODYN_JOINT);
        return std::string(matches[2].first, matches[2].second);
    }
    else if (isFullyQualifiedRoboDynJointWithGroup(name))
    {
        boost::match_results<std::string::const_iterator> matches;
        boost::regex_search(name.begin(), name.end(), matches, VALID_ROBODYN_JOINT_WITH_GROUP);
        return std::string(matches[3].first, matches[3].second);
    }
    else
    {
        throw std::runtime_error(name + " is not a valid joint or joint-with-group name.");
    }

    return std::string();
}

std::string StringUtilities::getRoboDynJointGroup(const std::string& name)
{
    if (isFullyQualifiedRoboDynJointWithGroup(name))
    {
        boost::match_results<std::string::const_iterator> matches;
        boost::regex_search(name.begin(), name.end(), matches, VALID_ROBODYN_JOINT_WITH_GROUP);
        return std::string(matches[2].first, matches[2].second);
    }
    else
    {
        throw std::runtime_error(name + " is not a valid joint-with-group name.");
    }

    return std::string();
}

std::string StringUtilities::getRoboDynJointWithGroup(const std::string& name)
{
    if (isFullyQualifiedRoboDynJointWithGroup(name))
    {
        boost::match_results<std::string::const_iterator> matches;
        boost::regex_search(name.begin(), name.end(), matches, VALID_ROBODYN_JOINT_WITH_GROUP);
        return std::string(matches[2].first, matches[3].second);
    }
    else
    {
        throw std::runtime_error(name + " is not a valid joint-with-group name.");
    }

    return std::string();
}

std::string StringUtilities::getRoboDynEverythingButJoint(const std::string& name)
{
    if (isFullyQualifiedRoboDynJoint(name))
    {
        boost::match_results<std::string::const_iterator> matches;
        boost::regex_search(name.begin(), name.end(), matches, VALID_ROBODYN_JOINT);
        return ROBODYN_PREFIX + TOKEN_DELIMITER + std::string(matches[1].first, matches[1].second);
    }
    else if (isFullyQualifiedRoboDynJointWithGroup(name))
    {
        boost::match_results<std::string::const_iterator> matches;
        boost::regex_search(name.begin(), name.end(), matches, VALID_ROBODYN_JOINT_WITH_GROUP);
        return ROBODYN_PREFIX + TOKEN_DELIMITER + std::string(matches[1].first, matches[2].second);
    }
    else
    {
        throw std::runtime_error(name + " is not a valid joint or joint-with-group name.");
    }

    return std::string();
}

std::string StringUtilities::makeFullyQualifiedRoboDynChain(const std::string& chain)
{
    string output = ROBODYN_PREFIX + TOKEN_DELIMITER + chain;

    if (isFullyQualifiedRoboDynChain(output))
    {
        return output;
    }
    else
    {
        throw std::runtime_error("Unable to create valid fully qualified RoboDyn chain from input [" + chain + "]");
    }

    return string();
}

std::string StringUtilities::makeFullyQualifiedRoboDynJoint(const std::string& chain, const std::string& joint)
{
    string output = ROBODYN_PREFIX + TOKEN_DELIMITER + chain + TOKEN_DELIMITER + joint;

    if (isFullyQualifiedRoboDynJoint(output))
    {
        return output;
    }
    else
    {
        throw std::runtime_error("Unable to create valid fully qualified RoboDyn joint from input [" + chain + "] and [" + joint + "]");
    }

    return string();
}

std::string StringUtilities::makeFullyQualifiedRoboDynJointGroup(const std::string& chain, const std::string& group)
{
    string output = ROBODYN_PREFIX + TOKEN_DELIMITER + chain + TOKEN_DELIMITER + group;

    if (isFullyQualifiedRoboDynJointWithGroup(output) || isFullyQualifiedRoboDynJoint(output))
    {
        return output;
    }
    else
    {
        throw std::runtime_error("Unable to create valid fully qualified RoboDyn group from input [" + chain + "], [" + group + "]");
    }

    return string();
}

std::string StringUtilities::makeFullyQualifiedRoboDynJointWithGroup(const std::string& chain, const std::string& group, const std::string& joint)
{
    string output = ROBODYN_PREFIX + TOKEN_DELIMITER + chain + TOKEN_DELIMITER + group + TOKEN_DELIMITER + joint;

    if (isFullyQualifiedRoboDynJointWithGroup(output))
    {
        return output;
    }
    else
    {
        throw std::runtime_error("Unable to create valid fully qualified RoboDyn joint-with-group from input [" + chain + "], [" + group + "], and [" + joint + "]");
    }

    return string();
}

std::string StringUtilities::makeFullyQualifiedRoboDynElement(const std::string& fqJoint, const std::string& element)
{
    string output = fqJoint + TOKEN_DELIMITER + element;

    if (isFullyQualifiedRoboDynJointWithGroup(output))
    {
        return output;
    }
    else
    {
        throw std::runtime_error("Unable to create valid fully qualified RoboDyn element from input [" + fqJoint + "] and [" + element + "]");
    }

    return string();
}

bool StringUtilities::isItemWithNumber(const std::string& name)
{
    return boost::regex_match(name, ITEM_WITH_NUMBER);
}

std::string StringUtilities::getItem(const std::string& name)
{
    if (isItemWithNumber(name))
    {
        boost::match_results<std::string::const_iterator> matches;
        boost::regex_search(name.begin(), name.end(), matches, ITEM_WITH_NUMBER);
        return std::string(matches[1].first, matches[1].second);
    }
    else
    {
        throw std::runtime_error(name + " is not a valid item with number.");
    }

    return std::string();
}

std::string StringUtilities::getNumber(const std::string& name)
{
    if (isItemWithNumber(name))
    {
        boost::match_results<std::string::const_iterator> matches;
        boost::regex_search(name.begin(), name.end(), matches, ITEM_WITH_NUMBER);
        return std::string(matches[2].first, matches[2].second);
    }
    else
    {
        throw std::runtime_error(name + " is not a valid item with number.");
    }

    return std::string();
}