stringdatastructures.cpp

Go to the documentation of this file.

/*****************************************************************************
    NumeRe: Framework fuer Numerische Rechnungen
    Copyright (C) 2022  Erik Haenel et al.
 
    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.
 
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
 
    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
******************************************************************************/
 
#include "stringdatastructures.hpp"
#include "../../kernel.hpp"
 
 
StringView StringVector::makePureString(StringView sStr)
{
    if (sStr.length() && sStr.front() == '"')
        return sStr.subview(1, sStr.length()-2);
 
    return sStr;
}
 
 
std::string StringVector::makeLocalString(const std::string& sStr)
{
    if (sStr.front() == '"')
        return "\"" + toInternalString(sStr) + "\"";
 
    return sStr;
}
 
 
StringView StringVector::getVectorized(size_t i) const
{
    if (size() == 1)
        return makePureString(front());
    else if (i < size())
        return makePureString(at(i));
 
    return StringView(m_sDUMMY);
}
 
 
mu::value_type StringVector::getNumericalVectorized(size_t i) const
{
    if (i >= size() && size() > 1)
        return NAN;
 
    if (is_string(i))
        return NAN;
 
    if (getVectorized(i) == "true")
        return 1.0;
 
    if (getVectorized(i) == "false")
        return 0.0;
 
    // Use the numerical parser here
    mu::Parser& _parser = NumeReKernel::getInstance()->getParser();
    _parser.SetExpr(getVectorized(i));
    return _parser.Eval();
}
 
 
bool StringVector::getBooleanVectorized(size_t i) const
{
    if (i >= size() && size() > 1)
        return false;
 
    if (is_string(i))
        return getVectorized(i).length() > 0;
 
    if (getVectorized(i) == "true")
        return true;
 
    if (getVectorized(i) == "false")
        return false;
 
    // Use the numerical parser here
    mu::Parser& _parser = NumeReKernel::getInstance()->getParser();
    _parser.SetExpr(getVectorized(i));
    return _parser.Eval() != 0.0;
}
 
 
void StringVector::assign(const StringVector& sVect)
{
    std::vector<std::string>::assign(sVect.begin(), sVect.end());
}
 
 
void StringVector::assign(const std::vector<bool>& vect)
{
    resize(vect.size());
 
    for (size_t i = 0; i < vect.size(); i++)
    {
        std::vector<std::string>::operator[](i) = vect[i] ? "true" : "false";
    }
}
 
 
StringVector::StringVector() : std::vector<std::string>()
{ }
 
 
StringVector::StringVector(const std::vector<std::string>& vect) : std::vector<std::string>(vect)
{ }
 
 
StringVector::StringVector(const std::string& sStr) : std::vector<std::string>(1, sStr)
{ }
 
 
StringVector::StringVector(const char* sStr) : std::vector<std::string>(1, std::string(sStr))
{ }
 
 
StringVector::StringVector(bool val) : std::vector<std::string>(1, toString(val))
{ }
 
 
StringVector::StringVector(const StringVector& vect) : std::vector<std::string>()
{
    assign(vect);
}
 
 
StringVector::StringVector(const std::vector<bool>& vect) : std::vector<std::string>()
{
    assign(vect);
}
 
 
StringVector::StringVector(size_t n, const std::string& sStr) : std::vector<std::string>(n, sStr)
{ }
 
 
StringVector StringVector::empty_string()
{
    return convert_internal("");
}
 
 
StringVector StringVector::convert_internal(const std::string& sInternal)
{
    return StringVector("\"" + sInternal + "\"");
}
 
 
StringVector StringVector::convert_literal(const std::string& sLiteral)
{
    return StringVector(makeLocalString(sLiteral));
}
 
 
StringVector& StringVector::operator=(const StringVector& sVect)
{
    assign(sVect);
    return *this;
}
 
 
StringVector& StringVector::operator=(const std::vector<bool>& vect)
{
    assign(vect);
    return *this;
}
 
 
void StringVector::push_back(const std::string& sStr)
{
    std::vector<std::string>::push_back("\"" + sStr + "\"");
}
 
 
void StringVector::push_back(const char* sStr)
{
    std::vector<std::string>::push_back("\"" + std::string(sStr) + "\"");
}
 
 
void StringVector::push_back(const mu::value_type& vVal)
{
    std::vector<std::string>::push_back(toString(vVal, 20));
}
 
 
void StringVector::push_back(size_t nVal)
{
    std::vector<std::string>::push_back(toString(nVal));
}
 
 
void StringVector::push_back(int nVal)
{
    std::vector<std::string>::push_back(toString(nVal));
}
 
 
void StringVector::push_back(long long int nVal)
{
    std::vector<std::string>::push_back(toString(nVal));
}
 
 
void StringVector::push_back(bool nVal)
{
    std::vector<std::string>::push_back(toString(nVal));
}
 
 
void StringVector::push_generic(const std::string& sStr)
{
    std::vector<std::string>::push_back(makeLocalString(sStr));
}
 
 
bool StringVector::is_string(size_t i) const
{
    if (i < size())
        return at(i).front() == '"';
    else if (size() == 1)
        return front().front() == '"';
 
    return false;
}
 
 
void StringVector::convert_to_string(size_t i, size_t minChars)
{
    if (i < size() && !is_string(i))
    {
        size_t len = std::vector<std::string>::operator[](i).length();
        std::vector<std::string>::operator[](i) = "\"" + (len < minChars ? std::string(minChars-len, '0') : "") + std::vector<std::string>::operator[](i) + "\"";
    }
}
 
 
StringView StringVector::operator[](size_t i) const
{
    if (i < size())
        return makePureString(at(i));
 
    return StringView(m_sDUMMY);
}
 
 
StringArg StringVector::getArg(size_t i) const
{
    if (i < size())
        return StringArg(at(i));
    else if (size() == 1)
        return StringArg(at(0));
 
    return StringArg();
}
 
 
std::string StringVector::getMasked(size_t i) const
{
    if (i < size())// && is_string(i))
    {
        const char NEWSTRING = (char)23;
        std::string sRet = at(i);
 
        // Go through the complete string without the first
        // and the last character
        for (size_t i = 1; i < sRet.length() - 1; i++)
        {
            // Escape backslashes
            if (sRet[i] == '\\' && sRet[i + 1] != '"' && sRet[i + 1] != ' ')
            {
                sRet.insert(i + 1, " ");
                i++;
            }
 
            // Escape quotation marks
            if (sRet[i] == '"' && sRet[i - 1] != '\\' && sRet[i + 1] != NEWSTRING && sRet.find('"', i + 1) != std::string::npos)
            {
                sRet.insert(i, "\\");
                i++;
            }
 
            // Replace the new string character with a comma
            if (sRet[i] == NEWSTRING)
            {
                sRet[i] = ',';
                if (sRet[i + 1] == '"')
                    i++;
            }
        }
 
        return sRet;
    }
    //else if (i < size())
    //    return at(i);
 
    return m_sDUMMY;
}
 
 
std::string& StringVector::getRef(size_t i)
{
    if (i < size())
        return std::vector<std::string>::operator[](i);
 
    throw std::out_of_range("Requested element " + toString(i) + ", which is greater than this->size().");
}
 
 
std::vector<bool> StringVector::operator==(const StringVector& sVect) const
{
    std::vector<bool> vRet(std::max(size(), sVect.size()));
 
    for (size_t i = 0; i < vRet.size(); i++)
    {
        if (is_string(i) != sVect.is_string(i))
            vRet[i] = false;
        else if (is_string(i))
            vRet[i] = getVectorized(i) == sVect.getVectorized(i);
        else
            vRet[i] = getNumericalVectorized(i) == sVect.getNumericalVectorized(i);
    }
 
    return vRet;
}
 
 
std::vector<bool> StringVector::operator!=(const StringVector& sVect) const
{
    std::vector<bool> vRet(std::max(size(), sVect.size()));
 
    for (size_t i = 0; i < vRet.size(); i++)
    {
        if (is_string(i) != sVect.is_string(i))
            vRet[i] = true;
        else if (is_string(i))
            vRet[i] = getVectorized(i) != sVect.getVectorized(i);
        else
            vRet[i] = getNumericalVectorized(i) != sVect.getNumericalVectorized(i);
    }
 
    return vRet;
}
 
 
std::vector<bool> StringVector::operator<(const StringVector& sVect) const
{
    std::vector<bool> vRet(std::max(size(), sVect.size()));
 
    for (size_t i = 0; i < vRet.size(); i++)
    {
        if (is_string(i) != sVect.is_string(i))
            vRet[i] = false;
        else if (is_string(i))
            vRet[i] = getVectorized(i) < sVect.getVectorized(i);
        else
            vRet[i] = getNumericalVectorized(i).real() < sVect.getNumericalVectorized(i).real();
    }
 
    return vRet;
}
 
 
std::vector<bool> StringVector::operator<=(const StringVector& sVect) const
{
    std::vector<bool> vRet(std::max(size(), sVect.size()));
 
    for (size_t i = 0; i < vRet.size(); i++)
    {
        if (is_string(i) != sVect.is_string(i))
            vRet[i] = false;
        else if (is_string(i))
            vRet[i] = getVectorized(i) <= sVect.getVectorized(i);
        else
            vRet[i] = getNumericalVectorized(i).real() <= sVect.getNumericalVectorized(i).real();
    }
 
    return vRet;
}
 
 
std::vector<bool> StringVector::operator>(const StringVector& sVect) const
{
    std::vector<bool> vRet(std::max(size(), sVect.size()));
 
    for (size_t i = 0; i < vRet.size(); i++)
    {
        if (is_string(i) != sVect.is_string(i))
            vRet[i] = false;
        else if (is_string(i))
            vRet[i] = getVectorized(i) > sVect.getVectorized(i);
        else
            vRet[i] = getNumericalVectorized(i).real() > sVect.getNumericalVectorized(i).real();
    }
 
    return vRet;
}
 
 
std::vector<bool> StringVector::operator>=(const StringVector& sVect) const
{
    std::vector<bool> vRet(std::max(size(), sVect.size()));
 
    for (size_t i = 0; i < vRet.size(); i++)
    {
        if (is_string(i) != sVect.is_string(i))
            vRet[i] = false;
        else if (is_string(i))
            vRet[i] = getVectorized(i) >= sVect.getVectorized(i);
        else
            vRet[i] = getNumericalVectorized(i).real() >= sVect.getNumericalVectorized(i).real();
    }
 
    return vRet;
}
 
 
std::vector<bool> StringVector::and_f(const StringVector& sVect) const
{
    std::vector<bool> vRet(std::max(size(), sVect.size()));
 
    for (size_t i = 0; i < vRet.size(); i++)
    {
        vRet[i] = getBooleanVectorized(i) && sVect.getBooleanVectorized(i);
    }
 
    return vRet;
}
 
 
std::vector<bool> StringVector::or_f(const StringVector& sVect) const
{
    std::vector<bool> vRet(std::max(size(), sVect.size()));
 
    for (size_t i = 0; i < vRet.size(); i++)
    {
        vRet[i] = getBooleanVectorized(i) || sVect.getBooleanVectorized(i);
    }
 
    return vRet;
}
 
 
std::vector<bool> StringVector::xor_f(const StringVector& sVect) const
{
    std::vector<bool> vRet(std::max(size(), sVect.size()));
 
    for (size_t i = 0; i < vRet.size(); i++)
    {
        vRet[i] = getBooleanVectorized(i) xor sVect.getBooleanVectorized(i);
    }
 
    return vRet;
}
 
 
StringVector StringVector::operator+(const StringVector& sVect) const
{
    StringVector vRet(std::max(size(), sVect.size()));
 
    for (size_t i = 0; i < vRet.size(); i++)
    {
        if (is_string(i) && sVect.is_string(i))
            vRet.getRef(i) = "\"" + (getVectorized(i) + sVect.getVectorized(i)) + "\"";
        else
            vRet.getRef(i) = getVectorized(i) + std::string("+") + sVect.getVectorized(i).to_string();
    }
 
    return vRet;
}
 
 
StringVector& StringVector::operator+=(const StringVector& sVect)
{
    assign(operator+(sVect));
    return *this;
}
 
 
StringVector StringVector::operator+(const std::string& sLiteral) const
{
    return operator+(StringVector(sLiteral));
}
 
 
StringVector& StringVector::operator+=(const std::string& sLiteral)
{
    assign(operator+(StringVector(sLiteral)));
    return *this;
}
 
 
StringVector& StringVector::evalIfElse(const StringVector& sLogicals, const StringVector& sIfBranch, const StringVector& sElseBranch)
{
    // Only one logical result?
    if (sLogicals.size() == 1)
    {
        if (sLogicals.getBooleanVectorized(0))
            assign(sIfBranch);
        else
            assign(sElseBranch);
 
        return *this;
    }
 
    StringVector vRet(std::max({sLogicals.size(), sIfBranch.size(), sElseBranch.size()}));
 
    for (size_t i = 0; i < vRet.size(); i++)
    {
        if (sLogicals.getBooleanVectorized(i))
            vRet.getRef(i) = sIfBranch.getArg(i).getRef();
        else
            vRet.getRef(i) = sElseBranch.getArg(i).getRef();
    }
 
    assign(vRet);
    return *this;
}