irrString.hpp

// Copyright (C) 2002-2012 Nikolaus Gebhardt
// This file is part of the "Irrlicht Engine" and the "irrXML" project.
// For conditions of distribution and use, see copyright notice in duckcpp/duckcpp.hpp and irrXML.h
 
#ifndef DCPP_STRING_HPP_INCLUDED
#define DCPP_STRING_HPP_INCLUDED
 
#include <duckcpp/core/engine/dcpp_types.hpp>
#include <duckcpp/core/engine/irrAllocator.hpp>
#include <duckcpp/core/engine/irrMath.hpp>
#include <sstream>
#include <iomanip>
#include <string>
 
namespace dcpp::nub
{
 
 
// forward declarations
template <typename T, typename TAlloc = irrAllocator<T> >
class basic_string;
 
using string = dcpp::nub::basic_string<dcpp::char_kt>;
 
using wstring = dcpp::nub::basic_string<wchar_t>;
 
static size_t multibyteToWString(dcpp::nub::wstring & destination, const char* source, dcpp::uint32_kt sourceSize);
inline dcpp::int32_kt isdigit(dcpp::int32_kt c);
 
enum eLocaleID
{
    DCPP_LOCALE_ANSI = 0,
    DCPP_LOCALE_GERMAN = 1
};
 
static eLocaleID locale_current = DCPP_LOCALE_ANSI;
static inline void locale_set ( eLocaleID id )
{
    locale_current = id;
}
 
static inline dcpp::uint32_kt locale_lower ( dcpp::uint32_kt x )
{
    switch ( locale_current )
    {
        case DCPP_LOCALE_GERMAN:
        case DCPP_LOCALE_ANSI:
            break;
    }
    // ansi
    return x >= 'A' && x <= 'Z' ? x + 0x20 : x;
}
 
static inline dcpp::uint32_kt locale_upper ( dcpp::uint32_kt x )
{
    switch ( locale_current )
    {
        case DCPP_LOCALE_GERMAN:
        case DCPP_LOCALE_ANSI:
            break;
    }
 
    // ansi
    return x >= 'a' && x <= 'z' ? x + ( 'A' - 'a' ) : x;
}
 
 
DUCKCPP_API void utf8ToWchar(const char *in, wchar_t *out, const dcpp::uint64_kt len);
 
 
DUCKCPP_API void wcharToUtf8(const wchar_t *in, char *out, const dcpp::uint64_kt len);
 
 
template <typename T, typename TAlloc>
class basic_string
{
private:
    using self_type = dcpp::nub::basic_string<T, TAlloc>;
public:
    using char_type = T;
 
public:
// constructor-list-begin
 
    basic_string()
    : array(0), allocated(1), used(1)
    {
        array = allocator.allocate(1); // new T[1];
        array[0] = 0;
    }
 
 
    basic_string(const self_type & other)
    : array(0), allocated(0), used(0)
    {
        *this = other;
    }
 
    template <class B, class A>
    basic_string(const dcpp::nub::basic_string<B, A>& other)
    : array(0), allocated(0), used(0)
    {
        *this = other;
    }
 
 
    explicit basic_string(const double number)
    : array(0), allocated(0), used(0)
    {
        std::ostringstream tmpbuf;  // new: do not limit tmpbuf string size.
        tmpbuf << std::fixed << std::setprecision(6) << number;
        *this = tmpbuf.str().data();
    }
 
 
    explicit basic_string(int number)
    : array(0), allocated(0), used(0)
    {
        // store if negative and make positive
 
        bool negative = false;
        if (number < 0)
        {
            number *= -1;
            negative = true;
        }
 
        // temporary buffer for 16 numbers
 
        dcpp::char_kt tmpbuf[16]={0};
        dcpp::uint32_kt idx = 15;
 
        // special case '0'
 
        if (!number)
        {
            tmpbuf[14] = '0';
            *this = &tmpbuf[14];
            return;
        }
 
        // add numbers
 
        while(number && idx)
        {
            --idx;
            tmpbuf[idx] = (dcpp::char_kt)('0' + (number % 10));
            number /= 10;
        }
 
        // add sign
 
        if (negative)
        {
            --idx;
            tmpbuf[idx] = '-';
        }
 
        *this = &tmpbuf[idx];
    }
 
 
    explicit basic_string(unsigned int number)
    : array(0), allocated(0), used(0)
    {
        // temporary buffer for 16 numbers
 
        dcpp::char_kt tmpbuf[16]={0};
        dcpp::uint32_kt idx = 15;
 
        // special case '0'
 
        if (!number)
        {
            tmpbuf[14] = '0';
            *this = &tmpbuf[14];
            return;
        }
 
        // add numbers
 
        while(number && idx)
        {
            --idx;
            tmpbuf[idx] = (dcpp::char_kt)('0' + (number % 10));
            number /= 10;
        }
 
        *this = &tmpbuf[idx];
    }
 
 
    explicit basic_string(long number)
    : array(0), allocated(0), used(0)
    {
        // store if negative and make positive
 
        bool negative = false;
        if (number < 0)
        {
            number *= -1;
            negative = true;
        }
 
        // temporary buffer for 16 numbers
 
        dcpp::char_kt tmpbuf[16]={0};
        dcpp::uint32_kt idx = 15;
 
        // special case '0'
 
        if (!number)
        {
            tmpbuf[14] = '0';
            *this = &tmpbuf[14];
            return;
        }
 
        // add numbers
 
        while(number && idx)
        {
            --idx;
            tmpbuf[idx] = (dcpp::char_kt)('0' + (number % 10));
            number /= 10;
        }
 
        // add sign
 
        if (negative)
        {
            --idx;
            tmpbuf[idx] = '-';
        }
 
        *this = &tmpbuf[idx];
    }
 
 
    explicit basic_string(unsigned long number)
    : array(0), allocated(0), used(0)
    {
        // temporary buffer for 16 numbers
 
        dcpp::char_kt tmpbuf[16]={0};
        dcpp::uint32_kt idx = 15;
 
        // special case '0'
 
        if (!number)
        {
            tmpbuf[14] = '0';
            *this = &tmpbuf[14];
            return;
        }
 
        // add numbers
 
        while(number && idx)
        {
            --idx;
            tmpbuf[idx] = (dcpp::char_kt)('0' + (number % 10));
            number /= 10;
        }
 
        *this = &tmpbuf[idx];
    }
 
 
    template <class B>
    basic_string(const B* const c, dcpp::uint32_kt length)
    : array(0), allocated(0), used(0)
    {
        if (!c)
        {
            // correctly init the string to an empty one
            *this="";
            return;
        }
 
        allocated = used = length+1;
        array = allocator.allocate(used); // new T[used];
 
        for (dcpp::uint32_kt l = 0; l<length; ++l)
            array[l] = (T)c[l];
 
        array[length] = 0;
    }
 
 
    template <class B>
    basic_string(const B* const c)
    : array(0), allocated(0), used(0)
    {
        *this = c;
    }
 
// constructor-list-end
 
public:
    virtual ~basic_string()
    {
        allocator.deallocate(array); // delete [] array;
    }
 
public:
    self_type & operator=(const self_type & other)
    {
        if (this == &other)
            return *this;
 
        used = other.size()+1;
        if (used>allocated)
        {
            allocator.deallocate(array); // delete [] array;
            allocated = used;
            array = allocator.allocate(used); //new T[used];
        }
 
        const T* p = other.data();
        for (dcpp::uint32_kt i=0; i<used; ++i, ++p)
            array[i] = *p;
 
        return *this;
    }
 
    template <class B, class A>
    self_type & operator=(const dcpp::nub::basic_string<B,A>& other)
    {
        *this = other.data();
        return *this;
    }
 
 
    template <class B>
    self_type & operator=(const B* const c)
    {
        if (!c)
        {
            if (!array)
            {
                array = allocator.allocate(1); //new T[1];
                allocated = 1;
            }
            used = 1;
            array[0] = 0x0;
            return *this;
        }
 
        if ((void*)c == (void*)array)
            return *this;
 
        dcpp::uint32_kt len = 0;
        const B* p = c;
        do
        {
            ++len;
        } while(*p++);
 
        // we'll keep the old string for a while, because the new
        // string could be a part of the current string.
        T* oldArray = array;
 
        used = len;
        if (used>allocated)
        {
            allocated = used;
            array = allocator.allocate(used); //new T[used];
        }
 
        for (dcpp::uint32_kt l = 0; l<len; ++l)
            array[l] = (T)c[l];
 
        if (oldArray != array)
            allocator.deallocate(oldArray); // delete [] oldArray;
 
        return *this;
    }
 
 
    self_type operator+(const self_type & other) const
    {
        self_type str(*this);
        str.append(other);
 
        return str;
    }
 
 
    template <class B>
    self_type operator+(const B* const c) const
    {
        self_type str(*this);
        str.append(c);
 
        return str;
    }
 
 
    T& operator[](const dcpp::uint32_kt index)
    {
        DCPP_DEBUG_BREAK_IF(index>=used) // bad index
        return array[index];
    }
 
 
    const T& operator[](const dcpp::uint32_kt index) const
    {
        DCPP_DEBUG_BREAK_IF(index>=used) // bad index
        return array[index];
    }
 
 
    bool operator==(const T* const str) const
    {
        if (!str)
            return false;
 
        dcpp::uint32_kt i;
        for (i=0; array[i] && str[i]; ++i)
            if (array[i] != str[i])
                return false;
 
        return (!array[i] && !str[i]);
    }
 
 
    bool operator==(const self_type & other) const
    {
        for (dcpp::uint32_kt i=0; array[i] && other.array[i]; ++i)
            if (array[i] != other.array[i])
                return false;
 
        return used == other.used;
    }
 
 
    bool operator<(const self_type & other) const
    {
        for (dcpp::uint32_kt i=0; array[i] && other.array[i]; ++i)
        {
            const dcpp::int32_kt diff = array[i] - other.array[i];
            if (diff)
                return (diff < 0);
        }
 
        return (used < other.used);
    }
 
 
    bool operator!=(const T* const str) const
    {
        return !(*this == str);
    }
 
 
    bool operator!=(const self_type & other) const
    {
        return !(*this == other);
    }
 
 
 
    dcpp::uint32_kt size() const
    {
        return used-1;
    }
 
    bool empty() const
    {
        return (size() == 0);
    }
 
    void clear(bool releaseMemory=true)
    {
        if ( releaseMemory )
        {
            reallocate(1);
        }
        array[0] = 0;
        used = 1;
    }
 
 
    const T* data() const
    {
        return array;
    }
 
 
    std::basic_string<T> str() const
    {
        return array;
    }
 
 
    explicit operator std::basic_string<T> () const
    {
        return this->str();
    }
 
    self_type & make_lower()
    {
        for (dcpp::uint32_kt i=0; array[i]; ++i)
            array[i] = locale_lower ( array[i] );
        return *this;
    }
 
 
    self_type & make_upper()
    {
        for (dcpp::uint32_kt i=0; array[i]; ++i)
            array[i] = locale_upper ( array[i] );
        return *this;
    }
 
 
 
    bool equals_ignore_case(const self_type & other) const
    {
        for(dcpp::uint32_kt i=0; array[i] && other[i]; ++i)
            if (locale_lower( array[i]) != locale_lower(other[i]))
                return false;
 
        return used == other.used;
    }
 
 
    bool equals_substring_ignore_case(const self_type & other, const dcpp::int32_kt sourcePos = 0 ) const
    {
        if ( (dcpp::uint32_kt) sourcePos >= used )
            return false;
 
        dcpp::uint32_kt i;
        for( i=0; array[sourcePos + i] && other[i]; ++i)
            if (locale_lower( array[sourcePos + i]) != locale_lower(other[i]))
                return false;
 
        return array[sourcePos + i] == 0 && other[i] == 0;
    }
 
 
 
    bool lower_ignore_case(const self_type & other) const
    {
        for(dcpp::uint32_kt i=0; array[i] && other.array[i]; ++i)
        {
            dcpp::int32_kt diff = (dcpp::int32_kt) locale_lower ( array[i] ) - (dcpp::int32_kt) locale_lower ( other.array[i] );
            if ( diff )
                return diff < 0;
        }
 
        return used < other.used;
    }
 
 
 
    bool equalsn(const self_type & other, dcpp::uint32_kt n) const
    {
        dcpp::uint32_kt i;
        for(i=0; i < n && array[i] && other[i]; ++i)
            if (array[i] != other[i])
                return false;
 
        // if one (or both) of the strings was smaller then they
        // are only equal if they have the same length
        return (i == n) || (used == other.used);
    }
 
 
 
    bool equalsn(const T* const str, dcpp::uint32_kt n) const
    {
        if (!str)
            return false;
        dcpp::uint32_kt i;
        for(i=0; i < n && array[i] && str[i]; ++i)
            if (array[i] != str[i])
                return false;
 
        // if one (or both) of the strings was smaller then they
        // are only equal if they have the same length
        return (i == n) || (array[i] == 0 && str[i] == 0);
    }
 
 
 
    self_type & append(T character)
    {
        if (used + 1 > allocated)
            reallocate(used + 1);
 
        ++used;
 
        array[used-2] = character;
        array[used-1] = 0;
 
        return *this;
    }
 
 
 
    self_type & append(const T* const other, dcpp::uint32_kt length=0xffffffff)
    {
        if (!other)
            return *this;
 
        dcpp::uint32_kt len = 0;
        const T* p = other;
        while(*p)
        {
            ++len;
            ++p;
        }
        if (len > length)
            len = length;
 
        if (used + len > allocated)
            reallocate(used + len);
 
        --used;
        ++len;
 
        for (dcpp::uint32_kt l=0; l<len; ++l)
            array[l+used] = *(other+l);
 
        used += len;
 
        return *this;
    }
 
 
 
    self_type & append(const self_type & other)
    {
        if (other.size() == 0)
            return *this;
 
        --used;
        const dcpp::uint32_kt len = other.size()+1;
 
        if (used + len > allocated)
            reallocate(used + len);
 
        for (dcpp::uint32_kt l=0; l<len; ++l)
            array[used+l] = other[l];
 
        used += len;
 
        return *this;
    }
 
 
 
    self_type & append(const self_type & other, dcpp::uint32_kt length)
    {
        if (other.size() == 0)
            return *this;
 
        if (other.size() < length)
        {
            append(other);
            return *this;
        }
 
        if (used + length > allocated)
            reallocate(used + length);
 
        --used;
 
        for (dcpp::uint32_kt l=0; l<length; ++l)
            array[l+used] = other[l];
        used += length;
 
        // ensure proper termination
        array[used]=0;
        ++used;
 
        return *this;
    }
 
    //\param pos Insert the characters before this index
    //\param s String to insert. Must be at least of size n
    //\param n Number of characters from string s to use.
    self_type & insert(dcpp::uint32_kt pos, const char* s, dcpp::uint32_kt n)
    {
        if ( pos < used )
        {
            reserve(used+n);
 
            // move stuff behind insert point
            const dcpp::uint32_kt end = used+n-1;
            for (dcpp::uint32_kt i=0; i<used-pos; ++i)
            {
                array[end-i] = array[end-(i+n)];
            }
            used += n;
 
            for (dcpp::uint32_kt i=0; i<n; ++i)
            {
                array[pos+i] = s[i];
            }
        }
 
        return *this;
    }
 
 
    void reserve(dcpp::uint32_kt count)
    {
        if (count < allocated)
            return;
 
        reallocate(count);
    }
 
 
 
    dcpp::int32_kt findFirst(T c) const
    {
        for (dcpp::uint32_kt i=0; i<used-1; ++i)
            if (array[i] == c)
                return i;
 
        return -1;
    }
 
 
    dcpp::int32_kt findFirstChar(const T* const c, dcpp::uint32_kt count=1) const
    {
        if (!c || !count)
            return -1;
 
        for (dcpp::uint32_kt i=0; i<used-1; ++i)
            for (dcpp::uint32_kt j=0; j<count; ++j)
                if (array[i] == c[j])
                    return i;
 
        return -1;
    }
 
 
 
    template <class B>
    dcpp::int32_kt findFirstCharNotInList(const B* const c, dcpp::uint32_kt count=1) const
    {
        if (!c || !count)
            return -1;
 
        for (dcpp::uint32_kt i=0; i<used-1; ++i)
        {
            dcpp::uint32_kt j;
            for (j=0; j<count; ++j)
                if (array[i] == c[j])
                    break;
 
            if (j==count)
                return i;
        }
 
        return -1;
    }
 
 
    template <class B>
    dcpp::int32_kt findLastCharNotInList(const B* const c, dcpp::uint32_kt count=1) const
    {
        if (!c || !count)
            return -1;
 
        for (dcpp::int32_kt i=(dcpp::int32_kt)(used-2); i>=0; --i)
        {
            dcpp::uint32_kt j;
            for (j=0; j<count; ++j)
                if (array[i] == c[j])
                    break;
 
            if (j==count)
                return i;
        }
 
        return -1;
    }
 
 
    dcpp::int32_kt findNext(T c, dcpp::uint32_kt startPos) const
    {
        for (dcpp::uint32_kt i=startPos; i<used-1; ++i)
            if (array[i] == c)
                return i;
 
        return -1;
    }
 
 
 
    dcpp::int32_kt findLast(T c, dcpp::int32_kt start = -1) const
    {
        start = dcpp::nub::clamp ( start < 0 ? (dcpp::int32_kt)(used) - 2 : start, 0, (dcpp::int32_kt)(used) - 2 );
        for (dcpp::int32_kt i=start; i>=0; --i)
            if (array[i] == c)
                return i;
 
        return -1;
    }
 
 
    dcpp::int32_kt findLastChar(const T* const c, dcpp::uint32_kt count=1) const
    {
        if (!c || !count)
            return -1;
 
        for (dcpp::int32_kt i=(dcpp::int32_kt)used-2; i>=0; --i)
            for (dcpp::uint32_kt j=0; j<count; ++j)
                if (array[i] == c[j])
                    return i;
 
        return -1;
    }
 
 
 
    template <class B>
    dcpp::int32_kt find(const B* const str, const dcpp::uint32_kt start = 0) const
    {
        if (str && *str)
        {
            dcpp::uint32_kt len = 0;
 
            while (str[len])
                ++len;
 
            if (len > used-1)
                return -1;
 
            for (dcpp::uint32_kt i=start; i<used-len; ++i)
            {
                dcpp::uint32_kt j=0;
 
                while(str[j] && array[i+j] == str[j])
                    ++j;
 
                if (!str[j])
                    return i;
            }
        }
 
        return -1;
    }
 
 
 
    self_type subString(dcpp::uint32_kt begin, dcpp::int32_kt length, bool make_lower = false ) const
    {
        // clamp length to maximal value
        if ((length+begin) > size())
            length = size()-begin;
        // if start after string
        // or no proper substring length
        if ((length <= 0) || (begin>=size()))
            return self_type{""};
 
        self_type o;
        o.reserve(length+1);
 
        if ( !make_lower )
        {
            for (dcpp::int32_kt i=0; i<length; ++i)
                o.array[i] = array[i+begin];
        }
        else
        {
            for (dcpp::int32_kt i=0; i<length; ++i)
                o.array[i] = locale_lower ( array[i+begin] );
        }
 
        o.array[length] = 0;
        o.used = length + 1;
 
        return o;
    }
 
 
 
    self_type & operator += (T c)
    {
        append(c);
        return *this;
    }
 
 
 
    self_type & operator += (const T* const c)
    {
        append(c);
        return *this;
    }
 
 
 
    self_type & operator += (const self_type & other)
    {
        append(other);
        return *this;
    }
 
 
 
    self_type & operator += (const int i)
    {
        append(self_type(i));
        return *this;
    }
 
 
 
    self_type & operator += (const unsigned int i)
    {
        append(self_type(i));
        return *this;
    }
 
 
 
    self_type & operator += (const long i)
    {
        append(self_type(i));
        return *this;
    }
 
 
 
    self_type & operator += (const unsigned long i)
    {
        append(self_type(i));
        return *this;
    }
 
 
 
    self_type & operator += (const double i)
    {
        append(self_type(i));
        return *this;
    }
 
 
 
    self_type & operator += (const float i)
    {
        append(self_type(i));
        return *this;
    }
 
 
 
    self_type & replace(T toReplace, T replaceWith)
    {
        for (dcpp::uint32_kt i=0; i<used-1; ++i)
            if (array[i] == toReplace)
                array[i] = replaceWith;
        return *this;
    }
 
 
 
    self_type & replace(const self_type & toReplace, const self_type & replaceWith)
    {
        if (toReplace.size() == 0)
            return *this;
 
        const T* other = toReplace.data();
        const T* replace = replaceWith.data();
        const dcpp::uint32_kt other_size = toReplace.size();
        const dcpp::uint32_kt replace_size = replaceWith.size();
 
        // Determine the delta.  The algorithm will change depending on the delta.
        dcpp::int32_kt delta = replace_size - other_size;
 
        // A character for character replace.  The string will not shrink or grow.
        if (delta == 0)
        {
            dcpp::int32_kt pos = 0;
            while ((pos = find(other, pos)) != -1)
            {
                for (dcpp::uint32_kt i = 0; i < replace_size; ++i)
                    array[pos + i] = replace[i];
                ++pos;
            }
            return *this;
        }
 
        // We are going to be removing some characters.  The string will shrink.
        if (delta < 0)
        {
            dcpp::uint32_kt i = 0;
            for (dcpp::uint32_kt pos = 0; pos < used; ++i, ++pos)
            {
                // Is this potentially a match?
                if (array[pos] == *other)
                {
                    // Check to see if we have a match.
                    dcpp::uint32_kt j;
                    for (j = 0; j < other_size; ++j)
                    {
                        if (array[pos + j] != other[j])
                            break;
                    }
 
                    // If we have a match, replace characters.
                    if (j == other_size)
                    {
                        for (j = 0; j < replace_size; ++j)
                            array[i + j] = replace[j];
                        i += replace_size - 1;
                        pos += other_size - 1;
                        continue;
                    }
                }
 
                // No match found, just copy characters.
                array[i] = array[pos];
            }
            array[i-1] = 0;
            used = i;
 
            return *this;
        }
 
        // We are going to be adding characters, so the string size will increase.
        // Count the number of times toReplace exists in the string so we can allocate the new size.
        dcpp::uint32_kt find_count = 0;
        dcpp::int32_kt pos = 0;
        while ((pos = find(other, pos)) != -1)
        {
            ++find_count;
            ++pos;
        }
 
        // Re-allocate the string now, if needed.
        dcpp::uint32_kt len = delta * find_count;
        if (used + len > allocated)
            reallocate(used + len);
 
        // Start replacing.
        pos = 0;
        while ((pos = find(other, pos)) != -1)
        {
            T* start = array + pos + other_size - 1;
            T* ptr   = array + used - 1;
            T* end   = array + delta + used -1;
 
            // Shift characters to make room for the string.
            while (ptr != start)
            {
                *end = *ptr;
                --ptr;
                --end;
            }
 
            // Add the new string now.
            for (dcpp::uint32_kt i = 0; i < replace_size; ++i)
                array[pos + i] = replace[i];
 
            pos += replace_size;
            used += delta;
        }
 
        return *this;
    }
 
 
 
    self_type & remove(T c)
    {
        dcpp::uint32_kt pos = 0;
        dcpp::uint32_kt found = 0;
        for (dcpp::uint32_kt i=0; i<used-1; ++i)
        {
            if (array[i] == c)
            {
                ++found;
                continue;
            }
 
            array[pos++] = array[i];
        }
        used -= found;
        array[used-1] = 0;
        return *this;
    }
 
 
 
    self_type & remove(const self_type & toRemove)
    {
        dcpp::uint32_kt size = toRemove.size();
        if ( size == 0 )
            return *this;
        dcpp::uint32_kt pos = 0;
        dcpp::uint32_kt found = 0;
        for (dcpp::uint32_kt i=0; i<used-1; ++i)
        {
            dcpp::uint32_kt j = 0;
            while (j < size)
            {
                if (array[i + j] != toRemove[j])
                    break;
                ++j;
            }
            if (j == size)
            {
                found += size;
                i += size - 1;
                continue;
            }
 
            array[pos++] = array[i];
        }
        used -= found;
        array[used-1] = 0;
        return *this;
    }
 
 
 
    self_type & removeChars(const self_type  & characters)
    {
        if (characters.size() == 0)
            return *this;
 
        dcpp::uint32_kt pos = 0;
        dcpp::uint32_kt found = 0;
        for (dcpp::uint32_kt i=0; i<used-1; ++i)
        {
            // Don't use characters.findFirst as it finds the \0,
            // causing used to become incorrect.
            bool docontinue = false;
            for (dcpp::uint32_kt j=0; j<characters.size(); ++j)
            {
                if (characters[j] == array[i])
                {
                    ++found;
                    docontinue = true;
                    break;
                }
            }
            if (docontinue)
                continue;
 
            array[pos++] = array[i];
        }
        used -= found;
        array[used-1] = 0;
 
        return *this;
    }
 
 
 
    self_type & trim(const self_type & whitespace = " \t\n\r")
    {
        // find start and end of the substring without the specified characters
        const dcpp::int32_kt begin = findFirstCharNotInList(whitespace.data(), whitespace.used);
        if (begin == -1)
            return (*this="");
 
        const dcpp::int32_kt end = findLastCharNotInList(whitespace.data(), whitespace.used);
 
        return (*this = subString(begin, (end +1) - begin));
    }
 
 
    self_type & eraseTrailingFloatZeros(char decimalPoint='.')
    {
        dcpp::int32_kt i=findLastCharNotInList("0", 1);
        if ( i > 0 && (dcpp::uint32_kt)i < used-2 ) // non 0 must be found and not last char (also used is at least 2 when i > 0)
        {
            dcpp::uint32_kt eraseStart=i+1;
            dcpp::uint32_kt dot=0;
            if( dcpp::nub::isdigit(array[i]) )
            {
                while( --i>0 && dcpp::nub::isdigit(array[i]) );
                if ( array[i] == decimalPoint )
                    dot = i;
            }
            else if ( array[i] == decimalPoint )
            {
                dot = i;
                eraseStart = i;
            }
            if ( dot > 0 && dcpp::nub::isdigit(array[dot-1]) )
            {
                array[eraseStart] = 0;
                used = eraseStart+1;
            }
        }
        return *this;
    }
 
 
    self_type & erase(dcpp::uint32_kt index)
    {
        DCPP_DEBUG_BREAK_IF(index>=used) // access violation
 
        for (dcpp::uint32_kt i=index+1; i<used; ++i)
            array[i-1] = array[i];
 
        --used;
        return *this;
    }
 
    self_type & validate()
    {
        // terminate on existing null
        for (dcpp::uint32_kt i=0; i<allocated; ++i)
        {
            if (array[i] == 0)
            {
                used = i + 1;
                return *this;
            }
        }
 
        // terminate
        if ( allocated > 0 )
        {
            used = allocated;
            array[used-1] = 0;
        }
        else
        {
            used = 0;
        }
 
        return *this;
    }
 
    T lastChar() const
    {
        return used > 1 ? array[used-2] : 0;
    }
 
 
    template<class container>
    dcpp::uint32_kt split(container& ret, const T* const delimiter, dcpp::uint32_kt countDelimiters=1, bool ignoreEmptyTokens=true, bool keepSeparators=false) const
    {
        if (!delimiter)
            return 0;
 
        const dcpp::uint32_kt oldSize=ret.size();
 
        dcpp::uint32_kt tokenStartIdx = 0;
        for (dcpp::uint32_kt i=0; i<used; ++i)
        {
            for (dcpp::uint32_kt j=0; j<countDelimiters; ++j)
            {
                if (array[i] == delimiter[j])
                {
                    if (i - tokenStartIdx > 0)
                        ret.push_back(self_type(&array[tokenStartIdx], i - tokenStartIdx));
                    else if ( !ignoreEmptyTokens )
                        ret.push_back(self_type());
                    if ( keepSeparators )
                    {
                        ret.push_back(self_type(&array[i], 1));
                    }
 
                    tokenStartIdx = i+1;
                    break;
                }
            }
        }
        if ((used - 1) > tokenStartIdx)
            ret.push_back(self_type(&array[tokenStartIdx], (used - 1) - tokenStartIdx));
         else if ( !ignoreEmptyTokens )
                ret.push_back(self_type());
 
        return ret.size()-oldSize;
    }
 
    friend size_t multibyteToWString(dcpp::nub::wstring & destination, const char* source, dcpp::uint32_kt sourceSize);
 
private:
 
    void reallocate(dcpp::uint32_kt new_size)
    {
        T* old_array = array;
 
        array = allocator.allocate(new_size); //new T[new_size];
        allocated = new_size;
 
        const dcpp::uint32_kt amount = used < new_size ? used : new_size;
        for (dcpp::uint32_kt i=0; i<amount; ++i)
            array[i] = old_array[i];
 
        if (allocated < used)
            used = allocated;
 
        allocator.deallocate(old_array); // delete [] old_array;
    }
 
    //--- member variables
 
    T* array;
    dcpp::uint32_kt allocated;
    dcpp::uint32_kt used;
    TAlloc allocator;
};  // class basic_string
 
 
static inline size_t multibyteToWString(dcpp::nub::wstring & destination, const dcpp::nub::string & source)
{
    return multibyteToWString(destination, source.data(), (dcpp::uint32_kt)source.size());
}
 
 
static inline size_t multibyteToWString(dcpp::nub::wstring & destination, const char* source)
{
    const dcpp::uint32_kt s = source ? (dcpp::uint32_kt)strlen(source) : 0;
    return multibyteToWString(destination, source, s);
}
 
static size_t multibyteToWString(dcpp::nub::wstring & destination, const char* source, dcpp::uint32_kt sourceSize)
{
    if ( sourceSize )
    {
        destination.reserve(sourceSize+1);
#if defined(_MSC_VER)
#pragma warning(push)
#pragma warning(disable: 4996)  // 'mbstowcs': This function or variable may be unsafe. Consider using mbstowcs_s instead.
#endif
        const size_t written = mbstowcs(destination.array, source, (size_t)sourceSize);
#if defined(_MSC_VER)
#pragma warning(pop)
#endif
        if ( written != (size_t)-1 )
        {
            destination.used = (dcpp::uint32_kt)written+1;
            destination.array[destination.used-1] = 0;
        }
        else
        {
            // Likely character which got converted until the invalid character was encountered are in destination now.
            // And it seems even 0-terminated, but I found no documentation anywhere that this (the 0-termination) is guaranteed :-(
            destination.clear();
        }
        return written;
    }
    else
    {
        destination.clear();
        return 0;
    }
}
 
}   // namespace dcpp::nub
 
#endif