symbols.cpp

Go to the documentation of this file.

#include <symbols.h>

bool compare_vector_strings(std::vector<std::string> v1, std::vector<std::string> v2) {
    if (v1.size() != v2.size())
        return false;
    std::set<std::string> s1(v1.begin(), v1.end());
    std::set<std::string> s2(v2.begin(), v2.end());
    std::vector<std::string> v3;
    std::set_intersection(s1.begin(), s1.end(), s2.begin(), s2.end(), std::back_inserter(v3));
    if (v1.size() == v3.size())
        return true;
    else
        return false;
}


char choose_variable_separator(std::string str)
{
        // get params separated by ,
        char separator;
        size_t found = str.find(',');
        if (found!=std::string::npos) {
                separator=',';
        }
        else {
                separator=' ';
        }
        return separator;
}

std::string trim(const std::string& str,
                 const std::string& whitespace)
{
    const size_t strBegin = str.find_first_not_of(whitespace);
    if (strBegin == std::string::npos)
        return ""; // no content

    const size_t strEnd = str.find_last_not_of(whitespace);
    const size_t strRange = strEnd - strBegin + 1;

    return str.substr(strBegin, strRange);
}


// OPERATORS
bool operator== (Symbol &s1, Symbol &s2)
{
    return ((s1.name_.compare(s2.name_) == 0) && compare_vector_strings(s1.param_names_, s2.param_names_));
}

std::ostream& operator<<(std::ostream &out, const Symbol &s)
{
    out << s.name_ << "(";
    for ( size_t i = 0; i < s.param_names_.size(); i++ ) {
        out << s.param_names_[i];
        if ( (i+1) < s.param_names_.size() )
            out << ",";
    }
    out << ")";
    return out;
}


// Symbol
Symbol::Symbol(std::string line):
        name_(get_symbol_name_from_string(line)), 
        param_names_(get_symbol_param_names_from_string(line))
{
}

bool Symbol::has_name(std::string name)
{
        if (name_.compare(name) == 0) {
                ROS_DEBUG_STREAM("Name comparison is true: " << name_ );
                return true;
        }
        else
                return false;
}

bool Symbol::has_param_name(std::string param)
{
        bool result = false;
        for ( size_t i = 0; i < param_names_.size(); i++ ) {
                if (param_names_[i] == param) {
                        result = true;
                }
        }
        return result;
}

bool Symbol::has_param_names_in(std::vector<std::string> params)
{
        bool result = true;
        for ( size_t i = 0; i < param_names_.size(); i++ ) {
                bool present = false;
                for (size_t j = 0; j < params.size(); j++) {
                        if (has_name("traversed2") && (i == 1)) { // TODO ugly
                                present = true;
                        }
                        if (param_names_[i] == params[j]) {
                                present = true;
                        }
                }
                if (!present) {
                        result = false;
                }
        }
        return result;
}

bool Symbol::exists()
{
        return (name_.compare("") != 0);
}


Symbol get_symbol_from_string(std::string line)
{
//     line = line.substr(line.find_first_not_of(" \t"));
    line = trim(line);
    Symbol symbol(get_symbol_name_from_string(line), get_symbol_param_names_from_string(line));
    return symbol;
}

std::string get_symbol_name_from_string(std::string line)
{
    std::stringstream ss(line);
    std::string item;
    
    if(std::getline(ss, item, '(')) {
        //std::cout << "Symbol name: " << item << std::endl;
    }
    
    return item;
}

std::vector< std::string > get_symbol_param_names_from_string(std::string line)
{
    std::stringstream ss(line);
    std::string item;
    std::vector< std::string> param_names;
    
    // get string between ()
    std::getline(ss, item, '(');
    std::getline(ss, item, ')');
    ss.str(item);
    
    char separator = choose_variable_separator(item);
    while ( std::getline(ss, item, separator) ) {
        // remove spaces and empty strings
        item.erase(remove_if(item.begin(), item.end(), isspace), item.end());
        if (item.compare("") != 0) {
            param_names.push_back(item);
            //std::cout << "Param names: " << item << std::endl;
        }
    }
    
    return param_names;
}