MyGUI_StringUtility.h

Go to the documentation of this file.

/*
 * This source file is part of MyGUI. For the latest info, see http://mygui.info/
 * Distributed under the MIT License
 * (See accompanying file COPYING.MIT or copy at http://opensource.org/licenses/MIT)
 */
 
#ifndef MYGUI_STRING_UTILITY_H_
#define MYGUI_STRING_UTILITY_H_
 
#include "MyGUI_Prerequest.h"
#include <vector>
#include <sstream>
 
namespace MyGUI::utility
{
 
    inline void trim(std::string& _str, bool _left = true, bool _right = true)
    {
        if (_right)
            _str.erase(_str.find_last_not_of(" \t\r") + 1);
        if (_left)
            _str.erase(0, _str.find_first_not_of(" \t\r"));
    }
 
    template<typename T>
    inline std::string toString(T _value)
    {
        std::ostringstream stream;
        stream << _value;
        return stream.str();
    }
 
    inline const std::string& toString(const std::string& _value)
    {
        return _value;
    }
 
    template<>
    inline std::string toString(std::string_view _value)
    {
        return std::string{_value};
    }
 
    template<typename... Args>
    inline std::string toString(Args&&... args)
    {
        std::ostringstream stream;
        ((stream << args), ...);
        return stream.str();
    }
 
    template<>
    inline std::string toString<bool>(bool _value)
    {
        return _value ? "true" : "false";
    }
 
 
    template<typename T>
    inline T parseValue(std::string_view _value)
    {
        std::stringstream stream;
        stream << _value;
        T result;
        stream >> result;
        if (stream.fail())
            return {};
 
        // check if there is more data, return {} in this case
        int item = stream.get();
        while (item != -1)
        {
            if (item != ' ' && item != '\t')
                return {};
            item = stream.get();
        }
        return result;
    }
 
    // bool specialization
    template<>
    inline bool parseValue(std::string_view _value)
    {
        return _value == "True" || _value == "true" || _value == "1";
    }
 
    // char specialization
    template<>
    inline char parseValue(std::string_view _value)
    {
        return static_cast<char>(parseValue<short>(_value));
    }
 
    // unsigned char specialization
    template<>
    inline unsigned char parseValue(std::string_view _value)
    {
        return static_cast<unsigned char>(parseValue<unsigned short>(_value));
    }
 
 
    inline int parseInt(std::string_view _value)
    {
        return parseValue<int>(_value);
    }
 
    inline unsigned int parseUInt(std::string_view _value)
    {
        return parseValue<unsigned int>(_value);
    }
 
    inline size_t parseSizeT(std::string_view _value)
    {
        return parseValue<size_t>(_value);
    }
 
    inline float parseFloat(std::string_view _value)
    {
        return parseValue<float>(_value);
    }
 
    inline double parseDouble(std::string_view _value)
    {
        return parseValue<double>(_value);
    }
 
    inline bool parseBool(std::string_view _value)
    {
        return parseValue<bool>(_value);
    }
 
    namespace templates
    {
        template<class ReturnType, class InputType = ReturnType>
        inline void split(std::vector<ReturnType>& _ret, const InputType& _source, const InputType& _delims)
        {
            size_t start = _source.find_first_not_of(_delims);
            while (start != _source.npos)
            {
                size_t end = _source.find_first_of(_delims, start);
                if (end != _source.npos)
                    _ret.emplace_back(_source.substr(start, end - start));
                else
                {
                    _ret.emplace_back(_source.substr(start));
                    break;
                }
                start = _source.find_first_not_of(_delims, end + 1);
            }
        }
    } // namespace templates
 
    inline std::vector<std::string> split(std::string_view _source, std::string_view _delims = "\t\n ")
    {
        std::vector<std::string> result;
        templates::split<std::string, std::string_view>(result, _source, _delims);
        return result;
    }
 
    template<typename... Args>
    inline bool parseComplex(std::string_view _value, Args&... args)
    {
        std::stringstream stream;
        stream << _value;
 
        ((stream >> args), ...);
 
        if (stream.fail())
            return false;
 
        // check if there is more data, return false in this case
        int item = stream.get();
        while (item != -1)
        {
            if (item != ' ' && item != '\t')
                return false;
            item = stream.get();
        }
 
        return true;
    }
 
    template<>
    inline bool parseComplex<bool>(std::string_view _value, bool& arg)
    {
        std::string value(_value);
        trim(value);
        if ((value == "True") || (value == "true") || (value == "1"))
        {
            arg = true;
            return true;
        }
        if ((value == "False") || (value == "false") || (value == "0"))
        {
            arg = false;
            return true;
        }
 
        return false;
    }
 
    inline bool startWith(std::string_view _source, std::string_view _value)
    {
#if __cplusplus >= 202002L
        return _source.starts_with(_value);
#else
        size_t count = _value.size();
        if (_source.size() < count)
            return false;
        for (size_t index = 0; index < count; ++index)
        {
            if (_source[index] != _value[index])
                return false;
        }
        return true;
#endif
    }
 
    inline bool endWith(std::string_view _source, std::string_view _value)
    {
#if __cplusplus >= 202002L
        return _source.ends_with(_value);
#else
        size_t count = _value.size();
        if (_source.size() < count)
            return false;
        size_t offset = _source.size() - count;
        for (size_t index = 0; index < count; ++index)
        {
            if (_source[index + offset] != _value[index])
                return false;
        }
        return true;
#endif
    }
 
} // namespace MyGUI
 
#endif // MYGUI_STRING_UTILITY_H_