__STRING.cpp

Go to the documentation of this file.

#ifdef __DCL_INTERNAL__
 
#undef _T
#undef CHAR_T
#undef UCHAR_T
#undef BUFFER_T
#undef STRING_T
#undef ARRAY_T
 
#undef STRLEN
#undef STRCMP
#undef STRNCMP
#undef STRCASECMP
#undef STRNCASECMP
#undef VSNPRINTF
#undef STRCHR
#undef STRSTR
#undef ISSPACE
#undef ISALNUM
#undef TOUPPER
#undef TOLOWER
#undef TOUPPER_L
#undef TOLOWER_L
 
#ifdef __DCL_COMPILE_UNICODE__
    #define _T(s)                   L ## s
    #define CHAR_T                  wchar_t
    #define UCHAR_T                 wint_t
    #define BUFFER_T                CharBuffer
    #define STRING_T                String
    #define ARRAY_T                 StringArray
    #define STRING_BUILDER_T        StringBuilder
 
    #define STRLEN(s)               wcslen(s)
    #define STRCMP(s1, s2)          wcscmp(s1, s2)
    #define STRNCMP(s1, s2, n)      wcsncmp(s1, s2, n)
 
    #ifdef __WINNT__
        #define STRCASECMP(s1, s2)          _wcsicmp(s1, s2)
        #define STRNCASECMP(s1, s2, n)      _wcsnicmp(s1, s2, n)
        #define VSNPRINTF(buf, len, fmt, args)  _vsnwprintf(buf, len, fmt, args)
    #else
        #define STRCASECMP(s1, s2)          wcscasecmp(s1, s2)
        #define STRNCASECMP(s1, s2, n)      wcsncasecmp(s1, s2, n)
        #define VSNPRINTF(buf, len, fmt, args)  vswprintf(buf, len, fmt, args)
    #endif
 
    #define STRCHR(s, c)            wcschr(s, c)
    #define STRSTR(s, cs)           wcsstr(s, cs)
    #define ISSPACE(c)              iswspace(c)
    #define ISALNUM(c)              iswalnum(c)
    #define TOUPPER(c)              towupper(c)
    #define TOLOWER(c)              towlower(c)
    #define TOUPPER_L(c, l)         towupper(c, l)
    #define TOLOWER_L(c, l)         towlower(c, l)
#else    // __DCL_COMPILE_UNICODE__
    #define _T(s)                   s
    #define CHAR_T                  char
    #define UCHAR_T                 unsigned char
    #define BUFFER_T                ByteBuffer
    #define STRING_T                ByteString
    #define ARRAY_T                 ByteStringArray
    #define STRING_BUILDER_T        ByteStringBuilder
 
    #define STRLEN(s)               strlen(s)
    #define STRCMP(s1, s2)          strcmp(s1, s2)
    #define STRNCMP(s1, s2, n)      strncmp(s1, s2, n)
 
    #ifdef __WINNT__
        #define STRCASECMP(s1, s2)          _stricmp(s1, s2)
        #define STRNCASECMP(s1, s2, n)      _strnicmp(s1, s2, n)
        #define VSNPRINTF(buf, len, fmt, args)  _vsnprintf(buf, len, fmt, args)
    #else
        #define STRCASECMP(s1, s2)          strcasecmp(s1, s2)
        #define STRNCASECMP(s1, s2, n)      strncasecmp(s1, s2, n)
        #define VSNPRINTF(buf, len, fmt, args)  vsnprintf(buf, len, fmt, args)
    #endif
 
    #define STRCHR(s, c)            strchr(s, c)
    #define STRSTR(s, cs)           strstr(s, cs)
    #define ISSPACE(c)              isspace(c)
    #define ISALNUM(c)              isalnum(c)
    #define TOUPPER(c)              toupper(c)
    #define TOLOWER(c)              tolower(c)
    #define TOUPPER_L(c, l)         toupper_l(c, l)
    #define TOLOWER_L(c, l)         tolower_l(c, l)
#endif
 
#if __DCL_HAVE_THIS_FILE__
    #undef __THIS_FILE__
    static const char_t __CONCAT(__sz_STRING_T_cpp, CHAR_T)[] =
        __CONCAT_TEXT("dcl/__STRING.cpp/", CHAR_T);
    #define __THIS_FILE__    __CONCAT(__sz_STRING_T_cpp, CHAR_T)
#endif
 
long BUFFER_T::addRef()
{
    long n = Thread::incrementAndGet(__refCount);
    return n;
}
 
long BUFFER_T::release()
{    
    __DCL_ASSERT_PARAM(__refCount > 0);    // __DCL_ASSERT_VALID(this);
    long n = Thread::decrementAndGet(__refCount);
    if (n == 0)
        BUFFER_T::destroy(this);
    return n;
}
 
#ifndef __EXTENDED_LENGTH_DEFINED
#define __EXTENDED_LENGTH_DEFINED
size_t __extended_length(size_t _allocLength)
{
    if (_allocLength <= 32)
        _allocLength = 32;
    else if (_allocLength <= 64)
        _allocLength = 64;
    else if (_allocLength <= 128)
        _allocLength = 128;
    else if (_allocLength <= 256)
        _allocLength = 256;
    else if (_allocLength <= 512)
        _allocLength = 512;
    else if (_allocLength <= 1024)
        _allocLength = 1024;
    else {
        size_t m = _allocLength / 2048;
        if (_allocLength % 2048)
            m++;
        _allocLength = m * 2048;
    }
    return _allocLength;
}
#endif
 
#if defined(__GNUC__) && !defined(__clang__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wfree-nonheap-object"
#endif
void BUFFER_T::destroy(BUFFER_T* _buf)
{
    free(_buf);
}
#if defined(__GNUC__) && !defined(__clang__)
#pragma GCC diagnostic pop
#endif
 
BUFFER_T* BUFFER_T::create(size_t _len)
{
    BUFFER_T* buf = (BUFFER_T*)
        malloc(sizeof(BUFFER_T) + (sizeof(CHAR_T) * (_len + 1)));
 
    if (buf) {
        buf->__refCount = 1;
        buf->__allocLength = _len;
        buf->__dataLength = 0;
        buf->data()[buf->__dataLength] = _T('\0');
    }
    /*
    else {
        throw BadAllocException
    }
    */
    return buf;
}
 
BUFFER_T* BUFFER_T::create_e(size_t _len)
{
    return BUFFER_T::create(__extended_length(_len));
}
 
void BUFFER_T::extend(BUFFER_T*& _buf, size_t _len)
{
    __DCL_ASSERT_PARAM(_buf != NULL);
    __DCL_ASSERT_PARAM(_buf->__allocLength < _len);
 
    _len = __extended_length(_len);
 
    BUFFER_T* buf = (BUFFER_T*)
        realloc(_buf, sizeof(BUFFER_T) + (sizeof(CHAR_T) * (_len + 1)));
 
    // buf와 _buf는 같지 않을 수 있다.
    if (buf) {
        _buf = buf;
        _buf->__allocLength = _len;
    }
    /*
    else {
        throw BadAllocException
    }
    */
}
 
void BUFFER_T::shrink(BUFFER_T*& _buf)
{
    __DCL_ASSERT_PARAM(_buf != NULL);
    if (_buf->__dataLength < _buf->__allocLength) {
        size_t _len = _buf->__dataLength;
        BUFFER_T* buf = (BUFFER_T*)
            realloc(_buf, sizeof(BUFFER_T) + (sizeof(CHAR_T) * (_len + 1)));
 
        if (buf) {
            _buf = buf;
            _buf->__allocLength = _len;
            _buf->data()[_buf->__dataLength] = _T('\0');
        }
        else {
            // throw new BadAllocException
        }
    }
}
 
void BUFFER_T::write(BUFFER_T*& _buf, const CHAR_T* _p, size_t _len)
{
    size_t avail = _buf->__allocLength - _buf->__dataLength;
    if (avail < _len) {
        BUFFER_T::extend(_buf, _buf->__allocLength + _len);
    }
    memcpy(_buf->data() + _buf->__dataLength, _p, _len * sizeof(CHAR_T));
    _buf->__dataLength += _len;
    _buf->data()[_buf->__dataLength] = _T('\0');
}
 
void BUFFER_T::write(BUFFER_T*& _buf, CHAR_T _ch)
{
    write(_buf, &_ch, 1);
}
 
int BUFFER_T::vformat(BUFFER_T*& _buf, const CHAR_T* _format, va_list _arglist)
{
    __DCL_ASSERT_PARAM(_format != NULL);
 
#if defined(__DCL_COMPILE_UNICODE__) && defined(_MSC_VER)
    String format;
    if (STRSTR(_format, L"%s")) {
        __DCL_TRACE3(L"Warning!! vformat _format [%ls] included [%ls]. replaced to [%ls]\n",
            _format, L"%s", L"%hs");
        format.assign(_format);
        format = format.replace(L"%s", L"%hs");
        _format = format;
    }
#endif
 
#define __EXTENDED_MAX  1024 * 1024
#define __EXTEND_MIN    32
    int n = 0;
    size_t extend =  __MAX(_buf->__allocLength - _buf->__dataLength, __EXTEND_MIN);
    size_t extended = _buf->__dataLength + extend;
    while (extended < __EXTENDED_MAX) {
        if (_buf->__allocLength < extended) {
            BUFFER_T::extend(_buf, extended);
        }
 
        va_list arglist;
        va_copy(arglist, _arglist);
        n = VSNPRINTF(
            _buf->data() + _buf->__dataLength,
            _buf->__allocLength - _buf->__dataLength,
            _format,
            arglist
        );
        va_end(arglist);
 
        // 버퍼가 부족한 경우, MSVC는 -1을 반환한다.
        // GNUC는 버퍼의 size로 문자열이 잘려지고, 만들어진 문자의 개수를 반환한다.
        // GNUC의 경우 arg 중 하나라도 문자열의 길이가 버퍼보다 길면 -1을 반환한다.
        if (0 <= n && (size_t)n <= (_buf->__allocLength - _buf->__dataLength)) {
            _buf->__dataLength += n;
            _buf->data()[_buf->__dataLength] = _T('\0');
            return n;
        }
 
        extend *= 2;
        if (n > 0) {
            extend = __MAX(extend, n);
        }        
        extended += extend;
        __DCL_TRACE2(__T("VSNPRINTF Failed(%d) extend[%zd] and Retry\n"), n, extend);
    }
    // throw new BadAllocException;
 
    // EXTEND_MAX 10MB 만큼 버퍼를 할당했음에도 불구하고 VSNPRINTF를 실패했다.
    __DCL_TRACE2(__T("Warning!! VSNPRINTF Failed(%d) extend[%zd]\n"), n, extend);
    return n;
}
 
#undef __EMPTY_STR
#undef __EMPTY
 
static const struct __CONCAT(__EMPTY_STRING, CHAR_T) {
    BUFFER_T    __buf;
    CHAR_T        __nil;
} __CONCAT(__empty__, CHAR_T) = { {0, 0, 0}, _T('\0') };
 
#define __EMPTY_STR  __CONCAT(__empty, CHAR_T)
CHAR_T* __EMPTY_STR() {
    return ((CHAR_T*)& __CONCAT(__empty__, CHAR_T).__nil);
}
 
#define __EMPTY        __EMPTY_STR()
 
void STRING_T::assignAlloc(size_t _len)
{
    __DCL_ASSERT_PARAM(_len > 0);
 
    BUFFER_T* buf = __buf();
    if (buf->__refCount == 0) {
        __DCL_ASSERT(__psz == __EMPTY);
        buf = BUFFER_T::create(_len);
    }
    else {
        __DCL_ASSERT(__psz != __EMPTY);
        buf->release();
        buf = BUFFER_T::create(_len);
    }
    __psz = buf->data();
    // assignAlloc을 호출한 곳에는 '\0' 설정하지 않는다.
    __psz[_len] = _T('\0');
}
 
STRING_T::~STRING_T()
{
    if (__psz != __EMPTY) {
        __DCL_ASSERT(__buf()->__refCount != 0);
        __buf()->release();
    }
}
 
STRING_T::STRING_T()
{
    __psz = __EMPTY;
}
 
STRING_T::STRING_T(BUFFER_T* _buf)
{
    __DCL_ASSERT_PARAM(_buf != NULL);
    __DCL_ASSERT(_buf->__refCount >= 1);
 
    __psz = __EMPTY;
    assign(_buf);
}
 
STRING_T::STRING_T(const STRING_T& _str)
{
    __psz = __EMPTY;
    assign(_str);
}
 
STRING_T::STRING_T(CHAR_T _ch, size_t _repeat)    // = 1);
{
    __psz = __EMPTY;
    assign(_ch, _repeat);
}
 
STRING_T::STRING_T(const CHAR_T* _psz, size_t _start, size_t _len)
{
    __psz = __EMPTY;
    assign(_psz, _start, _len);
}
 
STRING_T::STRING_T(const CHAR_T* _psz, size_t _len)    // = (size_t)-1 )
{
    __psz = __EMPTY;
    assign(_psz, _len);
}
 
STRING_T::STRING_T(const CHAR_T* _begin, const CHAR_T* _end)
{
    __psz = __EMPTY;
    assign(_begin, _end);
}
 
STRING_T& STRING_T::assign(BUFFER_T* _buf)
{
    __DCL_ASSERT_PARAM(_buf != NULL);
    __DCL_ASSERT(_buf->__refCount >= 1);
    if (__psz != _buf->data()) {
        if (__psz != __EMPTY)
            __buf()->release();
        __psz = _buf->data();
        _buf->addRef();
    }
    return *this;
}
 
STRING_T& STRING_T::assign(const STRING_T& _str)
{
    if (__psz != _str.__psz) {
        if (_str.__buf()->__refCount > 0) {
            __DCL_ASSERT(_str.__psz != __EMPTY);
            if (__psz != __EMPTY)
                __buf()->release();
            __psz = _str.__psz;
            __buf()->addRef();
        }
        else {
            // -1, 0
            assign(_str, _str.length());
        }
    }
    return *this;
}
 
STRING_T& STRING_T::assign(CHAR_T _ch, size_t _repeat)    // = 1)
{
    if (_repeat) {
        assignAlloc(_repeat);
 
        CHAR_T* p = __psz;
        CHAR_T* _end = p + _repeat;
        while(p < _end)
            *p++ = _ch;
 
        __buf()->__dataLength = _repeat;
        __DCL_ASSERT(__psz[_repeat] == _T('\0'));
    }
    else
        clear();
 
    return *this;
}
 
STRING_T& STRING_T::assign(const CHAR_T* _ps, size_t _start, size_t _len)
{
    __DCL_ASSERT_PARAM(_ps != NULL);
    if (_len) {
        assignAlloc(_len);
 
        memcpy(__psz, _ps + _start, _len * sizeof(CHAR_T));
 
        __buf()->__dataLength = _len;
        __DCL_ASSERT(__psz[_len] == _T('\0'));
    }
    else
        clear();
 
    return *this;
}
 
STRING_T& STRING_T::assign(const CHAR_T* _psz, size_t _len) // = (size_t)-1);
{
    if (_len == (size_t)-1)
        _len = STRING_T::length(_psz);
    return assign(_psz, 0, _len);
}
 
STRING_T& STRING_T::assign(const CHAR_T* _begin, const CHAR_T* _end)
{
    __DCL_ASSERT_PARAM(_begin <= _end);
    return assign(_begin, 0, _end - _begin);
}
 
void STRING_T::assign(
    const CHAR_T* _ps1, size_t _len1,
    const CHAR_T* _ps2, size_t _len2
)
{
    __DCL_ASSERT_PARAM(_ps1 != NULL && _ps2 != NULL);
 
    size_t _len = _len1 + _len2;
    if (_len) {
        assignAlloc(_len);
 
        memcpy(__psz, _ps1, _len1 * sizeof(CHAR_T));
        memcpy(__psz + _len1, _ps2, _len2 * sizeof(CHAR_T));
 
        __buf()->__dataLength = _len;
        __DCL_ASSERT(__psz[_len] == _T('\0'));
    }
    else
        clear();
}
 
void STRING_T::clear()
{
    if (__psz != __EMPTY) {
        __buf()->release();
        __psz = __EMPTY;
    }
}
 
DCLCAPI STRING_T operator + (const STRING_T& _str1, const STRING_T& _str2)
{
    STRING_T r;
    r.assign(_str1, _str1.length(), _str2, _str2.length());
    return r;
}
 
DCLCAPI STRING_T operator + (const STRING_T& _str, CHAR_T _ch)
{
    STRING_T r;
    r.assign(_str, _str.length(), &_ch, 1);
    return r;
}
 
DCLCAPI STRING_T operator + (CHAR_T _ch, const STRING_T& _str)
{
    STRING_T r;
    r.assign(&_ch, 1, _str, _str.length());
    return r;
}
 
DCLCAPI STRING_T operator + (const STRING_T& _str, const CHAR_T* _psz)
{
    __DCL_ASSERT_PARAM(_psz != NULL);
    STRING_T r;
    r.assign(_str, _str.length(), _psz, STRING_T::length(_psz));
    return r;
}
 
DCLCAPI STRING_T operator + (const CHAR_T* _psz, const STRING_T& _str)
{
    __DCL_ASSERT_PARAM(_psz != NULL);
    STRING_T r;
    r.assign(_psz, STRING_T::length(_psz), _str, _str.length());
    return r;
}
 
// return (size_t)-1 not found
size_t STRING_T::indexOf(CHAR_T _ch, size_t _start) const
{
    __DCL_ASSERT_PARAM(_start <= length());
    const CHAR_T* p = STRING_T::find(__psz + _start,
        __psz + length(), _ch);
    if (p)
        return p - __psz;
    return (size_t)-1;
}
 
size_t STRING_T::indexOf(const CHAR_T* _psz, size_t _start) const
{
    __DCL_ASSERT_PARAM(_start <= length());
    __DCL_ASSERT_PARAM(_psz != NULL);
 
    const CHAR_T* p = STRSTR(__psz + _start, _psz);
    if (p)
        return p - __psz;
    return (size_t)-1;
}
 
size_t STRING_T::indexOf(const STRING_T& _str, size_t _start) const
{
    __DCL_ASSERT_PARAM(_start <= length());
    const CHAR_T* p = STRING_T::find(
        __psz + _start, __psz + length(),
        _str, _str.length()
    );
    if (p)
        return p - __psz;
    return (size_t)-1;
}
 
size_t STRING_T::lastIndexOf(CHAR_T _ch, size_t _start)    const
{
    __DCL_ASSERT_PARAM(_start <= length());
    const CHAR_T* p = STRING_T::rfind(
        __psz, __psz + length() - _start,
        _ch
    );
    if (p)
        return p - __psz;
    return (size_t)-1;
}
 
size_t STRING_T::lastIndexOf(const CHAR_T* _psz, size_t _start)    const
{
    __DCL_ASSERT_PARAM(_start <= length());
    __DCL_ASSERT_PARAM(_psz != NULL);
    const CHAR_T* p = STRING_T::rfind(
        __psz, __psz + length() - _start,
        _psz, STRING_T::length(_psz)
    );
    if (p)
        return p - __psz;
    return (size_t)-1;
}
 
size_t STRING_T::lastIndexOf(const STRING_T& _str, size_t _start) const
{
    __DCL_ASSERT_PARAM(_start <= length());
    const CHAR_T* p = STRING_T::rfind(
        __psz, __psz + length() - _start,
        _str, _str.length()
    );
    if (p)
        return p - __psz;
    return (size_t)-1;
}
 
int STRING_T::compare(
    const CHAR_T* psz1,
    const CHAR_T* psz2, size_t _len    // = (size_t)-1);
)
{
    __DCL_ASSERT_PARAM(psz1 != NULL && psz2 != NULL);
 
    if (_len == (size_t)-1)
        return STRCMP(psz1, psz2);
    else
        return STRNCMP(psz1, psz2, _len);
}
 
int STRING_T::compareNoCase(
    const CHAR_T* psz1,
    const CHAR_T* psz2, size_t _len    // = (size_t)-1);
)
{
    __DCL_ASSERT_PARAM(psz1 != NULL && psz2 != NULL);
 
    if (_len == (size_t)-1)
        return STRCASECMP(psz1, psz2);
    else
        return STRNCASECMP(psz1, psz2, _len);
}
 
STRING_T STRING_T::mid(
    size_t _first, size_t _len         // = (size_t)-1) const;
) const
{
    __DCL_ASSERT_PARAM(_first <= length());
 
    if (_len == (size_t)-1)
        _len = length() - _first;
 
    __DCL_ASSERT((_first + _len) <= length());
 
    if (_first == 0 && _len == length())
        return *this;
 
    return STRING_T(__psz, _first, _len);
}
 
STRING_T STRING_T::left(size_t _len) const
{
    return mid(0, _len);
}
 
STRING_T STRING_T::right(size_t _len) const
{
    if (length() < _len)
        _len = length();
    return mid(length() - _len, _len);
}
 
STRING_T STRING_T::padCenter(size_t _len, CHAR_T _ch) const
{
    if (_len <= length()) {
        return mid((length() - _len) / 2, _len);
    }
 
    BUFFER_T* buf = BUFFER_T::create(_len);
    buf->__dataLength = _len;
 
    CHAR_T* dst = buf->data();
    CHAR_T* end = dst + ((_len - length()) / 2);
    while (dst < end) {
        *dst++ = _ch;
    }
 
    end = dst + length();
    const CHAR_T* src = __psz;
    while (dst < end) {
        *dst++ = *src++;
    }
 
    end = buf->data() + _len;
    *end = _T('\0');
    while (dst < end) {
        *dst++ = _ch;
    }
    __DCL_ASSERT(*(buf->data() + _len) == _T('\0'));
 
    STRING_T r = buf;
    buf->release();
    return r;
}
 
STRING_T STRING_T::padLeft(size_t _len, CHAR_T _ch) const
{
    if (_len <= length()) {
        return mid(length() - _len, _len);
    }
 
    BUFFER_T* buf = BUFFER_T::create(_len);
    buf->__dataLength = _len;
 
    CHAR_T* dst = buf->data();
    CHAR_T* end = dst + (_len - length());
    while (dst < end) {
        *dst++ = _ch;
    }
 
    end = buf->data() + _len;
    *end = _T('\0');
    const CHAR_T* src = __psz;
    while (dst < end) {
        *dst++ = *src++;
    }
 
    __DCL_ASSERT(*(buf->data() + _len) == _T('\0'));
 
    STRING_T r = buf;
    buf->release();
    return r;
}
 
STRING_T STRING_T::padRight(size_t _len, CHAR_T _ch) const
{
    if (_len <= length()) {
        return mid(0, _len);
    }
 
    BUFFER_T* buf = BUFFER_T::create(_len);
    buf->__dataLength = _len;
 
    CHAR_T* dst = buf->data();
    CHAR_T* end = dst + length();
    const CHAR_T* src = __psz;
    while (dst < end) {
        *dst++ = *src++;
    }
 
    end = buf->data() + _len;
    *end = _T('\0');
    while (dst < end) {
        *dst++ = _ch;
    }
    __DCL_ASSERT(*(buf->data() + _len) == _T('\0'));
 
    STRING_T r = buf;
    buf->release();
    return r;
}
 
STRING_T STRING_T::replace(
    size_t _start, size_t _len,
    const CHAR_T* _new, size_t _newlen
) const
{
    __DCL_ASSERT_PARAM((_start + _len) <= length());
    __DCL_ASSERT_PARAM(_new != NULL);
 
    if (_newlen == (size_t)-1)
        _newlen = STRING_T::length(_new);
 
    size_t len = length() - _len + _newlen;
    BUFFER_T* buf = BUFFER_T::create(len);
    buf->__dataLength = len;
    CHAR_T* p = buf->data();
    *(p + len) = _T('\0');
 
    memcpy(p, __psz, _start * sizeof(CHAR_T));
    memcpy(p + _start, _new, _newlen * sizeof(CHAR_T));
    memcpy(p + _start + _newlen, __psz + _start + _len,
        (length() - (_start + _len)) * sizeof(CHAR_T));
 
    __DCL_ASSERT(p[buf->__dataLength] == _T('\0'));
 
    STRING_T r(buf);
    buf->release();
    return r;
}
 
STRING_T STRING_T::rreplace(
    size_t _start, size_t _len,
    const CHAR_T* _new, size_t _newlen
) const
{
    __DCL_ASSERT_PARAM((_start + _len) <= length());
    __DCL_ASSERT_PARAM(_new != NULL);
    return replace(length() - _start - _len, _len, _new, _newlen);
}
 
STRING_T STRING_T::replace(CHAR_T _old, CHAR_T _new) const
{
    if (_old == _new || __psz == __EMPTY) {
        return *this;
    }
 
    BUFFER_T* buf = BUFFER_T::create(length());
    buf->__dataLength = length();
 
    CHAR_T* dst = buf->data();
    CHAR_T* end = dst + buf->__dataLength;
    *end = _T('\0');
    const CHAR_T* src = __psz;
 
    while (dst < end) {
        *dst++ = *src == _old ? _new : *src;
        src++;
    }
    __DCL_ASSERT(*(buf->data() + buf->__dataLength) == _T('\0'));
 
    STRING_T r = buf;
    buf->release();
    return r;
}
 
STRING_T STRING_T::replace(
    const CHAR_T* _old, size_t _oldlen,
    const CHAR_T* _new, size_t _newlen
) const
{
    __DCL_ASSERT_PARAM(_old != NULL && _new != NULL);
 
    if (_oldlen == 0 || __psz == __EMPTY) {
        return *this;
    }
 
    size_t count = 0;
    const CHAR_T* _start = __psz;
    const CHAR_T* _end = _start + length();
    const CHAR_T* _sub;
    while ((_sub = STRING_T::find(_start, _end, _old, _oldlen)) != NULL) {
        count++;
        _start = _sub + _oldlen;
    }
 
    if (!count) {
        return *this;
    }
 
    size_t allocLength = length() + (count * _newlen) - (count * _oldlen);
    BUFFER_T* buf = BUFFER_T::create(allocLength);
    buf->__dataLength = allocLength;
    CHAR_T* dst = buf->data();
    *(dst + allocLength) = _T('\0');
    size_t _len = 0;
    _start = __psz;
    while ((_sub = STRING_T::find(_start, _end, _old, _oldlen)) != NULL) {
        _len = _sub - _start;
        memcpy(dst, _start, _len * sizeof(CHAR_T));
        dst += _len;
        memcpy(dst, _new, _newlen * sizeof(CHAR_T));
        dst += _newlen;
 
        _start = _sub + _oldlen;
    }
    _len = _end - _start;
    memcpy(dst, _start, _len * sizeof(CHAR_T));
#ifdef __DCL_DEBUG
    dst += _len;
    __DCL_ASSERT((dst >= buf->data()) && ((size_t) (dst - buf->data()) == allocLength));
#endif
    __DCL_ASSERT(*(buf->data() + buf->__dataLength) == _T('\0'));
 
    STRING_T r = buf;
    buf->release();
    return r;
}
 
size_t STRING_T::search(
    const CHAR_T* _regex,
    bool _icase
) const __DCL_THROWS1(RegexException*)
{
    __DCL_ASSERT_PARAM(_regex != NULL);
    return __regex_search(
        _regex, _regex + STRING_T::length(_regex),
        __psz, __psz + length(),
        _icase
    );
}
 
size_t STRING_T::search(
    const STRING_T& _regex,
    bool _icase
) const __DCL_THROWS1(RegexException*)
{
    return __regex_search(
        _regex.__psz, _regex.__psz + _regex.length(),
        __psz, __psz + length(),
        _icase
    );
}
 
STRING_T STRING_T::substring(
    const CHAR_T* _regex,
    bool _icase
) const __DCL_THROWS1(RegexException*)
{
    __DCL_ASSERT_PARAM(_regex != NULL);
    return __regex_substring(
        _regex, _regex + STRING_T::length(_regex),
        __psz, __psz + length(),
        _icase
    );
}
 
STRING_T STRING_T::substring(
    const STRING_T& _regex,
    bool _icase
) const __DCL_THROWS1(RegexException*)
{
    return __regex_substring(
        _regex.__psz, _regex.__psz + _regex.length(),
        __psz, __psz + length(),
        _icase
    );
}
 
bool STRING_T::searches(
    const CHAR_T* _regex,
    bool _icase
) const __DCL_THROWS1(RegexException*)
{
    __DCL_ASSERT_PARAM(_regex != NULL);
    return __regex_search(
        _regex, _regex + STRING_T::length(_regex),
        __psz, __psz + length(),
        _icase
    ) != (size_t)-1;
}
 
bool STRING_T::searches(
    const STRING_T& _regex,
    bool _icase
) const __DCL_THROWS1(RegexException*)
{
    return __regex_search(
        _regex.__psz, _regex.__psz + _regex.length(),
        __psz, __psz + length(),
        _icase
    ) != (size_t)-1;
}
 
bool STRING_T::matches(
    const CHAR_T* _regex,
    bool _icase
) const __DCL_THROWS1(RegexException*)
{
    __DCL_ASSERT_PARAM(_regex != NULL);
    return __regex_matches(
        _regex, _regex + STRING_T::length(_regex),
        __psz, __psz + length(),
        _icase
    );
}
 
bool STRING_T::matches(
    const STRING_T& _regex,
    bool _icase
    ) const __DCL_THROWS1(RegexException*)
{
    return __regex_matches(
        _regex.__psz, _regex.__psz + _regex.length(),
        __psz, __psz + length(),
        _icase
    );
}
 
STRING_T STRING_T::replace_r(
    const CHAR_T* _regex,
    const CHAR_T* _replacment,
    bool _icase,
    size_t _limit // = (size_t)-1
) const  __DCL_THROWS1(RegexException*)
{
    __DCL_ASSERT_PARAM(_regex != NULL);
    __DCL_ASSERT_PARAM(_replacment != NULL);
    return __regex_replace(
        _regex, _regex + STRING_T::length(_regex),
        __psz, __psz + length(),
        _replacment, _replacment + STRING_T::length(_replacment),
        _icase,
        _limit
    );
}
 
STRING_T STRING_T::replace_r(
    const STRING_T& _regex,
    const STRING_T& _replacement,
    bool _icase,
    size_t _limit // = (size_t)-1
) const __DCL_THROWS1(RegexException*)
{
    return __regex_replace(
        _regex.__psz, _regex.__psz + _regex.length(),
        __psz, __psz + length(),
        _replacement.__psz, _replacement.__psz + _replacement.length(),
        _icase,
        _limit
    );
}
 
ARRAY_T& STRING_T::split_r(
    const CHAR_T* _regex,
    bool _icase,
    ARRAY_T& _results,
    size_t _limit // = (size_t)-1
) const __DCL_THROWS1(RegexException*)
{
    __DCL_ASSERT_PARAM(_regex != NULL);
    return __regex_split(
        _regex, _regex + STRING_T::length(_regex),
        __psz, __psz + length(),
        _icase,
        _results,
        _limit
    );
}
 
ARRAY_T& STRING_T::split_r(
    const STRING_T& _regex,
    bool _icase,
    ARRAY_T& _results,
    size_t _limit // = (size_t)-1
) const __DCL_THROWS1(RegexException*)
{
    return __regex_split(
         _regex.__psz, _regex.__psz + _regex.length(),
        __psz, __psz + length(),
        _icase,
        _results,
        _limit
    );
}
 
STRING_T STRING_T::toUpperCase() const
{
    BUFFER_T* buf = BUFFER_T::create(length());
    CHAR_T* dst = buf->data();
    const CHAR_T* src = __psz;
    const CHAR_T* _end = __psz + length();
    while (src < _end) {
        *dst = TOUPPER((UCHAR_T)*src);
        src++;
        dst++;
    }
    *dst = _T('\0');
    buf->__dataLength = dst - buf->data();
 
    STRING_T r(buf);
    buf->release();
    return r;
}
 
STRING_T STRING_T::toLowerCase() const
{
    BUFFER_T* buf = BUFFER_T::create(length());
    CHAR_T* dst = buf->data();
    const CHAR_T* src = __psz;
    const CHAR_T* _end = __psz + length();
    while (src < _end) {
        *dst = TOLOWER((UCHAR_T)*src);
        src++;
        dst++;
    }
    *dst = _T('\0');
    buf->__dataLength = dst - buf->data();
 
    STRING_T r(buf);
    buf->release();
    return r;
}
 
#ifdef __DCL_INCLUDED_LOCALE_H
STRING_T STRING_T::toUpperCase(locale_t _locale) const
{
    BUFFER_T* buf = BUFFER_T::create(length());
    CHAR_T* dst = buf->data();
    const CHAR_T* src = __psz;
    const CHAR_T* _end = __psz + length();
    while (src < _end) {
        *dst = TOUPPER_L((UCHAR_T)*src, __locale);
        src++;
        dst++;
    }
    *dst = _T('\0');
    buf->__dataLength = dst - buf->data();
 
    STRING_T r(buf);
    buf->release();
    return r;
}
 
STRING_T STRING_T::toLowerCase(locale_t _locale) const
{
    BUFFER_T* buf = BUFFER_T::create(length());
    CHAR_T* dst = buf->data();
    const CHAR_T* src = __psz;
    const CHAR_T* _end = __psz + length();
    while (src < _end) {
        *dst = TOLOWER_L((UCHAR_T)*src, __locale);
        src++;
        dst++;
    }
    *dst = _T('\0');
    buf->__dataLength = dst - buf->data();
 
    STRING_T r(buf);
    buf->release();
    return r;
}
#endif
 
#ifdef __DCL_COMPILE_UNICODE__
String STRING_T::toString() const
{
    return *this;
}
#else
String STRING_T::toString() const
{
    return String::toHexString(*this, 20);
}
#endif
 
STRING_T STRING_T::trim() const
{
    CHAR_T* first = __psz;
    CHAR_T* last = __psz + length();
 
    while(first < last) {
        if (!ISSPACE((UCHAR_T)*first))
            break;
        first++;
    }
 
    while(first < last) {
        if (!ISSPACE((UCHAR_T)*(last - 1)))
            break;
        last--;
    }
 
    __DCL_ASSERT(first <= last);
 
    if (__psz < first || last < __psz + length()) {
        size_t len = last - first;
        if (len) {
            BUFFER_T* buf = BUFFER_T::create(len);
            buf->__dataLength = len;
            CHAR_T* p = buf->data();
            *(p + len) = _T('\0');
            memcpy(p, first, len * sizeof(CHAR_T));
 
            STRING_T r = buf;
            buf->release();
            return r;
        }
    }
    return *this;
}
 
STRING_T STRING_T::trimLeft() const
{
    CHAR_T* first = __psz;
    CHAR_T* last = __psz + length();
 
    while (first < last) {
        if (!ISSPACE((UCHAR_T)*first))
            break;
        first++;
    }
 
    if (__psz < first) {
        size_t len = last - first;
        if (len) {
            BUFFER_T* buf = BUFFER_T::create(len);
            buf->__dataLength = len;
            CHAR_T* p = buf->data();
            *(p + len) = _T('\0');
            memcpy(p, first, len * sizeof(CHAR_T));
 
            STRING_T r = buf;
            buf->release();
            return r;
        }
    }
    return *this;
}
 
STRING_T STRING_T::trimRight() const
{
    CHAR_T* first = __psz;
    CHAR_T* last = __psz + length();
 
    while(first < last) {
        if (!ISSPACE((UCHAR_T)*(last - 1)))
            break;
        last--;
    }
 
    if (last < __psz + length()) {
        size_t len = last - first;
        if (len) {
            BUFFER_T* buf = BUFFER_T::create(len);
            buf->__dataLength = len;
            CHAR_T* p = buf->data();
            *(p + len) = _T('\0');
            memcpy(p, first, len * sizeof(CHAR_T));
 
            STRING_T r = buf;
            buf->release();
            return r;
        }
    }
    return *this;
}
 
STRING_T STRING_T::trim(const CHAR_T* _chars) const
{
    CHAR_T* first = __psz;
    CHAR_T* last = __psz + length();
 
    while (first < last) {
        if (STRCHR(_chars, (UCHAR_T)*first) == NULL)
            break;
        first++;
    }
 
    while (first < last) {
        if (STRCHR(_chars, (UCHAR_T)*(last - 1)) == NULL)
            break;
        last--;
    }
 
    __DCL_ASSERT(first <= last);
 
    if (__psz < first || last < __psz + length()) {
        size_t len = last - first;
        if (len) {
            BUFFER_T* buf = BUFFER_T::create(len);
            buf->__dataLength = len;
            CHAR_T* p = buf->data();
            *(p + len) = _T('\0');
            memcpy(p, first, len * sizeof(CHAR_T));
 
            STRING_T r = buf;
            buf->release();
            return r;
        }
        return STRING_T();
    }
    return *this;
}
 
STRING_T STRING_T::trimLeft(const CHAR_T* _chars) const
{
    CHAR_T* first = __psz;
    CHAR_T* last = __psz + length();
 
    while (first < last) {
        if (STRCHR(_chars, (UCHAR_T)*first) == NULL)
            break;
        first++;
    }
 
    if (__psz < first) {
        size_t len = last - first;
        if (len)
        {
            BUFFER_T* buf = BUFFER_T::create(len);
            buf->__dataLength = len;
            CHAR_T* p = buf->data();
            *(p + len) = _T('\0');
            memcpy(p, first, len * sizeof(CHAR_T));
 
            STRING_T r = buf;
            buf->release();
            return r;
        }
    }
    return *this;
}
 
STRING_T STRING_T::trimRight(const CHAR_T* _chars) const
{
    CHAR_T* first = __psz;
    CHAR_T* last = __psz + length();
 
    while (first < last) {
        if (STRCHR(_chars, (UCHAR_T)*(last - 1)) == NULL)
            break;
        last--;
    }
 
    if (last < __psz + length()) {
        size_t len = last - first;
        if (len) {
            BUFFER_T* buf = BUFFER_T::create(len);
            buf->__dataLength = len;
            CHAR_T* p = buf->data();
            *(p + len) = _T('\0');
            memcpy(p, first, len * sizeof(CHAR_T));
 
            STRING_T r = buf;
            buf->release();
            return r;
        }
    }
    return *this;
}
 
CHAR_T STRING_T::operator[](size_t _index) const
{
    __DCL_ASSERT(0 < length() && _index < length());
//    if (!(_index < __buf->__dataLength))
//        throw(new InvalidIndexException(0, __buf->__dataLength - 1, _index));
    return __psz[_index];
}
 
// static members
size_t STRING_T::length(
    const CHAR_T* _psz,
    size_t _max         //    = (size_t)-1,
)
{
    __DCL_ASSERT_PARAM(_psz != NULL);
    size_t r = 0;
    while (*_psz++ && r < _max) {
        r++;
    }
    return r;
}
 
STRING_T STRING_T::format(const CHAR_T* _format, ...)
{
    size_t len = STRING_T::length(_format) * 4;
    BUFFER_T* buf = BUFFER_T::create_e(len);
 
    va_list arglist;
    va_start(arglist, _format);
    int __UNUSED__ n = BUFFER_T::vformat(buf, _format, arglist);
    va_end(arglist);
 
    STRING_T r = buf;
    buf->release();
#ifdef __DCL_DEBUG
    const CHAR_T* p = r;
    __DCL_ASSERT(p[r.length()] == __T('\0'));
#endif
    return r;
}
 
#ifndef __A_HEX_DEFINED
#define __A_HEX_DEFINED
static const CHAR_T __hex__[] = _T("0123456789abcdef");
#endif
 
#define ASCII_32    _T(' ')
#define ASCII_126    _T('~')
 
bool __escapeable(unsigned int c, STRING_T::EscapeFlags _flag)
{
    bool r = false;
    if (_flag == STRING_T::ESCAPE_DEFAULT) {
        r = (c <= 0xff) && (c < ASCII_32 || ASCII_126 < c
            || c == _T('\"') || c == _T('\'') || c == _T('\\'));
    }
    else if (_flag == STRING_T::ESCAPE_EXTENDED) {
        r = ISALNUM(c) != 0;
    }
    else
        r = true;
 
    return r;
}
 
STRING_T STRING_T::escape(
    const CHAR_T*   _ps,
    size_t          _len,
    EscapeFlags     _flag    // = ESCAPE_DEFAULT
)
{
    __DCL_ASSERT_PARAM(_ps != NULL);
 
    if (_len == 0)
        return STRING_T();
 
    //                                                    javascript
    // byte_t   sizeof(CHAR_T) == 1        "\xff"          "%ff"
    // Windows  sizeof(CHAR_T) == 2        "\uffff"        "%uffff"
    // Linux    sizeof(CHAR_T) == 4        "\u00ffffff"    "%uffffff" ??
 
    BUFFER_T* buf = BUFFER_T::create(_len * 4);
    const UCHAR_T* src = (const UCHAR_T*) _ps;
    const UCHAR_T* _end = src + _len;
 
    if (_flag == ESCAPE_XML) {
        for( ; src < _end; src++) {
            CHAR_T c = *src;
            switch (c) {
            case _T('&') : BUFFER_T::write(buf, _T("&amp;"), 5); break;
            case _T('<') : BUFFER_T::write(buf, _T("&lt;"), 4); break;
            case _T('>') : BUFFER_T::write(buf, _T("&gt;"), 4); break;
            case _T('\"') : BUFFER_T::write(buf, _T("&quot;"), 6); break;
            case _T('\'') : BUFFER_T::write(buf, _T("&#39;"), 5); break;
            default:
                BUFFER_T::write(buf, c);
            }
        }
    }
    else {
        // ESCAPE_DEFAULT, ESCAPE_EXTENDED, ESCAPE_ALL
        for ( ; src < _end; src++) {
            unsigned int c = *src;
            if (__escapeable(c, _flag)) {
                BUFFER_T::write(buf, _T('\\'));
                switch(c) {
                case _T('\0') : BUFFER_T::write(buf, _T('0')); break;    // NULL
                case _T('\a') : BUFFER_T::write(buf, _T('a')); break;    // BEL, alert
                case _T('\b') : BUFFER_T::write(buf, _T('b')); break;    // backspace
                case _T('\t') : BUFFER_T::write(buf, _T('t')); break;    // horizontal tab
                case _T('\n') : BUFFER_T::write(buf, _T('n')); break;    // line feed, new line
                case _T('\v') : BUFFER_T::write(buf, _T('v')); break;    // vertical tab
                case _T('\f') : BUFFER_T::write(buf, _T('f')); break;    // form feed
                case _T('\r') : BUFFER_T::write(buf, _T('r')); break;    // carriage return
                case _T('\"') :                                // double quotation mark
                case _T('\'') :                                // single quotation mark
                case _T('\\') :                                // back slash
                    BUFFER_T::write(buf, c);
                    break;
                default :
                    if ( c <= 0xff) {
                        BUFFER_T::write(buf, _T('x'));
                        BUFFER_T::write(buf, __hex__[c >> 4]);
                        BUFFER_T::write(buf, __hex__[c & 0x0f]);
                    }
                    else if (c <= 0xffff) {
                        // 16bit unicode BMP
                        BUFFER_T::write(buf, _T('u'));
                        unsigned char a[4];
                        a[3] = c & 0x0f;
                        c >>= 4;
                        a[2] = c & 0x0f;
                        c >>= 4;
                        a[1] = c & 0x0f;
                        c >>= 4;
                        a[0] = c;
 
                        for(int i = 0; i < 4; i++)
                            BUFFER_T::write(buf, __hex__[a[i]]);
                    }
                    else {
                        BUFFER_T::write(buf, c);
                    }
                }
            }
            else
                BUFFER_T::write(buf, c);
        }
    }
 
    BUFFER_T::shrink(buf);
 
    STRING_T r(buf);
    buf->release();
    return r;
}
 
static int __hex2int(CHAR_T _c)
{
    if (_T('0') <= _c && _c <= _T('9'))
        return _c - _T('0');
    else if (_T('A') <= _c && _c <= _T('F'))
        return _c - _T('A') + 10;
    else if (_T('a') <= _c && _c <= _T('f'))
        return _c - _T('a') + 10;
    else {
        return -1;
    }
}
 
STRING_T STRING_T::unescape(
    const CHAR_T*       _psz,
    size_t              _len
)
{
    __DCL_ASSERT_PARAM(_psz != NULL);
    if (_len == (size_t)-1)
        _len = STRING_T::length(_psz);
 
    if (_len == 0)
        return STRING_T();
 
    BUFFER_T* buf = BUFFER_T::create(_len);
    const CHAR_T* src = (const CHAR_T*)_psz;
    const CHAR_T* end = src + _len;
 
    for ( ; src < end; src++) {
        if (*src == _T('\\') && (src + 1) < end) {
            switch (*++src) {
            case _T('0') : BUFFER_T::write(buf, _T('\0')); break;
            case _T('a') : BUFFER_T::write(buf, _T('\a')); break;
            case _T('b') : BUFFER_T::write(buf, _T('\b')); break;
            case _T('t') : BUFFER_T::write(buf, _T('\t')); break;
            case _T('n') : BUFFER_T::write(buf, _T('\n')); break;
            case _T('v') : BUFFER_T::write(buf, _T('\v')); break;
            case _T('f') : BUFFER_T::write(buf, _T('\f')); break;
            case _T('r') : BUFFER_T::write(buf, _T('\r')); break;
            case _T('\"') : 
            case _T('\'') :
//            case _T('\?') :
            case _T('\\') :
                BUFFER_T::write(buf, *src);
                break;
            case _T('x') :
            case _T('X') :
                if ((src + 2) < end) {
                    int high = __hex2int(src[1]);
                    int low = __hex2int(src[2]);
                    if (high >= 0 && low >= 0)
                    {
                        BUFFER_T::write(buf, (high << 4) | low);
                        src += 2;
                        break;
                    }
                }
                goto __no_escape;
            case _T('u') :
            case _T('U') :
                if ((src + 4) < end) {
                    int n;
                    UCHAR_T c = 0;
#ifdef __DCL_COMPILE_UNICODE__
                    for (int i = 1; i <= 4; i++) {
                        if ((n = __hex2int(src[i])) < 0)
                            goto __no_escape;
                        c = (c << 4) | n;
                    }
#else
                    for (int i = 1; i <= 4; i++) {
                        if ((n = __hex2int(src[i])) < 0)
                            goto __no_escape;
                        c = (c << 4) | n;
                        if (i == 1) {
                            BUFFER_T::write(buf, c);
                            c = 0;
                        }
                    }
#endif
                    BUFFER_T::write(buf, c);
                    src += 4;
                    break;
                }
            default :
__no_escape:
                BUFFER_T::write(buf, _T('\\'));
                BUFFER_T::write(buf, *src);
            }
        }
        else {
            // normal
            BUFFER_T::write(buf, *src);
        }
    }
    BUFFER_T::shrink(buf);
 
    STRING_T r(buf);
    buf->release();
    return r;
}
 
STRING_T STRING_T::toHexString(     // "\x..."
    const char*       _bytes,
    size_t            _len,
    size_t            _max,     //    = (size_t)-1,
    bool              _prefix   //    = true
)
{
    __DCL_ASSERT_PARAM(_bytes != NULL);
 
    size_t len = __MIN(_len, _max);
    /*
    size_t dstlen = len * 2;
    if (_prefix)        // "0x"
        dstlen += 2;
    if (_max <= _len)   // "..."
        dstlen += 3;
    */
    size_t dstlen = len * 2 + 5;
 
    BUFFER_T* buf = BUFFER_T::create(dstlen);
    CHAR_T* dst = buf->data();
    if (_prefix) {
        *dst++ = _T('\\');
        *dst++ = _T('x');
    }
 
    const byte_t* src = (const byte_t*) _bytes;
    const byte_t* end = src + len;
 
    while (src < end) {
        *dst++ = __hex__[*src >> 4];
        *dst++ = __hex__[*src & 0x0f];
        src++;
    }
 
    if (_max < _len) {
        *dst++ = _T('.');
        *dst++ = _T('.');
        *dst++ = _T('.');
    }
 
    *dst = _T('\0');
    //__DCL_TRACE2(__T("[%zd] [%zd]\n"), dstlen, dst - buf->data());
    __DCL_ASSERT(dst <= buf->data() + dstlen);
    buf->__dataLength = dst - buf->data();
 
    STRING_T r(buf);
    buf->release();
    return r;
}
 
STRING_T  STRING_T::tryString(
    const char*         _bytes,
    size_t              _len,
    size_t              _max    // = (size_t)-1
)
{
    // "12345\0\1\2\3\4\5"
    // "12345\x00\x01\x02\x03\x04\x05"
 
    __DCL_ASSERT_PARAM(_bytes != NULL);
 
    size_t len = __MIN(_len, _max);
    /*
    size_t dstlen = len * 4;        // \x01
    if (_max <= len)
        dstlen += 3;                // ...
    */
    size_t dstlen = len * 4 + 3;
 
    BUFFER_T* buf = BUFFER_T::create(dstlen);
    CHAR_T* dst = buf->data();
    const byte_t* src = (const byte_t*)_bytes;
    const byte_t* end = src + len;
 
    while (src < end) {
        if (isprint(*src)) {
            *dst++ = *src;
        }
        else {
            *dst++ = _T('\\');
            *dst++ = _T('x');
            *dst++ = __hex__[*src >> 4];
            *dst++ = __hex__[*src & 0x0f];
        }
        src++;
    }
 
    if (_max < _len) {
        *dst++ = _T('.');
        *dst++ = _T('.');
        *dst++ = _T('.');
    }
 
    *dst = _T('\0');
     //__DCL_TRACE2(__T("[%zd] [%zd]\n"), dstlen, dst - buf->data());
    __DCL_ASSERT(dst <= buf->data() + dstlen);
    buf->__dataLength = dst - buf->data();
 
    STRING_T r(buf);
    buf->release();
    return r;
}
 
CHAR_T* STRING_T::find(
    const CHAR_T*    _begin,
    const CHAR_T*    _end,
    CHAR_T           _ch
)
{
    __DCL_ASSERT_PARAM(_begin != NULL && _begin <= _end);
 
    while (_begin < _end) {
        if (*_begin == _ch)
            return (CHAR_T*)_begin;
        _begin++;
    }
    return NULL;
}
 
CHAR_T* STRING_T::rfind(
    const CHAR_T*    _begin,
    const CHAR_T*    _end,
    CHAR_T           _ch
)
{
    __DCL_ASSERT_PARAM(_begin != NULL && _begin <= _end);
 
    while (_begin <= --_end) {
        if (*_end == _ch)
            return (CHAR_T*)_end;;
    }
    return NULL;
}
 
CHAR_T* STRING_T::find(
    const CHAR_T*    _begin,
    const CHAR_T*    _end,
    const CHAR_T*    _sub,
    size_t           _sublen
)
{
    __DCL_ASSERT_PARAM(_begin != NULL && _begin <= _end);
    __DCL_ASSERT_PARAM(_sub != NULL);
 
    const CHAR_T* subbegin = _sub;
    const CHAR_T* subend = _sub + _sublen;
 
    if (_begin == _end) {
        if (subbegin == subend)
            return (CHAR_T*)_begin;
        return NULL;
    }
 
    CHAR_T c = *subbegin++;
    while (_begin < _end) {
        if (c == *_begin++) {
            // found first char
            const CHAR_T* s = _begin;//    s++;
            const CHAR_T* _sub = subbegin;
            while (s < _end && _sub < subend && *s == *_sub)
                s++, _sub++;
 
            if (_sub == subend)
//                return (CHAR_T*)_begin;
                return (CHAR_T*)--_begin;
        }
//        _begin++;
    }
 
    return NULL;
}
 
CHAR_T* STRING_T::rfind(
    const CHAR_T*    _begin,
    const CHAR_T*    _end,
    const CHAR_T*    _sub,
    size_t           _sublen
)
{
    __DCL_ASSERT_PARAM(_begin != NULL && _begin <= _end);
    __DCL_ASSERT_PARAM(_sub != NULL);
 
    const CHAR_T* subbegin = _sub;
    const CHAR_T* subend = _sub + _sublen;
 
    if (_begin == _end) {
        if (subbegin == subend)
            return (CHAR_T*)_begin;
        return NULL;
    }
 
    _end -= _sublen;
    CHAR_T c = *subbegin++;
    while (_begin <= _end) {
        if (c == *_end) {
            // found first char
            const CHAR_T* s = _end; s++;
            const CHAR_T* _sub = subbegin;
            while (_sub < subend && *s == *_sub)
                s++, _sub++;
 
            if (_sub == subend)
                return (CHAR_T*)_end;
        }
        _end--;
    }
    return NULL;
}
 
size_t STRING_T::split(
    const CHAR_T*    _begin,
    const CHAR_T*    _end,
    const CHAR_T*    _delimiter,
    size_t           _delimiterlen,
    ARRAY_T&         _results,
    size_t           _limit    //        = (size_t)-1
)
{
    size_t count = 0;
    while (_begin < _end && count < _limit) {
        const CHAR_T* s = STRING_T::find(_begin, _end, _delimiter, _delimiterlen);
        if (s) {
            _results.add(STRING_T(_begin, s));
            _begin = s + _delimiterlen;
            count++;
        }
        else
            break;
    }
 
    if ((count < _limit) && ((_begin < _end) || (count == 0 && _begin == _end))) {
        _results.add(STRING_T(_begin, _end));
        count++;
    }
 
    return count;
}
 
size_t STRING_T::split(
    const CHAR_T*    _begin,
    const CHAR_T*    _end,
    CHAR_T           _delimiter,
    ARRAY_T&         _results,
    size_t           _limit    //    = (size_t)-1
)
{
    size_t count = 0;
    while (_begin < _end && count < _limit) {
        const CHAR_T* s = STRING_T::find(_begin, _end, _delimiter);
        if (s) {
            _results.add(STRING_T(_begin, s));
            _begin = s + 1;
            count++;
        }
        else
            break;
    }
 
    if ((count < _limit) && ((_begin < _end) || (count == 0 && _begin == _end))) {
        _results.add(STRING_T(_begin, _end));
        count++;
    }
 
    return count;
}
 
STRING_T STRING_T::join(
    const ARRAY_T&  _array,
    CHAR_T          _delimiter,
    bool            _hasEmpty   // = false
)
{
    STRING_BUILDER_T r;
    ARRAY_T::ConstIterator it = _array.begin();
    if (it != _array.end()) {
        for ( ; ; ) {
            const STRING_T& s = *it;
            r += s;
            if (++it == _array.end()) {
                break;
            }
 
            if (s.isEmpty()) {
                if (_hasEmpty) {
                    r += _delimiter;
                }
            }
            else {
                r += _delimiter;
            }
        }
    }
 
    return r;
}
 
STRING_T STRING_T::valueOf(bool _b)
{
    return _b ? _T("true") : _T("false");
}
 
STRING_T STRING_T::valueOf(char _n)
{
#ifdef __DCL_COMPILE_UNICODE__
    return Int32::toString((int32_t) _n, 10);
#else
    return Int32::toByteString((int32_t) _n, 10);
#endif
}
 
STRING_T STRING_T::valueOf(unsigned char _n)
{
#ifdef __DCL_COMPILE_UNICODE__
    return UInt32::toString((uint32_t) _n, 10);
#else
    return UInt32::toByteString((uint32_t) _n, 10);
#endif
}
 
STRING_T STRING_T::valueOf(short _n)
{
#ifdef __DCL_COMPILE_UNICODE__
    return Int32::toString((int32_t) _n, 10);
#else
    return Int32::toByteString((int32_t) _n, 10);
#endif
}
 
STRING_T STRING_T::valueOf(unsigned short _n)
{
#ifdef __DCL_COMPILE_UNICODE__
    return UInt32::toString((uint32_t) _n, 10);
#else
    return UInt32::toByteString((uint32_t) _n, 10);
#endif
}
 
STRING_T STRING_T::valueOf(int _n)
{
#ifdef __DCL_COMPILE_UNICODE__
    return Int32::toString((int32_t) _n, 10);
#else
    return Int32::toByteString((int32_t) _n, 10);
#endif
}
 
STRING_T STRING_T::valueOf(unsigned int _n)
{
#ifdef __DCL_COMPILE_UNICODE__
    return UInt32::toString((uint32_t) _n, 10);
#else
    return UInt32::toByteString((uint32_t) _n, 10);
#endif
}
 
STRING_T STRING_T::valueOf(long _n)
{
#if __WORDSIZE == 64
#ifdef __DCL_COMPILE_UNICODE__
    return Int64::toString((int64_t) _n, 10);
#else
    return Int64::toByteString((int64_t) _n, 10);
#endif
#else
#ifdef __DCL_COMPILE_UNICODE__
    return UInt32::toString((uint32_t) _n, 10);
#else
    return UInt32::toByteString((uint32_t) _n, 10);
#endif
#endif
}
 
STRING_T STRING_T::valueOf(unsigned long _n)
{
#if __WORDSIZE == 64
#ifdef __DCL_COMPILE_UNICODE__
    return UInt64::toString((uint64_t) _n, 10);
#else
    return UInt64::toByteString((uint64_t) _n, 10);
#endif
#else
#ifdef __DCL_COMPILE_UNICODE__
    return UInt32::toString((uint32_t) _n, 10);
#else
    return UInt32::toByteString((uint32_t) _n, 10);
#endif
#endif
}
 
STRING_T STRING_T::valueOf(long long _n)
{
#ifdef __DCL_COMPILE_UNICODE__
    return Int64::toString((int64_t) _n, 10);
#else
    return Int64::toByteString((int64_t) _n, 10);
#endif
}
 
STRING_T STRING_T::valueOf(unsigned long long _n)
{
#ifdef __DCL_COMPILE_UNICODE__
    return UInt64::toString((uint64_t) _n, 10);
#else
    return UInt64::toByteString((uint64_t) _n, 10);
#endif
}
 
STRING_T STRING_T::valueOf(float _n)
{
#ifdef __DCL_COMPILE_UNICODE__
    return String::format(L"%.8g", _n);
#else
    return ByteString::format("%.8g", _n);
#endif
}
 
STRING_T STRING_T::valueOf(double _n)
{
#ifdef __DCL_COMPILE_UNICODE__
    return String::format(L"%.16g", _n);
#else
    return ByteString::format("%.16g", _n);
#endif
}
 
STRING_T STRING_T::valueOf(long double _n)
{
#ifdef __DCL_COMPILE_UNICODE__
    return String::format(L"%.32Lg", _n);
#else
    return ByteString::format("%.32Lg", _n);
#endif
}
 
#if __DCL_HAVE_THIS_FILE__
    #undef __THIS_FILE__
#endif
 
#endif        // __DCL_INTERNAL__