StringUtils.h

Go to the documentation of this file.

// StringUtils.h

// Interfaces to various string helper functions




#pragma once



typedef std::string AString;
typedef std::vector<AString> AStringVector;
typedef std::list<AString>   AStringList;

typedef std::map<AString, AString> AStringMap;





extern AString & Printf(AString & a_Dst, const char * format, fmt::ArgList args);
FMT_VARIADIC(AString &, Printf, AString &, const char *)


extern AString Printf(const char * format, fmt::ArgList args);
FMT_VARIADIC(AString, Printf, const char *)

template <typename... Args>
extern AString & AppendPrintf(AString & a_Dst, const char * format, const Args & ... args)
{
    a_Dst += Printf(format, args...);
    return a_Dst;
}

extern AStringVector StringSplit(const AString & str, const AString & delim);

extern AStringVector StringSplitWithQuotes(const AString & str, const AString & delim);

AString StringJoin(const AStringVector & a_Strings, const AString & a_Delimiter);

extern AStringVector StringSplitAndTrim(const AString & str, const AString & delim);

extern AString TrimString(const AString & str);  // tolua_export

extern AString & InPlaceUppercase(AString & s);

extern AString & InPlaceLowercase(AString & s);

extern AString StrToUpper(const AString & s);

extern AString StrToLower(const AString & s);

extern int NoCaseCompare(const AString & s1, const AString & s2);  // tolua_export

extern size_t RateCompareString(const AString & s1, const AString & s2);

extern void ReplaceString(AString & iHayStack, const AString & iNeedle, const AString & iReplaceWith);  // tolua_export

extern AString & RawBEToUTF8(const char * a_RawData, size_t a_NumShorts, AString & a_UTF8);

extern AString UnicodeCharToUtf8(unsigned a_UnicodeChar);

extern std::u16string UTF8ToRawBEUTF16(const AString & a_String);

extern AString & CreateHexDump(AString & a_Out, const void * a_Data, size_t a_Size, size_t a_BytesPerLine);

extern AString EscapeString(const AString & a_Message);  // tolua_export

extern AString StripColorCodes(const AString & a_Message);  // tolua_export

extern std::pair<bool, AString> URLDecode(const AString & a_String);  // Exported to Lua as cUrlParser::UrlDecode()

extern AString URLEncode(const AString & a_Text);

extern AString ReplaceAllCharOccurrences(const AString & a_String, char a_From, char a_To);  // Needn't export to Lua, since Lua doesn't have chars anyway

extern AString Base64Decode(const AString & a_Base64String);  // Exported manually due to embedded NULs and extra parameter

extern AString Base64Encode(const AString & a_Input);  // Exported manually due to embedded NULs and extra parameter

extern short GetBEShort(const char * a_Mem);

extern unsigned short GetBEUShort(const char * a_Mem);

extern int GetBEInt(const char * a_Mem);

extern void SetBEInt(char * a_Mem, Int32 a_Value);

extern bool SplitZeroTerminatedStrings(const AString & a_Strings, AStringVector & a_Output);

extern AStringVector MergeStringVectors(const AStringVector & a_Strings1, const AStringVector & a_Strings2);

extern AString StringsConcat(const AStringVector & a_Strings, char a_Separator);

extern bool StringToFloat(const AString & a_String, float & a_Num);

bool IsOnlyWhitespace(const AString & a_String);





template <class T>
bool StringToInteger(const AString & a_str, T & a_Num)
{
    size_t i = 0;
    bool positive = true;
    T result = 0;
    if (a_str[0] == '+')
    {
        i++;
    }
    else if (a_str[0] == '-')
    {
        i++;
        positive = false;
    }
    if (positive)
    {
        for (size_t size = a_str.size(); i < size; i++)
        {
            if ((a_str[i] < '0') || (a_str[i] > '9'))
            {
                return false;
            }
            if (std::numeric_limits<T>::max() / 10 < result)
            {
                return false;
            }
            result *= 10;
            T digit = static_cast<T>(a_str[i] - '0');
            if (std::numeric_limits<T>::max() - digit < result)
            {
                return false;
            }
            result += digit;
        }
    }
    else
    {
        // Unsigned result cannot be signed!
        if (!std::numeric_limits<T>::is_signed)
        {
            return false;
        }

        for (size_t size = a_str.size(); i < size; i++)
        {
            if ((a_str[i] < '0') || (a_str[i] > '9'))
            {
                return false;
            }
            if (std::numeric_limits<T>::min() / 10 > result)
            {
                return false;
            }
            result *= 10;
            T digit = static_cast<T>(a_str[i] - '0');
            if (std::numeric_limits<T>::min() + digit > result)
            {
                return false;
            }
            result -= digit;
        }
    }
    a_Num = result;
    return true;
}





template <typename T>
T GetStringMapInteger(const AStringMap & a_Map, const AString & a_Key, T a_Default)
{
    // Try to locate the key:
    auto itr = a_Map.find(a_Key);
    if (itr == a_Map.end())
    {
        return a_Default;
    }

    // Try to convert the value to a number:
    T res = a_Default;
    if (!StringToInteger<T>(itr->second, res))
    {
        return a_Default;
    }
    return res;
}





// If you have any other string helper functions, declare them here