2014-05-08 11:10:54 +08:00
|
|
|
/****************************************************************************
|
|
|
|
Copyright (c) 2014 cocos2d-x.org
|
2018-01-29 16:25:32 +08:00
|
|
|
Copyright (c) 2014-2016 Chukong Technologies Inc.
|
|
|
|
Copyright (c) 2017-2018 Xiamen Yaji Software Co., Ltd.
|
2014-05-08 11:10:54 +08:00
|
|
|
|
|
|
|
http://www.cocos2d-x.org
|
|
|
|
|
|
|
|
Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
|
|
of this software and associated documentation files (the "Software"), to deal
|
|
|
|
in the Software without restriction, including without limitation the rights
|
|
|
|
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
|
|
copies of the Software, and to permit persons to whom the Software is
|
|
|
|
furnished to do so, subject to the following conditions:
|
|
|
|
|
|
|
|
The above copyright notice and this permission notice shall be included in
|
|
|
|
all copies or substantial portions of the Software.
|
|
|
|
|
|
|
|
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
|
|
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
|
|
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
|
|
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
|
|
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
|
|
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
|
|
|
THE SOFTWARE.
|
|
|
|
****************************************************************************/
|
2013-02-27 15:16:49 +08:00
|
|
|
|
2014-08-29 15:39:52 +08:00
|
|
|
#include "base/ccUTF8.h"
|
2014-05-17 05:36:00 +08:00
|
|
|
#include "platform/CCCommon.h"
|
2014-04-27 01:35:57 +08:00
|
|
|
#include "base/CCConsole.h"
|
2014-05-08 11:10:54 +08:00
|
|
|
#include "ConvertUTF.h"
|
2017-10-17 11:03:32 +08:00
|
|
|
#include <limits>
|
2013-02-27 15:16:49 +08:00
|
|
|
|
|
|
|
NS_CC_BEGIN
|
|
|
|
|
2014-05-08 11:10:54 +08:00
|
|
|
namespace StringUtils {
|
2013-02-27 15:16:49 +08:00
|
|
|
|
2017-11-08 14:05:03 +08:00
|
|
|
/*--- This a C++ universal sprintf in the future.
|
|
|
|
** @pitfall: The behavior of vsnprintf between VS2013 and VS2015/2017 is different
|
|
|
|
** VS2013 or Unix-Like System will return -1 when buffer not enough, but VS2015/2017 will return the actural needed length for buffer at this station
|
|
|
|
** The _vsnprintf behavior is compatible API which always return -1 when buffer isn't enough at VS2013/2015/2017
|
|
|
|
** Yes, The vsnprintf is more efficient implemented by MSVC 19.0 or later, AND it's also standard-compliant, see reference: http://www.cplusplus.com/reference/cstdio/vsnprintf/
|
|
|
|
*/
|
2016-06-15 15:01:26 +08:00
|
|
|
std::string format(const char* format, ...)
|
|
|
|
{
|
2017-11-08 14:05:03 +08:00
|
|
|
#define CC_VSNPRINTF_BUFFER_LENGTH 512
|
|
|
|
va_list args;
|
2020-05-06 16:28:34 +08:00
|
|
|
std::string buf(CC_VSNPRINTF_BUFFER_LENGTH, '\0');
|
2017-11-08 14:05:03 +08:00
|
|
|
|
|
|
|
va_start(args, format);
|
2020-05-06 16:28:34 +08:00
|
|
|
int nret = vsnprintf(&buf.front(), buf.length() + 1, format, args);
|
2017-11-08 14:05:03 +08:00
|
|
|
va_end(args);
|
|
|
|
|
2020-05-06 16:28:34 +08:00
|
|
|
if (nret >= 0)
|
|
|
|
{
|
|
|
|
if ((unsigned int)nret < buf.length())
|
|
|
|
{
|
|
|
|
buf.resize(nret);
|
2017-11-08 14:05:03 +08:00
|
|
|
}
|
2020-05-06 16:28:34 +08:00
|
|
|
else if ((unsigned int)nret > buf.length())
|
|
|
|
{ // handle return required length when buffer insufficient
|
|
|
|
buf.resize(nret);
|
2017-11-08 14:05:03 +08:00
|
|
|
|
|
|
|
va_start(args, format);
|
2020-05-06 16:28:34 +08:00
|
|
|
nret = vsnprintf(&buf.front(), buf.length() + 1, format, args);
|
2017-11-08 14:05:03 +08:00
|
|
|
va_end(args);
|
|
|
|
}
|
|
|
|
// else equals, do nothing.
|
2016-06-15 15:01:26 +08:00
|
|
|
}
|
2020-05-06 16:28:34 +08:00
|
|
|
else
|
|
|
|
{ // handle return -1 when buffer insufficient
|
|
|
|
/*
|
|
|
|
vs2013/older & glibc <= 2.0.6, they would return -1 when the output was truncated.
|
|
|
|
see: http://man7.org/linux/man-pages/man3/vsnprintf.3.html
|
|
|
|
*/
|
|
|
|
#if (defined(__linux__) && ((__GLIBC__ < 2) || ((__GLIBC__ == 2) && (__GLIBC_MINOR__ < 1)))) || \
|
|
|
|
(defined(_MSC_VER) && _MSC_VER < 1900)
|
|
|
|
enum : size_t
|
|
|
|
{
|
|
|
|
enlarge_limits = (1 << 20), // limits the buffer cost memory less than 2MB
|
|
|
|
};
|
|
|
|
do
|
|
|
|
{
|
|
|
|
buf.resize(buf.length() << 1);
|
2017-11-08 14:05:03 +08:00
|
|
|
|
|
|
|
va_start(args, format);
|
2020-05-06 16:28:34 +08:00
|
|
|
nret = vsnprintf(&buf.front(), buf.length() + 1, format, args);
|
2017-11-08 14:05:03 +08:00
|
|
|
va_end(args);
|
|
|
|
|
2020-05-06 16:28:34 +08:00
|
|
|
} while (nret < 0 && buf.size() <= enlarge_limits);
|
|
|
|
if (nret > 0)
|
|
|
|
buf.resize(nret);
|
|
|
|
else
|
|
|
|
buf = "strfmt: an error is encountered!";
|
|
|
|
#else
|
|
|
|
/* other standard implementation
|
|
|
|
see: http://www.cplusplus.com/reference/cstdio/vsnprintf/
|
|
|
|
*/
|
|
|
|
buf = "strfmt: an error is encountered!";
|
|
|
|
#endif
|
2017-11-08 14:05:03 +08:00
|
|
|
}
|
|
|
|
|
2020-05-06 16:28:34 +08:00
|
|
|
return buf;
|
2016-06-15 15:01:26 +08:00
|
|
|
}
|
|
|
|
|
2013-02-27 15:16:49 +08:00
|
|
|
/*
|
|
|
|
* @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.
|
|
|
|
* */
|
2014-05-08 11:10:54 +08:00
|
|
|
unsigned int getIndexOfLastNotChar16(const std::vector<char16_t>& str, char16_t c)
|
2013-02-27 15:16:49 +08:00
|
|
|
{
|
2013-12-06 16:32:06 +08:00
|
|
|
int len = static_cast<int>(str.size());
|
2014-05-08 11:10:54 +08:00
|
|
|
|
2013-02-27 15:16:49 +08:00
|
|
|
int i = len - 1;
|
|
|
|
for (; i >= 0; --i)
|
|
|
|
if (str[i] != c) return i;
|
2014-05-08 11:10:54 +08:00
|
|
|
|
2013-02-27 15:16:49 +08:00
|
|
|
return i;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* @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.
|
|
|
|
* */
|
2014-05-08 11:10:54 +08:00
|
|
|
static void trimUTF16VectorFromIndex(std::vector<char16_t>& str, int index)
|
2013-02-27 15:16:49 +08:00
|
|
|
{
|
2014-05-08 11:10:54 +08:00
|
|
|
int size = static_cast<int>(str.size());
|
2013-02-27 15:16:49 +08:00
|
|
|
if (index >= size || index < 0)
|
|
|
|
return;
|
2014-05-08 11:10:54 +08:00
|
|
|
|
|
|
|
str.erase(str.begin() + index, str.begin() + size);
|
2013-02-27 15:16:49 +08:00
|
|
|
}
|
2017-02-06 16:41:52 +08:00
|
|
|
|
|
|
|
/*
|
|
|
|
* @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 trimUTF32VectorFromIndex(std::vector<char32_t>& str, int index)
|
|
|
|
{
|
|
|
|
int size = static_cast<int>(str.size());
|
|
|
|
if (index >= size || index < 0)
|
|
|
|
return;
|
|
|
|
|
|
|
|
str.erase(str.begin() + index, str.begin() + size);
|
|
|
|
}
|
2013-02-27 15:16:49 +08:00
|
|
|
|
|
|
|
/*
|
|
|
|
* @ch is the unicode character whitespace?
|
|
|
|
*
|
|
|
|
* Reference: http://en.wikipedia.org/wiki/Whitespace_character#Unicode
|
|
|
|
*
|
|
|
|
* Return value: weather the character is a whitespace character.
|
|
|
|
* */
|
2017-02-06 16:41:52 +08:00
|
|
|
bool isUnicodeSpace(char32_t ch)
|
2013-02-27 15:16:49 +08:00
|
|
|
{
|
2018-04-02 10:27:26 +08:00
|
|
|
return (ch >= 0x0009 && ch <= 0x000D) || ch == 0x0020 || ch == 0x0085 || ch == 0x00A0 || ch == 0x1680
|
2013-02-27 15:16:49 +08:00
|
|
|
|| (ch >= 0x2000 && ch <= 0x200A) || ch == 0x2028 || ch == 0x2029 || ch == 0x202F
|
|
|
|
|| ch == 0x205F || ch == 0x3000;
|
|
|
|
}
|
|
|
|
|
2017-02-06 16:41:52 +08:00
|
|
|
bool isCJKUnicode(char32_t ch)
|
2014-02-08 14:15:42 +08:00
|
|
|
{
|
2014-02-08 14:52:10 +08:00
|
|
|
return (ch >= 0x4E00 && ch <= 0x9FBF) // CJK Unified Ideographs
|
|
|
|
|| (ch >= 0x2E80 && ch <= 0x2FDF) // CJK Radicals Supplement & Kangxi Radicals
|
|
|
|
|| (ch >= 0x2FF0 && ch <= 0x30FF) // Ideographic Description Characters, CJK Symbols and Punctuation & Japanese
|
|
|
|
|| (ch >= 0x3100 && ch <= 0x31BF) // Korean
|
|
|
|
|| (ch >= 0xAC00 && ch <= 0xD7AF) // Hangul Syllables
|
|
|
|
|| (ch >= 0xF900 && ch <= 0xFAFF) // CJK Compatibility Ideographs
|
|
|
|
|| (ch >= 0xFE30 && ch <= 0xFE4F) // CJK Compatibility Forms
|
2017-02-06 16:41:52 +08:00
|
|
|
|| (ch >= 0x31C0 && ch <= 0x4DFF) // Other extensions
|
|
|
|
|| (ch >= 0x1f004 && ch <= 0x1f682);// Emoji
|
2014-02-08 14:15:42 +08:00
|
|
|
}
|
2018-04-02 10:27:26 +08:00
|
|
|
|
|
|
|
bool isUnicodeNonBreaking(char32_t ch)
|
|
|
|
{
|
|
|
|
return ch == 0x00A0 // Non-Breaking Space
|
|
|
|
|| ch == 0x202F // Narrow Non-Breaking Space
|
|
|
|
|| ch == 0x2007 // Figure Space
|
|
|
|
|| ch == 0x2060; // Word Joiner
|
|
|
|
}
|
|
|
|
|
2014-05-08 11:10:54 +08:00
|
|
|
void trimUTF16Vector(std::vector<char16_t>& str)
|
2013-02-27 15:16:49 +08:00
|
|
|
{
|
2014-05-08 11:10:54 +08:00
|
|
|
int len = static_cast<int>(str.size());
|
|
|
|
|
2013-02-27 15:16:49 +08:00
|
|
|
if ( len <= 0 )
|
|
|
|
return;
|
2014-05-08 11:10:54 +08:00
|
|
|
|
2013-02-27 15:16:49 +08:00
|
|
|
int last_index = len - 1;
|
2014-05-08 11:10:54 +08:00
|
|
|
|
2013-02-27 15:16:49 +08:00
|
|
|
// Only start trimming if the last character is whitespace..
|
2014-05-08 11:10:54 +08:00
|
|
|
if (isUnicodeSpace(str[last_index]))
|
2013-02-27 15:16:49 +08:00
|
|
|
{
|
|
|
|
for (int i = last_index - 1; i >= 0; --i)
|
|
|
|
{
|
2014-05-08 11:10:54 +08:00
|
|
|
if (isUnicodeSpace(str[i]))
|
2013-02-27 15:16:49 +08:00
|
|
|
last_index = i;
|
|
|
|
else
|
|
|
|
break;
|
|
|
|
}
|
2014-05-08 11:10:54 +08:00
|
|
|
|
|
|
|
trimUTF16VectorFromIndex(str, last_index);
|
2013-02-27 15:16:49 +08:00
|
|
|
}
|
|
|
|
}
|
2017-02-06 16:41:52 +08:00
|
|
|
|
|
|
|
void trimUTF32Vector(std::vector<char32_t>& str)
|
|
|
|
{
|
|
|
|
int len = static_cast<int>(str.size());
|
|
|
|
|
|
|
|
if ( len <= 0 )
|
|
|
|
return;
|
|
|
|
|
|
|
|
int last_index = len - 1;
|
|
|
|
|
|
|
|
// Only start trimming if the last character is whitespace..
|
|
|
|
if (isUnicodeSpace(str[last_index]))
|
|
|
|
{
|
|
|
|
for (int i = last_index - 1; i >= 0; --i)
|
|
|
|
{
|
|
|
|
if (isUnicodeSpace(str[i]))
|
|
|
|
last_index = i;
|
|
|
|
else
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
trimUTF32VectorFromIndex(str, last_index);
|
|
|
|
}
|
|
|
|
}
|
2013-02-27 15:16:49 +08:00
|
|
|
|
2015-11-21 11:00:14 +08:00
|
|
|
|
|
|
|
template <typename T>
|
|
|
|
struct ConvertTrait {
|
|
|
|
typedef T ArgType;
|
|
|
|
};
|
|
|
|
template <>
|
|
|
|
struct ConvertTrait<char> {
|
|
|
|
typedef UTF8 ArgType;
|
|
|
|
};
|
|
|
|
template <>
|
|
|
|
struct ConvertTrait<char16_t> {
|
|
|
|
typedef UTF16 ArgType;
|
|
|
|
};
|
|
|
|
template <>
|
|
|
|
struct ConvertTrait<char32_t> {
|
|
|
|
typedef UTF32 ArgType;
|
|
|
|
};
|
|
|
|
|
|
|
|
template <typename From, typename To, typename FromTrait = ConvertTrait<From>, typename ToTrait = ConvertTrait<To>>
|
|
|
|
bool utfConvert(
|
|
|
|
const std::basic_string<From>& from, std::basic_string<To>& to,
|
|
|
|
ConversionResult(*cvtfunc)(const typename FromTrait::ArgType**, const typename FromTrait::ArgType*,
|
|
|
|
typename ToTrait::ArgType**, typename ToTrait::ArgType*,
|
|
|
|
ConversionFlags)
|
|
|
|
)
|
2013-02-27 15:16:49 +08:00
|
|
|
{
|
2015-11-21 11:00:14 +08:00
|
|
|
static_assert(sizeof(From) == sizeof(typename FromTrait::ArgType), "Error size mismatched");
|
|
|
|
static_assert(sizeof(To) == sizeof(typename ToTrait::ArgType), "Error size mismatched");
|
|
|
|
|
|
|
|
if (from.empty())
|
2013-02-27 15:16:49 +08:00
|
|
|
{
|
2015-11-21 11:00:14 +08:00
|
|
|
to.clear();
|
2014-05-08 11:10:54 +08:00
|
|
|
return true;
|
2013-02-27 15:16:49 +08:00
|
|
|
}
|
2014-05-08 11:10:54 +08:00
|
|
|
|
2015-11-21 11:00:14 +08:00
|
|
|
// See: http://unicode.org/faq/utf_bom.html#gen6
|
|
|
|
static const int most_bytes_per_character = 4;
|
2014-05-08 11:10:54 +08:00
|
|
|
|
2015-11-21 11:00:14 +08:00
|
|
|
const size_t maxNumberOfChars = from.length(); // all UTFs at most one element represents one character.
|
|
|
|
const size_t numberOfOut = maxNumberOfChars * most_bytes_per_character / sizeof(To);
|
|
|
|
|
|
|
|
std::basic_string<To> working(numberOfOut, 0);
|
|
|
|
|
|
|
|
auto inbeg = reinterpret_cast<const typename FromTrait::ArgType*>(&from[0]);
|
|
|
|
auto inend = inbeg + from.length();
|
2014-05-08 11:10:54 +08:00
|
|
|
|
|
|
|
|
2015-11-21 11:00:14 +08:00
|
|
|
auto outbeg = reinterpret_cast<typename ToTrait::ArgType*>(&working[0]);
|
|
|
|
auto outend = outbeg + working.length();
|
|
|
|
auto r = cvtfunc(&inbeg, inend, &outbeg, outend, strictConversion);
|
|
|
|
if (r != conversionOK)
|
|
|
|
return false;
|
2014-05-08 11:10:54 +08:00
|
|
|
|
2015-11-21 11:00:14 +08:00
|
|
|
working.resize(reinterpret_cast<To*>(outbeg) - &working[0]);
|
|
|
|
to = std::move(working);
|
|
|
|
|
|
|
|
return true;
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
bool UTF8ToUTF16(const std::string& utf8, std::u16string& outUtf16)
|
|
|
|
{
|
|
|
|
return utfConvert(utf8, outUtf16, ConvertUTF8toUTF16);
|
|
|
|
}
|
|
|
|
|
|
|
|
bool UTF8ToUTF32(const std::string& utf8, std::u32string& outUtf32)
|
|
|
|
{
|
|
|
|
return utfConvert(utf8, outUtf32, ConvertUTF8toUTF32);
|
2014-05-08 11:10:54 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
bool UTF16ToUTF8(const std::u16string& utf16, std::string& outUtf8)
|
|
|
|
{
|
2015-11-21 11:00:14 +08:00
|
|
|
return utfConvert(utf16, outUtf8, ConvertUTF16toUTF8);
|
|
|
|
}
|
|
|
|
|
|
|
|
bool UTF16ToUTF32(const std::u16string& utf16, std::u32string& outUtf32)
|
|
|
|
{
|
|
|
|
return utfConvert(utf16, outUtf32, ConvertUTF16toUTF32);
|
|
|
|
}
|
2014-05-08 11:10:54 +08:00
|
|
|
|
2015-11-21 11:00:14 +08:00
|
|
|
bool UTF32ToUTF8(const std::u32string& utf32, std::string& outUtf8)
|
|
|
|
{
|
|
|
|
return utfConvert(utf32, outUtf8, ConvertUTF32toUTF8);
|
|
|
|
}
|
|
|
|
|
|
|
|
bool UTF32ToUTF16(const std::u32string& utf32, std::u16string& outUtf16)
|
|
|
|
{
|
|
|
|
return utfConvert(utf32, outUtf16, ConvertUTF32toUTF16);
|
2013-02-27 15:16:49 +08:00
|
|
|
}
|
|
|
|
|
2015-08-04 16:24:08 +08:00
|
|
|
#if (CC_TARGET_PLATFORM == CC_PLATFORM_ANDROID)
|
2015-08-05 16:10:14 +08:00
|
|
|
std::string getStringUTFCharsJNI(JNIEnv* env, jstring srcjStr, bool* ret)
|
2015-08-04 16:24:08 +08:00
|
|
|
{
|
2015-08-05 16:10:14 +08:00
|
|
|
std::string utf8Str;
|
2018-09-29 13:58:06 +08:00
|
|
|
if(srcjStr != nullptr && env != nullptr)
|
2015-08-05 16:10:14 +08:00
|
|
|
{
|
2016-08-08 10:43:14 +08:00
|
|
|
const unsigned short * unicodeChar = ( const unsigned short *)env->GetStringChars(srcjStr, nullptr);
|
|
|
|
size_t unicodeCharLength = env->GetStringLength(srcjStr);
|
|
|
|
const std::u16string unicodeStr((const char16_t *)unicodeChar, unicodeCharLength);
|
|
|
|
bool flag = UTF16ToUTF8(unicodeStr, utf8Str);
|
|
|
|
if (ret)
|
|
|
|
{
|
|
|
|
*ret = flag;
|
|
|
|
}
|
|
|
|
if (!flag)
|
|
|
|
{
|
|
|
|
utf8Str = "";
|
|
|
|
}
|
|
|
|
env->ReleaseStringChars(srcjStr, unicodeChar);
|
2015-08-05 16:10:14 +08:00
|
|
|
}
|
2016-08-08 10:43:14 +08:00
|
|
|
else
|
2015-08-05 16:10:14 +08:00
|
|
|
{
|
2016-08-08 10:43:14 +08:00
|
|
|
if (ret)
|
|
|
|
{
|
|
|
|
*ret = false;
|
|
|
|
}
|
2015-08-05 16:10:14 +08:00
|
|
|
utf8Str = "";
|
|
|
|
}
|
|
|
|
return utf8Str;
|
|
|
|
}
|
|
|
|
|
2016-05-17 12:17:56 +08:00
|
|
|
jstring newStringUTFJNI(JNIEnv* env, const std::string& utf8Str, bool* ret)
|
2015-08-05 16:10:14 +08:00
|
|
|
{
|
|
|
|
std::u16string utf16Str;
|
|
|
|
bool flag = cocos2d::StringUtils::UTF8ToUTF16(utf8Str, utf16Str);
|
|
|
|
|
|
|
|
if (ret)
|
|
|
|
{
|
|
|
|
*ret = flag;
|
|
|
|
}
|
|
|
|
|
|
|
|
if(!flag)
|
|
|
|
{
|
|
|
|
utf16Str.clear();
|
|
|
|
}
|
|
|
|
jstring stringText = env->NewString((const jchar*)utf16Str.data(), utf16Str.length());
|
|
|
|
return stringText;
|
2015-08-04 16:24:08 +08:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2014-05-08 11:10:54 +08:00
|
|
|
std::vector<char16_t> getChar16VectorFromUTF16String(const std::u16string& utf16)
|
2013-02-27 15:16:49 +08:00
|
|
|
{
|
2015-11-21 11:00:14 +08:00
|
|
|
return std::vector<char16_t>(utf16.begin(), utf16.end());
|
2014-05-08 11:10:54 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
long getCharacterCountInUTF8String(const std::string& utf8)
|
|
|
|
{
|
|
|
|
return getUTF8StringLength((const UTF8*)utf8.c_str());
|
|
|
|
}
|
|
|
|
|
2016-03-07 18:59:53 +08:00
|
|
|
|
|
|
|
StringUTF8::StringUTF8()
|
|
|
|
{
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
StringUTF8::StringUTF8(const std::string& newStr)
|
|
|
|
{
|
2016-03-11 20:09:50 +08:00
|
|
|
replace(newStr);
|
2016-03-07 18:59:53 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
StringUTF8::~StringUTF8()
|
|
|
|
{
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
std::size_t StringUTF8::length() const
|
|
|
|
{
|
|
|
|
return _str.size();
|
|
|
|
}
|
|
|
|
|
2016-03-11 20:09:50 +08:00
|
|
|
void StringUTF8::replace(const std::string& newStr)
|
2016-03-07 18:59:53 +08:00
|
|
|
{
|
|
|
|
_str.clear();
|
|
|
|
if (!newStr.empty())
|
|
|
|
{
|
|
|
|
UTF8* sequenceUtf8 = (UTF8*)newStr.c_str();
|
|
|
|
|
|
|
|
int lengthString = getUTF8StringLength(sequenceUtf8);
|
|
|
|
|
|
|
|
if (lengthString == 0)
|
|
|
|
{
|
|
|
|
CCLOG("Bad utf-8 set string: %s", newStr.c_str());
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
while (*sequenceUtf8)
|
|
|
|
{
|
|
|
|
std::size_t lengthChar = getNumBytesForUTF8(*sequenceUtf8);
|
|
|
|
|
|
|
|
CharUTF8 charUTF8;
|
|
|
|
charUTF8._char.append((char*)sequenceUtf8, lengthChar);
|
|
|
|
sequenceUtf8 += lengthChar;
|
|
|
|
|
|
|
|
_str.push_back(charUTF8);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
std::string StringUTF8::getAsCharSequence() const
|
2017-10-17 11:03:32 +08:00
|
|
|
{
|
|
|
|
return getAsCharSequence(0, std::numeric_limits<std::size_t>::max());
|
|
|
|
}
|
|
|
|
|
|
|
|
std::string StringUTF8::getAsCharSequence(std::size_t pos) const
|
|
|
|
{
|
|
|
|
return getAsCharSequence(pos, std::numeric_limits<std::size_t>::max());
|
|
|
|
}
|
|
|
|
|
|
|
|
std::string StringUTF8::getAsCharSequence(std::size_t pos, std::size_t len) const
|
2016-03-07 18:59:53 +08:00
|
|
|
{
|
|
|
|
std::string charSequence;
|
2017-10-17 11:03:32 +08:00
|
|
|
std::size_t maxLen = _str.size() - pos;
|
|
|
|
if (len > maxLen)
|
|
|
|
{
|
|
|
|
len = maxLen;
|
|
|
|
}
|
2016-03-07 18:59:53 +08:00
|
|
|
|
2017-10-17 11:03:32 +08:00
|
|
|
std::size_t endPos = len + pos;
|
|
|
|
while (pos < endPos)
|
2016-03-07 18:59:53 +08:00
|
|
|
{
|
2017-10-17 11:03:32 +08:00
|
|
|
charSequence.append(_str[pos++]._char);
|
2016-03-07 18:59:53 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
return charSequence;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool StringUTF8::deleteChar(std::size_t pos)
|
|
|
|
{
|
|
|
|
if (pos < _str.size())
|
|
|
|
{
|
|
|
|
_str.erase(_str.begin() + pos);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
bool StringUTF8::insert(std::size_t pos, const std::string& insertStr)
|
|
|
|
{
|
|
|
|
StringUTF8 utf8(insertStr);
|
|
|
|
|
|
|
|
return insert(pos, utf8);
|
|
|
|
}
|
|
|
|
|
|
|
|
bool StringUTF8::insert(std::size_t pos, const StringUTF8& insertStr)
|
|
|
|
{
|
|
|
|
if (pos <= _str.size())
|
|
|
|
{
|
|
|
|
_str.insert(_str.begin() + pos, insertStr._str.begin(), insertStr._str.end());
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-05-08 11:10:54 +08:00
|
|
|
} //namespace StringUtils {
|
|
|
|
|
2013-02-27 15:16:49 +08:00
|
|
|
NS_CC_END
|