stringtools.cpp

Go to the documentation of this file.

/*****************************************************************************
    NumeRe: Framework fuer Numerische Rechnungen
    Copyright (C) 2021  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 "stringtools.hpp"
#include "../settings.hpp"
#include "../structures.hpp"
#include "fast_float/fast_float.h"
 
#include <cstring>
#include <sstream>
#include <iomanip>
 
// Forward declarations
std::string getNextArgument(std::string& sArgList, bool bCut);
double intPower(double, int);
 
// toString function implementations
// There's an overwrite for mostly every variable type
//
std::string toString(int nNumber, const Settings& _option)
{
    return toString((double)nNumber, _option);  // Unnoetig das nochmal zu schreiben. Rufen wir die andere Funktion mit einer expliziten Konvertierung auf
}
 
 
std::string toString(double dNumber, const Settings& _option)
{
    return toString(dNumber, _option.getPrecision());   // Auf den eigentlichen string wird dann mit der Methode ostringstream::str() zugegriffen
}
 
 
std::string toString(double dNumber, int nPrecision)
{
    std::ostringstream Temp;
    Temp.precision(nPrecision);
    Temp << dNumber;
    return Temp.str();
}
 
std::string toString(const std::complex<double>& dNumber, int nPrecision)
{
    if (std::isnan(dNumber.real()) && std::isnan(dNumber.imag()))
        return "nan";
 
    std::ostringstream Temp;
    Temp.precision(std::rint(nPrecision / (dNumber.real() != 0.0 && dNumber.imag() != 0.0 && !std::isnan(dNumber.imag()) ? 2 : 1)));
 
    if (dNumber.real() || !dNumber.imag())
        Temp << dNumber.real();
 
    if (dNumber.imag())
    {
        if ((dNumber.imag() > 0.0 || std::isnan(dNumber.imag())) && dNumber.real() != 0.0)
            Temp << "+";
 
        Temp << dNumber.imag() << (std::isnan(dNumber.imag()) || std::isinf(dNumber.imag()) ? " i" : "i");
    }
 
    return Temp.str();
}
 
 
std::string toString(int nNumber)
{
    return toString((long long int)nNumber);
}
 
 
std::string toString(size_t nNumber)
{
    return toString((long long int)nNumber);
}
 
 
std::string toString(__time64_t tTime, int timeStampFlags)
{
    tm* ltm = _localtime64(&tTime);
 
    if (!ltm)
        return "";
 
    time_zone tz = getCurrentTimeZone();
 
    std::ostringstream timeStream;
 
    if (!(timeStampFlags & GET_ONLY_TIME))
    {
        timeStream << 1900+ltm->tm_year << "-"; //YYYY-
        timeStream << std::setfill('0') << std::setw(2) << ltm->tm_mon + 1 << "-"; // MM-
        timeStream << std::setfill('0') << std::setw(2) << ltm->tm_mday;    // DD
 
        if (timeStampFlags & GET_AS_TIMESTAMP)
            timeStream << "_";
        else
        {
            timeStream << ", "; // Komma im regulaeren Datum
 
            if (timeStampFlags & GET_WITH_TEXT)
            {
                if (_lang.get("TOOLS_TIMESTAMP_AT") == "TOOLS_TIMESTAMP_AT")
                    timeStream << "at ";
                else
                    timeStream << _lang.get("TOOLS_TIMESTAMP_AT") << " ";
            }
        }
    }
 
    if (timeStampFlags & GET_ONLY_TIME)
        timeStream << std::setfill('0') << std::setw(2) << ltm->tm_hour + tz.Bias.count()/60;   // hh
    else
        timeStream << std::setfill('0') << std::setw(2) << ltm->tm_hour;    // hh
 
    if (!(timeStampFlags & GET_AS_TIMESTAMP))
        timeStream << ":";      // ':' im regulaeren Datum
 
    timeStream << std::setfill('0') << std::setw(2) << ltm->tm_min; // mm
 
    if (!(timeStampFlags & GET_AS_TIMESTAMP))
        timeStream << ":";
 
    timeStream << std::setfill('0') << std::setw(2) << ltm->tm_sec; // ss
 
    return timeStream.str();
}
 
 
std::string toString(sys_time_point tp, int timeStampFlags)
{
    time_stamp ltm = getTimeStampFromTimePoint(tp);
    time_zone tz = getCurrentTimeZone();
    std::ostringstream timeStream;
 
    if (!(timeStampFlags & GET_ONLY_TIME))
    {
        timeStream << ltm.m_ymd.year() << "-"; //YYYY-
        timeStream << std::setfill('0') << std::setw(2) << unsigned(ltm.m_ymd.month()) << "-"; // MM-
        timeStream << ltm.m_ymd.day();  // DD
 
        if (timeStampFlags & GET_AS_TIMESTAMP)
            timeStream << "_";
        else
        {
            timeStream << ", "; // Komma im regulaeren Datum
 
            if (timeStampFlags & GET_WITH_TEXT)
            {
                if (_lang.get("TOOLS_TIMESTAMP_AT") == "TOOLS_TIMESTAMP_AT")
                    timeStream << "at ";
                else
                    timeStream << _lang.get("TOOLS_TIMESTAMP_AT") << " ";
            }
        }
    }
 
    if (timeStampFlags & GET_ONLY_TIME)
        timeStream << std::setfill('0') << std::setw(2) << ltm.m_hours.count() + (tz.Bias + tz.DayLightBias).count()/60;    // hh
    else
        timeStream << std::setfill('0') << std::setw(2) << ltm.m_hours.count();     // hh
 
    if (!(timeStampFlags & GET_AS_TIMESTAMP))
        timeStream << ":";      // ':' im regulaeren Datum
 
    timeStream << std::setfill('0') << std::setw(2) << ltm.m_minutes.count();   // mm
 
    if (!(timeStampFlags & GET_AS_TIMESTAMP))
        timeStream << ":";
 
    timeStream << std::setfill('0') << std::setw(2) << ltm.m_seconds.count();   // ss
 
    if (!(timeStampFlags & GET_AS_TIMESTAMP))
    {
        if (timeStampFlags & (GET_MILLISECONDS | GET_FULL_PRECISION)
            || ltm.m_millisecs.count())
            timeStream << "." << std::setfill('0') << std::setw(3) << ltm.m_millisecs.count();
 
        if (timeStampFlags & GET_FULL_PRECISION)
            timeStream << std::setfill('0') << std::setw(3) << ltm.m_microsecs.count();
    }
 
    return timeStream.str();
}
 
 
std::string toString(long long int nNumber)
{
    std::ostringstream Temp;
    Temp << nNumber;
    return Temp.str();
}
 
 
std::string toString(bool bBoolean)
{
    if (bBoolean)
        return "true";
    else
        return "false";
}
 
 
std::string toCmdString(double dNumber)
{
    std::ostringstream Temp;
    Temp.precision(20);
    Temp << dNumber;
    return Temp.str();
}
 
 
std::string toCmdString(const std::complex<double>& dNumber)
{
    return toString(dNumber, 20);
}
 
 
std::string toHexString(int nNumber)
{
    std::ostringstream Temp;
    Temp << std::hex << nNumber;
    return "0x" + Temp.str();
}
 
 
std::vector<std::string> toStrVector(std::string sString)
{
    std::vector<std::string> vVector;
 
    if (sString == "{}" || !sString.length())
        return vVector;
 
    if (sString.front() == '{' && sString.back() == '}')
    {
        sString.erase(0, 1);
        sString.pop_back();
    }
 
    while (sString.length())
    {
        vVector.push_back(getNextArgument(sString, true));
    }
 
    return vVector;
}
 
 
std::vector<int> toIntVector(std::string sString)
{
    std::vector<int> vVector;
    std::vector<std::string> vStrVect = toStrVector(sString);
 
    if (!vStrVect.size())
        return vVector;
 
    for (const auto& s : vStrVect)
    {
        vVector.push_back(StrToInt(s));
    }
 
    return vVector;
}
 
 
std::string condenseText(const std::string& sText)
{
    std::string sReturn = sText;
    static std::string sToErase = " AaEeIiOoUuÄäÖöÜüßYy";
    for (unsigned int i = 0; i < sReturn.length(); i++)
    {
        if (sToErase.find(sReturn[i]) != std::string::npos
                || sReturn[i] == 142
                || sReturn[i] == 132
                || sReturn[i] == 153
                || sReturn[i] == 148
                || sReturn[i] == 154
                || sReturn[i] == 129
                || sReturn[i] == 225)
        {
            sReturn.erase(i, 1);
            i--;
        }
    }
    return sReturn;
}
 
 
std::string truncString(const std::string& sText, size_t nMaxChars)
{
    if (sText.length() <= nMaxChars)
        return sText;
 
    return sText.substr(0, nMaxChars-3) + "...";
}
 
 
void StripSpaces(std::string& sToStrip)
{
    if (!sToStrip.length())
        return;
 
    sToStrip.erase(0, sToStrip.find_first_not_of(" \t"));
 
    if (sToStrip.length() && (sToStrip.back() == ' ' || sToStrip.back() == '\t'))
        sToStrip.erase(sToStrip.find_last_not_of(" \t") + 1);
}
 
 
int StrToInt(const std::string& sString)
{
    return atoi(sString.c_str());
}
 
 
double StrToDb(const std::string& sString)
{
    return atof(sString.c_str());
}
 
 
double StrToLogical(const std::string& sString)
{
    if (toLowerCase(sString) == "true" || sString == "1")
        return 1.0;
    else if (toLowerCase(sString) == "false" || sString == "0")
        return 0.0;
 
    return StrToCmplx(sString).real();
}
 
 
std::complex<double> StrToCmplx(const std::string& sString)
{
    double re, im;
 
    //if (!isConvertible(sString, CONVTYPE_VALUE) || sString == "---") <-- Should be obsolete due to the fact that it should be checked in advance
    if (sString == "---"
        || (sString.length() < 4 && (toLowerCase(sString) == "na" || toLowerCase(sString) == "n/a")))
        return NAN;
 
    const char* pStart = sString.c_str();
    const char* pEnd = pStart + sString.length();
    int oprt = 0;
 
    // check whether next char is 'i' and advance
    // over all whitespaces
    while (pStart < pEnd && (*pStart == ' ' || *pStart == '+'))
        pStart++;
 
    if (pStart >= pEnd)
        return NAN; // End of Input
 
    // read 1st value
    fast_float::from_chars_result res = fast_float::from_chars(pStart, pEnd, re);
 
    // Error code might imply "i" or "-i"
    if (res.ec == std::errc::invalid_argument)
    {
        // Check, if there are other characters
        while (res.ptr < pEnd && (*res.ptr == '-' || *res.ptr == ' ' || tolower(*res.ptr) == 'i'))
            res.ptr++;
 
        // Did we find any? If no, it is +/-i
        if (res.ptr >= pEnd)
            return std::complex<double>(0, *pStart == '-' ? -1 : 1);
 
        // We did find other character sequences
        return NAN;
    }
 
    // check whether next char is 'i' and advance
    // over all whitespaces
    while (res.ptr < pEnd && *res.ptr == ' ')
        res.ptr++;
 
    if (res.ptr >= pEnd)
        return re; // End of Input
 
    if (*res.ptr == '-' || *res.ptr == '+')
    {
        oprt = *res.ptr == '-' ? -1 : 1;
        res.ptr++;
    }
 
    // check whether next char is 'i' and advance
    // over all whitespaces
    while (res.ptr < pEnd && *res.ptr == ' ')
        res.ptr++;
 
    if (res.ptr >= pEnd)
        return re; // End of Input
 
    // Is it the actual imaginary value?
    if (tolower(*res.ptr) == 'i'
        && oprt
        && (res.ptr+1 >= pEnd || tolower(*(res.ptr+1)) != 'n'))
        return std::complex<double>(re, oprt);
 
    if ((tolower(*res.ptr) == 'i' && (res.ptr+1 >= pEnd || tolower(*(res.ptr+1)) != 'n')) || *res.ptr == '*')
        return std::complex<double>(0.0, re);
 
    // read 2nd value
    res = fast_float::from_chars(res.ptr, pEnd, im);
 
    // Error
    if (res.ec == std::errc::invalid_argument)
        return re;
 
    // check whether next char is 'i' and advance
    // over all whitespaces
    while (res.ptr < pEnd && *res.ptr == ' ')
        res.ptr++;
 
    if (tolower(*res.ptr) != 'i' && *res.ptr != '*')
    { // ERROR or premature end of input
        return re;
    }
 
    return std::complex<double>(re, oprt*im);
}
 
 
sys_time_point StrToTime(const std::string& sString)
{
    int format = detectTimeDateFormat(sString);
 
    if (format == TD_NONE)
        return sys_time_point();
 
    // Try to detect dates
    size_t pos = sString.find_first_not_of(" \t");
 
    time_stamp timeStruct = getTimeStampFromTimePoint(sys_time_now());
    timeStruct.m_hours = std::chrono::hours::zero();
    timeStruct.m_minutes = std::chrono::minutes::zero();
    timeStruct.m_seconds = std::chrono::seconds::zero();
    timeStruct.m_millisecs = std::chrono::milliseconds::zero();
    timeStruct.m_microsecs = std::chrono::microseconds::zero();
 
    const char* DIGITS = "0123456789";
 
    // Contains time
    if (format & TD_HHMM || format & TD_HHMMSS)
    {
        std::vector<std::string> toks = split(sString, ':');
 
        bool isFirst = sString.find(':') < 3 + pos;
 
        for (size_t i = 0; i < toks.size(); i++)
        {
            // Catch milliseconds written as s.i or ss.iii
            StripSpaces(toks[i]);
 
            if (i == 2 && toks[i].length() >= 3 && (toks[i][1] == '.' || toks[i][2] == '.'))
            {
                size_t dot = toks[i].find('.');
                toks.insert(toks.begin()+i+1, toks[i].substr(dot+1));
                toks[i].erase(dot);
            }
 
            // Remove leading of trailing non-time characters
            if (toks[i].find_first_not_of(DIGITS) != std::string::npos)
            {
                if ((isFirst && i+1 != toks.size()) || (!isFirst && i))
                    break;
 
                if (isFirst)
                    toks[i].erase(toks[i].find_first_not_of(DIGITS));
                else
                    toks[i].erase(0, toks[i].find_last_not_of(DIGITS)+1);
            }
 
            if (!i)
                timeStruct.m_hours = std::chrono::hours(StrToInt(toks[i]));
            else if (i == 1)
                timeStruct.m_minutes = std::chrono::minutes(StrToInt(toks[i]));
            else if (i == 2 && format & TD_HHMMSS)
                timeStruct.m_seconds = std::chrono::seconds(StrToInt(toks[i]));
            else if (i == 3 && format & TD_HHMMSS)
                timeStruct.m_millisecs = std::chrono::milliseconds(int(StrToInt(toks[i])*intPower(10.0, 3-toks[i].length()))); // scaling due to possible missing trailing zeros
        }
    }
 
    // Contains DD.MM.YY or DD/MM/YYYY
    if (format & TD_DDMM || format & TD_DDMMYY)
    {
        std::vector<std::string> toks = split(sString, format & TD_SEP_SLASH ? '/' : '.');
        date::year y(timeStruct.m_ymd.year());
        date::month m(0);
        date::day d(0);
 
        bool isFirst = sString.find(format & TD_SEP_SLASH ? '/' : '.') < 3 + pos;
 
        for (size_t i = 0; i < toks.size(); i++)
        {
            StripSpaces(toks[i]);
 
            // Remove leading or trailing non-date chars
            if (toks[i].find_first_not_of(DIGITS) != std::string::npos)
            {
                // Obscure logic needed because msecs are also
                // separated by a dot
                if ((isFirst && i < bool(format & TD_DDMMYY) + 1) || (!isFirst && i))
                    break;
 
                if (isFirst)
                    toks[i].erase(toks[i].find_first_not_of(DIGITS));
                else
                    toks[i].erase(0, toks[i].find_last_not_of(DIGITS)+1);
            }
 
            if (!i)
                d = date::day(StrToInt(toks[i]));
            else if (i == 1)
                m = date::month(StrToInt(toks[i]));
            else if (i == 2 && format & TD_DDMMYY)
            {
                if (toks[i].length() > 2)
                    y = date::year(StrToInt(toks[i]));
                else
                    y = date::year(StrToInt(toks[i]) + 2000);
            }
        }
 
        timeStruct.m_ymd = date::year_month_day(y,m,d);
    }
 
    // Contains YY-MM-DD or YY/MM/DD
    if (format & TD_YYMMDD)
    {
        std::vector<std::string> toks;
        bool isFirst;
        date::year y(0);
        date::month m(0);
        date::day d(0);
 
        if (format & TD_SEP_MINUS)
        {
            toks = split(sString, '-');
            isFirst = sString.find('-') < 5 + pos;
        }
        else
        {
            toks = split(sString, '/');
            isFirst = sString.find('/') < 5 + pos;
        }
 
        for (size_t i = 0; i < toks.size(); i++)
        {
            StripSpaces(toks[i]);
 
            // Remove leading or trailing non-date chars
            if (toks[i].find_first_not_of(DIGITS) != std::string::npos)
            {
                if ((isFirst && i+1 != toks.size()) || (!isFirst && i))
                    break;
 
                if (isFirst)
                    toks[i].erase(toks[i].find_first_not_of(DIGITS));
                else
                    toks[i].erase(0, toks[i].find_last_not_of(DIGITS)+1);
            }
 
            if (!i)
            {
                if (toks[i].length() > 2)
                    y = date::year(StrToInt(toks[i]));
                else
                    y = date::year(StrToInt(toks[i]) + 2000);
            }
            else if (i == 1)
                m = date::month(StrToInt(toks[i]));
            else if (i == 2)
                d = date::day(StrToInt(toks[i]));
        }
 
        timeStruct.m_ymd = date::year_month_day(y,m,d);
    }
 
    return getTimePointFromTimeStamp(timeStruct);
}
 
 
size_t versionToInt(std::string sVersion)
{
    size_t nVOffset = 0;
 
    if (sVersion.front() == 'v')
        nVOffset = 1;
 
    replaceAll(sVersion, ".", "");
    return StrToInt(sVersion.substr(nVOffset));
}
 
 
std::string intToVersion(size_t nVersionDigits)
{
    std::string _sVer = toString(nVersionDigits);
 
    // Prepend zeroes, if the length is shorter than
    // three
    if (_sVer.length() < 3)
        _sVer.insert(0, 3-_sVer.length(), '0');
 
    // Convert the version string into the M.m.b format
    for (size_t n = 1; n < _sVer.length(); n++)
    {
        if (n % 2)
            _sVer.insert(n, 1, '.');
    }
 
    return _sVer;
}
 
 
std::string toInternalString(std::string sStr)
{
    if (sStr.front() == '"' && sStr.back() == '"')
        sStr = sStr.substr(1, sStr.length()-2);
 
    for (size_t i = 0; i < sStr.length(); i++)
    {
        if (sStr.compare(i, 2, "\\t") == 0
            && sStr.compare(i, 4, "\\tau") != 0
            && sStr.compare(i, 6, "\\theta") != 0
            && sStr.compare(i, 6, "\\times") != 0)
            sStr.replace(i, 2, "\t");
 
        if (sStr.compare(i, 2, "\\n") == 0
            && sStr.compare(i, 3, "\\nu") != 0
            && sStr.compare(i, 4, "\\neq") != 0)
            sStr.replace(i, 2, "\n");
 
        if (sStr.compare(i, 2, "\\\"") == 0)
            sStr.replace(i, 2, "\"");
 
        if (sStr.compare(i, 2, "\\ ") == 0)
            sStr.replace(i, 2, "\\");
    }
 
    return sStr;
}
 
 
std::string toExternalString(std::string sStr)
{
    replaceAll(sStr, "\"", "\\\"");
    return "\"" + sStr + "\"";
}
 
 
std::string toLowerCase(const std::string& sUpperCase)
{
    std::string sLowerCase = sUpperCase;
    for (unsigned int i = 0; i < sLowerCase.length(); i++)
    {
        // --> Laufe alle Zeichen im String ab und pruefe, ob ihr CHAR-Wert zwischen A und Z liegt
        if ((int)sLowerCase[i] >= (int)'A' && (int)sLowerCase[i] <= (int)'Z')
        {
            // --> Falls ja, verschiebe den CHAR-Wert um die Differenz aus A und a <--
            sLowerCase[i] = (char)((int)sLowerCase[i] + ((int)'a' - (int)'A'));
        }
        if (sLowerCase[i] == 'Ä')
            sLowerCase[i] = 'ä';
        else if (sLowerCase[i] == 'Ö')
            sLowerCase[i] = 'ö';
        else if (sLowerCase[i] == 'Ü')
            sLowerCase[i] = 'ü';
        else if (sLowerCase[i] == (char)142)
            sLowerCase[i] = (char)132;
        else if (sLowerCase[i] == (char)153)
            sLowerCase[i] = (char)148;
        else if (sLowerCase[i] == (char)154)
            sLowerCase[i] = (char)129;
    }
    return sLowerCase;
}
 
 
std::string toUpperCase(const std::string& sLowerCase)
{
    std::string sUpperCase = sLowerCase;
    for (unsigned int i = 0; i < sUpperCase.length(); i++)
    {
        // Handle escape characters like linebreaks or tabulator characters
        if ((!i || sUpperCase[i - 1] != '\\') && (sUpperCase.substr(i, 2) == "\\n" || sUpperCase.substr(i, 2) == "\\t"))
        {
            i++;
            continue;
        }
        else if (sUpperCase.substr(i, 2) == "\\n")
        {
            sUpperCase.replace(i, 2, "N");
        }
        else if (sUpperCase.substr(i, 2) == "\\t")
        {
            sUpperCase.replace(i, 2, "T");
        }
        // --> Laufe alle Zeichen im String ab und pruefe, ob ihr CHAR-Wert zwischen a und z liegt
        if ((int)sUpperCase[i] >= (int)'a' && (int)sLowerCase[i] <= (int)'z')
        {
            // --> Falls ja, verschiebe den CHAR-Wert um die Differenz aus a und A <--
            sUpperCase[i] = (char)((int)sUpperCase[i] + ((int)'A' - (int)'a'));
        }
        if (sUpperCase[i] == 'ä')
            sUpperCase[i] = 'Ä';
        else if (sUpperCase[i] == 'ö')
            sUpperCase[i] = 'Ö';
        else if (sUpperCase[i] == 'ü')
            sUpperCase[i] = 'Ü';
        else if (sUpperCase[i] == (char)132)
            sUpperCase[i] = (char)142;
        else if (sUpperCase[i] == (char)148)
            sUpperCase[i] = (char)153;
        else if (sUpperCase[i] == (char)129)
            sUpperCase[i] = (char)154;
    }
    return sUpperCase;
}
 
 
static bool isDateTimePattern(const std::string& sStr, size_t pos)
{
    if (pos
        && isdigit(sStr[pos-1])
        && isdigit(sStr[pos+1])
        && ((pos+3 < sStr.length() && sStr[pos+3] == sStr[pos])
            || (pos+2 < sStr.length() && sStr[pos+2] == sStr[pos])
            || sStr[pos] == ':'
            || (sStr[pos] == '.' && pos > 6 && sStr[pos-2] == ':')))
        return true;
 
    return false;
}
 
 
bool isConvertible(const std::string& sStr, ConvertibleType type)
{
    if (type == CONVTYPE_VALUE)
    {
        // Apply the simplest heuristic: mostly every numerical valid character
        // and ignore characters, which cannot represent a value by themselves
        if (sStr.find_first_not_of(" 0123456789.,eianfEIANF+-*/\t") != std::string::npos
            || (sStr.find_first_not_of("+-* .,\teE") == std::string::npos && sStr.find("---") == std::string::npos))
            return false;
 
        // Eliminate invalid character positions
        if (tolower(sStr.front()) == 'e'
            || tolower(sStr.front()) == 'a'
            || tolower(sStr.front()) == 'f'
            || tolower(sStr.back()) == 'e')
            return false;
 
        // Try to detect dates
        return !isConvertible(sStr, CONVTYPE_DATE_TIME);
    }
    else if (type == CONVTYPE_LOGICAL)
    {
        // Apply the simplest heuristic: mostly every numerical valid character
        // and ignore characters, which cannot represent a value by themselves
        if (toLowerCase(sStr) == "true"
            || toLowerCase(sStr) == "false"
            || sStr == "0"
            || sStr == "1")
            return true;
 
        // Try to detect values
        return isConvertible(sStr, CONVTYPE_VALUE);
    }
    else if (type == CONVTYPE_DATE_TIME)
    {
        // Apply the simplest heuristic: only digits and separators
        // and ignore characters, which cannot represent a date by themselves
        if (sStr.find_first_not_of(" 0123456789,.:-/\tTZ") != std::string::npos
            || sStr.find_first_not_of(" \t,.:-/TZ") == std::string::npos)
            return false;
 
        // Try to detect dates
        size_t pos = sStr.find_first_not_of(" \t");
 
        if (sStr.length() >= pos+3 && isdigit(sStr[pos]))
        {
            for (size_t i = pos; i < sStr.length()-1; i++)
            {
                // Detects these candidates:
                // (YY)YY-MM-DD, DD.MM.YY(YY), (yy)yy-m-d, d.m.yy(yy),
                // d.m., dd.mm., (YY)YY/MM/DD, (YY)YY/M/D,
                // hh:mm:ss, h:mm:ss, h:mm, hh:mm
                // hh:mm:ss:iii, h:mm:ss:iii, hh:mm:ss.iii, h:mm:ss.iii
                // YYYY-MM-DDThh:mm:ss.iiiZ
                if (sStr[i] == '-' || sStr[i] == '.' || sStr[i] == '/' || sStr[i] == ':')
                {
                    if (isDateTimePattern(sStr, i))
                        return true;
 
                    return false;
                }
            }
        }
    }
 
    return false;
}
 
 
static int isDatePattern_US(const std::string& sStr, size_t i)
{
    // Surrounded by digits?
    if (!i || !isdigit(sStr[i-1]) || !isdigit(sStr[i+1]))
        return TD_NONE;
 
    // Detects these candidates:
    // YY-MM-DD, yy-m-d, YY/MM/DD, YY/M/D, DD/MM/YYYY, D/M/YY(YY)
    if ((i+3 < sStr.length() && sStr[i+3] == sStr[i])
        || (i+2 < sStr.length() && sStr[i+2] == sStr[i]))
    {
        // Special case for DD/MM/YYYY, D/M/YY(YY) (note that the year has more characters)
        if ((sStr[i+3] == '/' && i+6 < sStr.length() && isdigit(sStr[i+6]))
            || (sStr[i+2] == '/' && i+4 < sStr.length() && isdigit(sStr[i+4])))
            return TD_DDMMYY | TD_SEP_SLASH;
 
        return TD_YYMMDD | (sStr[i] == '-' ? TD_SEP_MINUS : TD_SEP_SLASH);
    }
 
    return TD_NONE;
}
 
 
static int isDatePattern_DE(const std::string& sStr, size_t i)
{
    // Surrounded by digits?
    if (!i || !isdigit(sStr[i-1]) || !isdigit(sStr[i+1]))
        return TD_NONE;
 
    // Detects these candidates:
    // DD.MM.YY, d.m.yy
    if ((i+4 < sStr.length() && sStr[i+3] == sStr[i] && isdigit(sStr[i+4]))
        || (i+3 < sStr.length() && sStr[i+2] == sStr[i] && isdigit(sStr[i+3])))
        return TD_DDMMYY | TD_SEP_DOT;
    // d.m., dd.mm.
    else if ((i+3 < sStr.length() && sStr[i+3] == sStr[i])
             || (i+2 < sStr.length() && sStr[i+2] == sStr[i]))
        return TD_DDMM | TD_SEP_DOT;
 
    return TD_NONE;
}
 
 
static int isTimePattern(const std::string& sStr, size_t i)
{
    // Surrounded by digits?
    if (!i || !isdigit(sStr[i-1]) || !isdigit(sStr[i+1]))
        return TD_NONE;
 
    // Detects these candidates:
    // hh:mm:ss, h:mm:ss, hh:mm:ss:iii, h:mm:ss:iii, hh:mm:ss.iii, h:mm:ss.iii
    if ((i+3 < sStr.length() && sStr[i+3] == sStr[i])
        || (i+2 < sStr.length() && sStr[i+2] == sStr[i]))
        return TD_HHMMSS | TD_SEP_COLON;
 
    // h:mm, hh:mm
    return TD_HHMM | TD_SEP_COLON;
}
 
 
int detectTimeDateFormat(const std::string& sStr)
{
    if (sStr.find_first_not_of(" 0123456789,.:-/\tTZ") != std::string::npos || sStr.find_first_not_of(" \t") == std::string::npos)
        return TD_NONE;
 
    // Try to detect dates
    size_t pos = sStr.find_first_not_of(" \t");
    int format = TD_NONE;
 
    if (sStr.length() >= pos+3 && isdigit(sStr[pos]))
    {
        for (size_t i = pos; i < sStr.length()-1; i++)
        {
            // Detects these candidates:
            // (YY)YY-MM-DD, (yy)yy-m-d, (YY)YY/MM/DD, (YY)YY/M/D, DD/MM/YYYY, D/M/YYYY
            if (sStr[i] == '-' || sStr[i] == '/')
                format |= isDatePattern_US(sStr, i);
            // DD.MM.YY(YY), d.m.yy(yy), d.m., dd.mm.
            else if (sStr[i] == '.')
                format |= isDatePattern_DE(sStr, i);
            // hh:mm:ss, h:mm:ss, h:mm, hh:mm
            // hh:mm:ss:iii, h:mm:ss:iii, hh:mm:ss.iii, h:mm:ss.iii
            else if (sStr[i] == ':')
                format |= isTimePattern(sStr, i);
        }
    }
 
    // If we have the dashed american theme and T and Z,
    // then we have a full UTC time stamp
    if (format & (TD_YYMMDD | TD_HHMMSS | TD_SEP_COLON | TD_SEP_MINUS)
        && sStr.find('T') != std::string::npos
        && sStr.find('Z') != std::string::npos)
        format |= TD_UTC;
 
    return format;
}
 
 
std::string wcstombs(const std::wstring& wStr)
{
    std::string sReturn;
 
    // provide a target character array
    char* cBuf = new char[wStr.length() * 2 + 1];
 
    // transform the wstring into the target array
    unsigned int nRet = wcstombs(cBuf, wStr.c_str(), wStr.length() * 2 + 1);
 
    // Write the zero character and copy the contents of the character
    // array to the target string
    if (nRet == wStr.length() * 2 + 1)
        cBuf[wStr.length() * 2] = '\0';
    if (nRet)
        sReturn = cBuf;
 
    // Clear the memory and return the string
    delete[] cBuf;
    return sReturn;
}
 
 
std::string toSystemCodePage(std::string sOutput)
{
    return sOutput;
}
 
 
std::string fromSystemCodePage(std::string sOutput)
{
    for (unsigned int i = 0; i < sOutput.length(); i++)
    {
        if (sOutput[i] == (char)142)
            sOutput[i] = 'Ä';
        else if (sOutput[i] == (char)132)
            sOutput[i] = 'ä';
        else if (sOutput[i] == (char)153)
            sOutput[i] = 'Ö';
        else if (sOutput[i] == (char)148)
            sOutput[i] = 'ö';
        else if (sOutput[i] == (char)154)
            sOutput[i] = 'Ü';
        else if (sOutput[i] == (char)129)
            sOutput[i] = 'ü';
        else if (sOutput[i] == (char)225)
            sOutput[i] = 'ß';
        else if (sOutput[i] == (char)248)
            sOutput[i] = '°';
        else if (sOutput[i] == (char)174)
            sOutput[i] = (char)171;
        else if (sOutput[i] == (char)175)
            sOutput[i] = (char)187;
        else
            continue;
    }
    return sOutput;
}
 
 
std::string utf8parser(const std::string& sString)
{
    std::string sReturn = sString;
    if (sReturn.length() < 2)
        return sReturn;
 
    // Go through the complete string
    for (unsigned int i = 0; i < sReturn.length() - 1; i++)
    {
        // UTF-8 encoded characters are more than one byte in length
        if (sReturn[i] == (char)195)
        {
            if (sReturn[i + 1] == (char)132) //Ä
            {
                sReturn.erase(i, 1);
                sReturn[i] = (char)142;
            }
            else if (sReturn[i + 1] == (char)164) //ä
            {
                sReturn.erase(i, 1);
                sReturn[i] = (char)132;
            }
            else if (sReturn[i + 1] == (char)150) //Ö
            {
                sReturn.erase(i, 1);
                sReturn[i] = (char)153;
            }
            else if (sReturn[i + 1] == (char)182) //ö
            {
                sReturn.erase(i, 1);
                sReturn[i] = (char)148;
            }
            else if (sReturn[i + 1] == (char)156) //Ü
            {
                sReturn.erase(i, 1);
                sReturn[i] = (char)154;
            }
            else if (sReturn[i + 1] == (char)188) //ü
            {
                sReturn.erase(i, 1);
                sReturn[i] = (char)129;
            }
            else if (sReturn[i + 1] == (char)159) //ß
            {
                sReturn.erase(i, 1);
                sReturn[i] = (char)225;
            }
        }
        if (sReturn[i] == (char)194 && sReturn[i + 1] == (char)176)
        {
            sReturn.erase(i, 1);
            sReturn[i] = (char)248;
        }
    }
    return sReturn;
}
 
 
std::string getTimeStamp(bool bGetStamp)
{
    return toString(_time64(0), bGetStamp ? GET_AS_TIMESTAMP : GET_WITH_TEXT);
}
 
 
std::vector<std::string> split(const std::string& sStr, char cSplit)
{
    std::vector<std::string> vSplit;
    size_t lastPos = 0;
 
    for (size_t i = 1; i < sStr.length(); i++)
    {
        if (sStr[i] == cSplit)
        {
            vSplit.push_back(sStr.substr(lastPos, i - lastPos));
            lastPos = i+1;
        }
    }
 
    if (lastPos < sStr.length())
        vSplit.push_back(sStr.substr(lastPos));
 
    return vSplit;
}
 
 
std::string ellipsize(const std::string& sLongString, size_t nMaxStringLength)
{
    if (sLongString.length() > nMaxStringLength)
        return sLongString.substr(0, nMaxStringLength/2-2) + "[...]" + sLongString.substr(sLongString.length()-nMaxStringLength+2);
 
    return sLongString;
}
 
 
void replaceAll(std::string& sToModify, const char* sToRep, const char* sNewValue, size_t nStart /*= 0*/, size_t nEnd /*= string::npos*/)
{
    size_t nRepLength = strlen(sToRep);
    size_t nNewLength = strlen(sNewValue);
    int nOffSet = nNewLength - nRepLength;
    // Ensure the values are correct
    if (!sToModify.length() || !nRepLength)
        return;
 
    // check the boundaries
    if ((size_t)nStart > sToModify.length())
        return;
 
    if (nEnd == std::string::npos)
        nEnd = sToModify.length();
 
    // Process the replacing
    for (size_t i = nStart; i <= nEnd-nRepLength; i++)
    {
        if (i >= sToModify.length())
            break;
 
        if (!sToModify.compare(i, nRepLength, sToRep))
        {
            sToModify.replace(i, nRepLength, sNewValue);
            nEnd += nOffSet;
            i += nNewLength - 1;
        }
    }
}
 
 
void replaceAll(std::string& sToModify, const std::string& sToRep, const std::string& sNewValue, size_t nStart /*= 0*/, size_t nEnd /*= string::npos*/)
{
    size_t nRepLength = sToRep.length();
    size_t nNewLength = sNewValue.length();
    int nOffSet = nNewLength - nRepLength;
    // Ensure the values are correct
    if (!sToModify.length() || !nRepLength)
        return;
 
    // check the boundaries
    if ((size_t)nStart > sToModify.length())
        return;
 
    if (nEnd == std::string::npos)
        nEnd = sToModify.length();
 
    // Process the replacing
    for (size_t i = nStart; i <= nEnd-nRepLength; i++)
    {
        if (i >= sToModify.length())
            break;
 
        if (!sToModify.compare(i, nRepLength, sToRep))
        {
            sToModify.replace(i, nRepLength, sNewValue);
            nEnd += nOffSet;
            i += nNewLength - 1;
        }
    }
}
 
 
std::string replaceControlCharacters(std::string sToModify)
{
    replaceAll(sToModify, "\n", "\\n");
    replaceAll(sToModify, "\t", "\\t");
 
    return sToModify;
}
 
 
std::string replacePathSeparator(const std::string& __sPath)
{
    std::string sPath = __sPath;
 
    // Go through the whole string
    for (unsigned int i = 0; i < sPath.length(); i++)
    {
        // Replace the backslash
        if (sPath[i] == '\\')
            sPath[i] = '/';
    }
 
    return sPath;
}
 
 
bool isEqualStripped(StringView str1, StringView str2)
{
    str1.strip();
    str2.strip();
 
    return str1 == str2;
}