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 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 void ReplaceURL(AString & iHayStack, const AString & iNeedle, const AString & iReplaceWith);
 
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 std::byte * a_Mem);
 
extern unsigned short GetBEUShort(const char * a_Mem);
 
extern int GetBEInt(const std::byte * a_Mem);
 
extern void SetBEInt(std::byte * 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