stringutils.h

Go to the documentation of this file.

/*
 *  The Mana Client
 *  Copyright (C) 2007-2009  The Mana World Development Team
 *  Copyright (C) 2009-2012  The Mana Developers
 *
 *  This file is part of The Mana Client.
 *
 *  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 2 of the License, or
 *  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/>.
 */
 
#pragma once
 
#include <optional>
#include <sstream>
#include <string>
#include <vector>
 
std::string &trim(std::string &str);
 
std::string &toLower(std::string &str);
 
std::string &toUpper(std::string &str);
 
 
unsigned int atox(const std::string &str);
 
template<typename T> std::string toString(const T &arg)
{
    std::ostringstream ss;
    ss << arg;
    return ss.str();
}
 
const char *ipToString(int address);
 
std::string strprintf(char const *, ...)
#ifdef __GNUC__
    /* This attribute is nice: it even works through gettext invokation. For
       example, gcc will complain that strprintf(_("%s"), 42) is ill-formed. */
    __attribute__((__format__(__printf__, 1, 2)))
#endif
;
 
std::string &replaceCharacters(std::string &str,
                               std::string_view chars,
                               char replacement = '_');
 
std::string &removeColors(std::string &msg);
 
inline bool startsWith(std::string_view str, std::string_view prefix)
{
    return str.substr(0, prefix.size()) == prefix;
}
 
inline bool endsWith(std::string_view str, std::string_view suffix)
{
    return str.size() >= suffix.size() &&
           str.compare(str.size() - suffix.size(), suffix.size(), suffix) == 0;
}
 
bool isWordSeparator(char chr);
 
std::string findSameSubstring(const std::string &str1,
                              const std::string &str2);
 
bool getBoolFromString(std::string text, bool def = false);
 
template<typename T, typename Enable = void>
struct FromString;
 
template<typename T>
void fromString(const char *str, T &value)
{
    FromString<T>()(str, value);
}
 
inline void fromString(const char *str, std::string &value)
{
    value = str;
}
 
inline void fromString(const char *str, std::string_view &value)
{
    value = str;
}
 
inline void fromString(const char *str, int &value)
{
    value = atoi(str);
}
 
inline void fromString(const char *str, unsigned &value)
{
    value = strtoul(str, nullptr, 10);
}
 
inline void fromString(const char *str, unsigned short &value)
{
    value = static_cast<unsigned short>(strtoul(str, nullptr, 10));
}
 
inline void fromString(const char *str, float &value)
{
    value = strtof(str, nullptr);
}
 
inline void fromString(const char *str, double &value)
{
    value = atof(str);
}
 
inline void fromString(const char *str, bool &value)
{
    value = getBoolFromString(str);
}
 
void fromString(const char *str, std::vector<int> &value);
 
template<typename T>
struct FromString<T, std::enable_if_t<std::is_enum_v<T>>>
{
    void operator() (const char *str, T &value)
    {
        fromString(str, reinterpret_cast<std::underlying_type_t<T>&>(value));
    }
};
 
template<typename T>
struct FromString<std::optional<T>>
{
    void operator() (const char *str, std::optional<T> &value)
    {
        fromString(str, value.emplace());
    }
};
 
std::string autocomplete(const std::vector<std::string> &candidates,
                         std::string base);
 
std::string normalize(const std::string &name);
 
std::string getDirectoryFromURL(const std::string &url);
 
std::string join(const std::vector<std::string> &strings, const char *separator);