StringUtils.h

Go to the documentation of this file.

/*
* True Reality Open Source Game and Simulation Engine
* Copyright © 2021 Acid Rain Studios LLC
*
* The Base of this class has been adopted from the Delta3D engine
*
* This library is free software; you can redistribute it and/or modify it under
* the terms of the GNU Lesser General Public License as published by the Free
* Software Foundation; either version 3.0 of the License, or (at your option)
* any later version.
*
* This library 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 Lesser General Public License for more
* details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with this library; if not, write to the Free Software Foundation, Inc.,
* 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
* Class Inspired by the Delta3D Engine
* http://delta3dengine.org/
*
* @author David Guthrie
* @author John K. Grant
* @author William E. Johnson II
* @author Chris Osborn
* @author Maxim Serebrennik
*/
#pragma once

#include <trUtil/Export.h>

#include <trUtil/UnaryFunction.h>
#include <trUtil/WarningUtils.h>

#include <string>
#include <sstream>
#include <locale>
#include <vector>
#include <algorithm>

namespace trUtil::StringUtils
{
    class IsSpace;

    static const std::string STR_BLANK("");

    template <class Pred = IsSpace>
    class StringTokenizer
    {
    public:

        static void tokenize(std::vector<std::string>& tokens, const std::string& stringToParse, const Pred& predFxn = Pred());

        static void tokenize(std::vector<std::string>& tokens, const std::string& stringToParse, const std::string& delimiter);
    };

    template <class Pred>
    inline void StringTokenizer<Pred>::tokenize(std::vector<std::string>& tokens, const std::string& stringToParse, const Pred& predFxn)
    {
        //First clear the results std::vector
        tokens.clear();
        std::string::const_iterator it = stringToParse.begin();
        std::string::const_iterator itTokenEnd = stringToParse.begin();
        while (it != stringToParse.end())
        {
            //Eat separators
            if (predFxn(*it))
            {
                it++;
            }
            else
            {
                //Find next token
                itTokenEnd = std::find_if(it, stringToParse.end(), predFxn);
                //Append token to result
                if (it < itTokenEnd)
                {
                    tokens.push_back(std::string(it, itTokenEnd));
                }
                it = itTokenEnd;
            }
        }
    }

    class TR_UTIL_EXPORT IsSpace : public trUtil::UnaryFunction<char, bool>
    {
        TR_DISABLE_WARNING_START_MSVC(4251)
    public:
        static const std::string DEFAULT_LOCALE_NAME;
        IsSpace(const std::locale& loc = std::locale(DEFAULT_LOCALE_NAME.c_str())) : mLocale(loc) {}

        const std::locale& GetLocale() const { return mLocale; }
        bool operator()(char c) const { return std::isspace(c, mLocale); }
        TR_DISABLE_WARNING_END
    private:
        std::locale mLocale;
    };

    class IsSlash : public trUtil::UnaryFunction<char, bool>
    {
    public:
        bool operator()(char c) const { return c == '/'; }
    };

    class IsDelimeter : public trUtil::UnaryFunction<char, bool>
    {
    public:
        IsDelimeter(char delim) : mDelimeter(delim) { }
        bool operator()(char c) const { return c == mDelimeter; }
    private:
        char mDelimeter;
    };

    TR_UTIL_EXPORT const std::string& Trim(std::string& toTrim);

    TR_UTIL_EXPORT int StrCompare(const std::string& one, const std::string& two, bool caseSensitive = true);

    TR_UTIL_EXPORT void ToLowerCase(std::string& str);

    TR_UTIL_EXPORT std::string ToLowerCase(const std::string& str);

    TR_UTIL_EXPORT void ToUpperCase(std::string& str);

    TR_UTIL_EXPORT std::string ToUpperCase(const std::string& str);

    struct StrCompareFunc
    {
        StrCompareFunc(const std::string& mainString, bool caseSensitive = true)
        : mString(mainString)
        , mCaseSensitive(caseSensitive)
        {
        }

        bool operator() (const std::string& toCompare)
        {
            return StrCompare(toCompare, mString, mCaseSensitive) == 0;
        }

        const std::string& mString;
        bool mCaseSensitive;
    };

    template<class VecType>
    bool ParseVec(const std::string& value, VecType& vec, unsigned size, unsigned numberPrecision = 16)
    {
        bool result = true;
        unsigned int i;

        if (value.empty() || value == "NULL")
        {
            for (i = 0; i < size; ++i)
            {
                vec[i] = 0.0;
            }
        }
        else
        {
            std::istringstream iss(value);
            iss.precision(numberPrecision);
            for (i = 0; i < size && !iss.eof(); ++i)
            {
                iss >> vec[i];
            }

            //did we run out of data?
            if (i < size)
                result = false;
        }

        return result;
    }

    template<typename T>
    std::string ToString(const T& t, int precision = -1)
    {
        std::ostringstream ss;
        if (precision > 0)
        {
            ss.precision(precision);
        }
        ss << t;
        return ss.str();
    }


    template<typename T>
    T FromString(const std::string& u)
    {
        T result = T();
        std::istringstream is;
        is.str(u);
        is >> result;
        return result;
    }


    template<>
    bool TR_UTIL_EXPORT FromString<bool>(const std::string& u);

    bool TR_UTIL_EXPORT Match(const char* wildCards, const char* str);

    void TR_UTIL_EXPORT MakeIndexString(unsigned index, std::string& toFill, unsigned paddedLength = 4);

    bool TR_UTIL_EXPORT TakeToken(std::string& data, std::string& outToken, char openChar, char closeChar);

    void TR_UTIL_EXPORT FindAndReplace(std::string& modifiedString, const std::string& findWhat, const std::string& replaceWith);
}