StringHelper.h

#pragma once
#include <string>
#include <map>
#include <float.h>
using namespace std;

namespace ParaEngine
{
    class StringHelper
    {
    public:
        static bool UTF8ToUTF16(const std::string& utf8, std::u16string& outUtf16);
        static bool UTF8ToUTF16_Safe(const std::string& utf8, std::u16string& outUtf16);

        /*
        * @str:    the string to trim
        * @index:    the index to start trimming from.
        *
        * Trims str st str=[0, index) after the operation.
        *
        * Return value: the trimmed string.
        * */
        static void TrimUTF16VectorFromIndex(std::vector<char16_t>& str, int index);

        /*
        * @ch is the unicode character whitespace?
        *
        * Reference: http://en.wikipedia.org/wiki/Whitespace_character#Unicode
        *
        * Return value: weather the character is a whitespace character.
        * */
        static bool IsUnicodeSpace(char16_t ch);

        static bool IsCJKUnicode(char16_t ch);

        static void TrimUTF16Vector(std::vector<char16_t>& str);


        /*
        * @str:    the string to search through.
        * @c:        the character to not look for.
        *
        * Return value: the index of the last character that is not c.
        * */
        static unsigned int GetIndexOfLastNotChar16(const std::vector<char16_t>& str, char16_t c);

        static bool UTF16ToUTF8(const std::u16string& utf16, std::string& outUtf8);

        static const WCHAR* MultiByteToWideChar(const char* name, unsigned int nCodePage = 0, size_t* outLen = nullptr);
        static const char* WideCharToMultiByte(const WCHAR* name, unsigned int nCodePage = 0, size_t* outLen = nullptr);
        static int WideCharToMultiByte(const WCHAR* name, char* szText, int nLength, unsigned int nCodePage = 0);

        static const WCHAR* AnsiToWideChar(const char* name);
        static const char* WideCharToAnsi(const WCHAR* name);

        static const char* UTF8ToAnsi(const char* name);
        static const char* AnsiToUTF8(const char* name);

        static int GetUnicodeCharNum(const char* str);

        static string UniSubString(const char* str, int nFrom, int nTo);

        static string SimpleEncode(const string& source);

        static string SimpleDecode(const string& source);

        static const std::string& EncodingConvert(const std::string& srcEncoding, const std::string& dstEncoding, const std::string& bytes);

        static bool CopyTextToClipboard(const string& text);

        static const char* GetTextFromClipboard();

        static void DevideString(const string& input,string& str1,string&str2,char separator=';');

        static void split(const std::string& src, const std::string& token, std::vector<std::string>& vect);

        static void make_lower(string& str);

        static void make_upper(string& str);

        static bool checkValidXMLChars( const std::string& data );

        static bool removeInValidXMLChars( std::string& data );

        static bool IsNumber(const char * str);
        static bool IsLetter(const char * str);
        static int StrToInt(const char *str);
        static double StrToFloat(const char * str);
        static bool RegularMatch(const char *input,const char *expression);
        //replace all "\" in a string to "\\"
        static std::string ToCString(const char* input);
        static std::string StrReplace(const char* inputstring, char srcchar,char destchar);
        static RECT * GetImageAndRect(const std::string &str,std::string &imagefile, RECT * pOut=NULL);

        static std::string md5(const std::string& source, bool bBinary = false);

        /*
            convert the sha1 of the input source string.
            * @param bBinary: if false (default), result is 32 hex number chars. if true, result is 16 bytes binary string.
        */
        static std::string sha1(const std::string& source, bool bBinary = false);

        static std::string base64(const std::string& source);
        static std::string unbase64(const std::string& source);



        static void fast_sprintf(char* s,const char *fmt, ...);
        static void fast_snprintf(char* s, int nMaxCount, const char *fmt, ...);

        static int fast_itoa( int64 value, char* result, int buf_size, int base = 10 );

        static int fast_dtoa(double num, char* str, int nBuffSize=40, int max_decimal=5, int radix = 10);

        static bool MatchWildcard(const std::string& str, const std::string& sWildcardPattern);

        static bool StrEndsWith(const string& str, const string& sequence);


        private:
            class _CodePageName
            {
            public:
                _CodePageName()
                {
#ifdef WIN32
                    auto cp = GetACP();
                    char tmp[30];
                    ParaEngine::StringHelper::fast_itoa((int)cp, tmp, 30);

                    name = "CP";
                    name += tmp;
#else
                    name = "utf-8";
#endif
                }

                const std::string& get() const
                {
                    return name;
                }

            private:
                std::string name;

            };

            static _CodePageName defaultCPName;

    };
}