String.h

// $Id: String.h 21 2010-09-05 04:18:17Z cschwarz1 $

#ifndef BASE_STRING_H
#define BASE_STRING_H

#include <cstdlib>
#include <stdexcept>
#include <vector>
#include "CharTraits.h"
#include "IntTraits.h"

namespace base {

    template<class charT, class traits = CharTraits<charT> > class StringT {
    public:
        typedef typename traits::size_type size_type;   
        static const size_type npos = static_cast<size_type>(-1);   

        StringT() {
            _buf = NULL;
            _len = _size = 0;
        }

        StringT(const StringT &s) {
            _buf = NULL;
            _size = 0;
            assign(s);
        }

        template<typename T> StringT(T t)  {
            _buf = NULL;
            _size = 0;
            assign(t);
        }

        StringT(const StringT &s, size_type pos, size_type len = npos) {
            _buf = NULL;
            _size = 0;
            assign(s, pos, len);
        }

        StringT(const charT *s, size_type len) {
            _buf = NULL;
            _size = 0;
            assign(s, len);
        }

        ~StringT() {
            if (_buf)
                free(_buf);
        }

        StringT &append(charT ch) {
            return append(&ch, 1);
        }

        StringT &append(double n) {
            charT buf[128];

            return append(buf, traits::dtoa(n, buf));
        }

        StringT &append(int n) {
            charT buf[64];

            return append(buf, traits::ltoa(n, buf));
        }

        StringT &append(unsigned int n) {
            charT buf[64];

            return append(buf, traits::ultoa(n, buf));
        }

        StringT &append(long n) {
            charT buf[64];

            return append(buf, traits::ltoa(n, buf));
        }

        StringT &append(unsigned long n) {
            charT buf[64];

            return append(buf, traits::ultoa(n, buf));
        }

        StringT &append(longlong_t n) {
            charT buf[64];

            return append(buf, traits::lltoa(n, buf));
        }

        StringT &append(u_longlong_t n) {
            charT buf[64];

            return append(buf, traits::ulltoa(n, buf));
        }

        StringT &append(const StringT &s) {
            return append(s.data(), s.length());
        }

        StringT &append(const StringT &s, size_type pos, size_type len = npos) {
            if (pos < s.length()) {
                if (len == npos || pos + len > s.length())
                    len = s.length() - pos;
                return append(s.data() + pos, len);
            } else
                return *this;
        }

        StringT &append (const charT *s) {
            return append(s, traits::length(s));
        }

        StringT &append(const charT *s, size_type len)  {
            if (s && len > 0) {
                if (len + _len >= _size)
                    resize(len + _len);
                traits::memmove(_buf + _len, s, len);
                _buf[_len += len] = traits::nul;
            }
            return *this;
        }

        StringT &append(size_type n, charT ch) {
            if (n > 0) {
                if (n + _len >= _size)
                    resize(n + _len);
                traits::memset(_buf + _len, ch, n);
                _buf[_len += n] = traits::nul;
            }
            return *this;
        }


        StringT &appendf(const charT *fmt, ...) {
            va_list ap;

            va_start(ap, fmt);
            appendvf(fmt, ap);
            va_end(ap);
            return *this;
        }


        StringT &appendvf(const charT *fmt, va_list ap) {
            size_type len;
            size_type n = 4;

            for (;;) {
                len = traits::vxprintf(_buf + _len, _size - _len, fmt, ap);
                if (len == npos) {
                    n <<= 1;
                    resize(_size + n);
                } else if (len >= _size - _len)
                    resize(_len + len);
                else {
                    _len += len;
                    break;
                }
            }
            return *this;
        }

        StringT &assign(charT ch) {
            return assign(&ch, 1);
        }

        StringT &assign(double n) {
            charT buf[128];

            return assign(buf, traits::dtoa(n, buf));
        }

        StringT &assign(int n) {
            charT buf[64];

            return assign(buf, traits::ltoa(n, buf));
        }

        StringT &assign(unsigned int n) {
            charT buf[64];

            return assign(buf, traits::ultoa(n, buf));
        }

        StringT &assign(long n) {
            charT buf[64];

            return assign(buf, traits::ltoa(n, buf));
        }

        StringT &assign(unsigned long n) {
            charT buf[64];

            return assign(buf, traits::ultoa(n, buf));
        }

        StringT &assign(longlong_t n) {
            charT buf[64];

            return assign(buf, traits::lltoa(n, buf));
        }

        StringT &assign(u_longlong_t n) {
            charT buf[64];

            return assign(buf, traits::ulltoa(n, buf));
        }

        StringT &assign(const StringT &s) {
            return assign(s.data(), s.length());
        }

        StringT &assign(const StringT &s, size_type pos, size_type len = npos) {
            if (pos < s.length()) {
                if (len > s.length() - pos)
                    len = s.length() - pos;
                return assign(s.data() + pos, len);
            } else
                return clear();
        }

        StringT &assign(const charT *s) {
            return assign(s, traits::length(s));
        }

        StringT &assign(const charT *s, size_type len) {
            if (s) {
                if (len >= _size)
                    resize(len);
                if (len <= 0)
                    len = 0;
                else
                    traits::memmove(_buf, s, len);
                _len = len;
                _buf[_len] = traits::nul;
            } else {
                _len = 0;
                if (_buf)
                    *_buf = traits::nul;
            }
            return *this;
        }


        StringT &assignf(const charT *fmt, ...) {
            va_list ap;

            va_start(ap, fmt);
            assignvf(fmt, ap);
            va_end(ap);
            return *this;
        }


        StringT &assignvf(const charT *fmt, va_list ap) {
            size_type len;
            size_type n = 4;

            for (;;) {
                len = traits::vxprintf(_buf, _size, fmt, ap);
                if (len == npos) {
                    n <<= 1;
                    resize(_size + n);
                } else if (len >= _size)
                    resize(len);
                else {
                    _len = len;
                    break;
                }
            }
            return *this;
        }

        const charT *c_str() const {
            return _buf ? _buf : traits::empty;
        }

        size_type capacity() const {
            return _size ? _size - 1 : 0;
        }

        StringT &clear() {
            if (_buf)
                _buf[_len = 0] = traits::nul;
            return *this;
        }


        int compare(const StringT &s, bool icase = false) const {
            return compare(0, _len, s.data(), s.length(), icase);
        }

        int compare(const StringT &s, size_type pos, size_type len, bool icase = false) const {
            return compare(0, _len, s.data() + pos, len, icase);
        }

        int compare(size_type pos, size_type len, const StringT &s, bool icase = false) const {
            return compare(pos, len, s.data(), s.length(), icase);
        }

        int compare(size_type pos, size_type len, const StringT &s, size_type spos, size_type slen, bool icase = false) const {
            return compare(pos, len, s.data() + spos, slen, icase);
        }

        int compare(const charT *s, bool icase = false) const {
            return compare(0, _len, s, traits::length(s), icase);
        }

        int compare(const charT *s, size_type len, bool icase = false) const {
            return compare(0, _len, s, len, icase);
        }

        int compare(size_type pos, size_type len, const charT *s, bool icase = false) const {
            return compare(pos, len, s, traits::length(s), icase);
        }

        int compare(size_type pos, size_type len, const charT *s, size_type slen, bool icase = false) const {
            size_type    m;
            size_type    n;
            const charT *p;
            const charT *q;
            int          ret;

            if (pos >= _len)
                ret = slen ? -1 : 0;
            else {
                if (pos + len > _len)
                    len = _len - pos;
                if (icase) {
                    n = len;
                    q = s;
                    m = slen;
                    p = _buf + pos;
                    ret = 0;
                    while (m > 0 && n > 0) {
                        if (traits::tolower(*p) < traits::tolower(*q)) {
                            ret = -1;
                            break;
                        } else if (traits::tolower(*p) > traits::tolower(*q)) {
                            ret = 1;
                            break;
                        } else {
                            m--;
                            n--;
                            p++;
                            q++;
                        }
                    }
                    if (!ret)
                        ret = n ? 1 : (m ? -1 : 0);
                } else {
                    if ((ret = traits::memcmp(_buf + pos, s, slen < len ? slen : len)) == 0)
                        ret = slen < len ? 1 : (slen > len ? -1 : 0);
                }
            }
            return ret;
        }

        const charT *data() const {
            return _buf ? _buf : traits::empty;
        }

        bool empty() const {
            return _len <= 0;
        }

        StringT &erase(size_type pos = 0, size_type len = npos) {
            if (pos < _len) {
                if (len > _len - pos)
                    len = _len - pos;
                if (len > 0) {
                    traits::memmove(_buf + pos, _buf + pos + len, _len - pos - len + 1);
                    _len -= len;
                }
            }
            return *this;
        }

        StringT &eraseAll(charT ch) {
            for (size_type pos = 0; pos < _len; ) {
                if (_buf[pos] == ch)
                    erase(pos, 1);
                else
                    pos++;
            }
            return *this;
        }

        size_type find(const StringT &s, size_type pos = 0, bool icase = false) const {
            return find(s.data(), pos, s.length(), icase);
        }

        size_type find(const charT *s, size_type pos = 0, bool icase = false) const {
            return find(s, pos, traits::length(s), icase);
        }

        size_type find(const charT *s, size_type pos, size_type len, bool icase = false) const {
            size_type i;
            size_type ret = npos;

            if (len > 0) {
                if (icase) {
                    for (i = 0; pos + i < _len; ) {
                        if (traits::tolower(s[i]) == traits::tolower(_buf[pos + i])) {
                            if (++i >= len) {
                                ret = pos;
                                break;
                            }
                        } else {
                            i = 0;
                            pos++;
                        }
                    }
                } else {
                    for (i = 0; pos + i < _len; ) {
                        if (s[i] == _buf[pos + i]) {
                            if (++i >= len) {
                                ret = pos;
                                break;
                            }
                        } else {
                            i = 0;
                            pos++;
                        }
                    }
                }
            }

            return ret;
        }

        size_type find(charT ch, size_type pos = 0) const {
            size_type ret;

            for (ret = pos; ret < _len && _buf[ret] != ch; ret++) ;
            if (ret >= _len)
                ret = npos;

            return ret;
        }

        size_type find_first_not_of(const StringT &s, size_type pos = 0) const {
            return find_first_not_of(s.data(), pos, s.length());
        }

        size_type find_first_not_of(const charT *s, size_type pos = 0) const {
            return find_first_not_of(s, pos, traits::length(s));
        }

        size_type find_first_not_of(const charT *s, size_type pos, size_type len) const {
            size_type  i;
            size_type  n = _len;
            charT     *p;
            size_type  ret;

            // len = length of s
            if (pos < n) {
                for (ret = pos, p = _buf + pos; ret < n; p++, ret++) {
                    // p = pointer to the current char in *this
                    unsigned c = 0;

                    for (i = 0; i < len; i++)
                        if (s[i] != *p)
                            c++;
                    if (c == len)
                        return ret;
                    if (i < len)
                        break;
                }
                if (ret >= n)
                    ret = npos;
            } else
                ret = npos;
            return ret;
        }

        size_type find_first_of(const StringT &s, size_type pos = 0) const {
            return find_first_of(s.data(), pos, s.length());
        }

        size_type find_first_of(const charT *s, size_type pos = 0) const {
            return find_first_of(s, pos, traits::length(s));
        }

        size_type find_first_of(const charT *s, size_type pos, size_type len) const {
            size_type  i;
            size_type  n = _len;
            charT     *p;
            size_type  ret;

            if (pos < n) {
                for (ret = pos, p = _buf + pos; ret < n; p++, ret++) {
                    for (i = 0; i < len; i++)
                        if (s[i] == *p)
                            break;
                    if (i < len)
                        break;
                }
                if (ret >= n)
                    ret = npos;
            } else
                ret = npos;
            return ret;
        }

        size_type find_first_of(charT ch, size_type pos = 0) const {
            return find(ch, pos);
        }

        size_type find_last_not_of(const StringT &s, size_type pos = npos) const {
            return find_last_not_of(s.data(), pos, s.length());
        }

        size_type find_last_not_of(const charT *s, size_type pos = npos) const {
            return find_last_not_of(s, pos, traits::length(s));
        }

        size_type find_last_not_of(const charT *s, size_type pos, size_type len) const {
            size_type  i;
            size_type  n = _len;
            charT     *p;
            size_type  ret;

            // len = length of s
            if (pos >= n)
                pos = n - 1;
            if (pos < n) {
                for (ret = pos, p = _buf + pos; ; p--, ret--) {
                    // p = pointer to the current char in *this
                    unsigned c = 0;

                    for (i = 0; i < len; i++)
                        if (s[i] != *p)
                            c++;
                    if (c == len)
                        return ret;
                    if (i < len)
                        break;
                    if (!ret)
                        return npos;
                }
            } else
                ret = npos;
            return ret;
        }

        size_type find_last_of(const StringT &s, size_type pos = npos) const {
            return find_last_of(s.data(), pos, s.length());
        }

        size_type find_last_of(const charT *s, size_type pos = npos) const {
            return find_last_of(s, pos, traits::length(s));
        }

        size_type find_last_of(const charT *s, size_type pos, size_type len) const {
            size_type  i;
            size_type  n = _len;
            charT     *p;
            size_type  ret;

            // len = length of s
            if (pos >= n)
                pos = n - 1;
            if (pos < n) {
                for (ret = pos, p = _buf + pos; ; p--, ret--) { 
                    // p = pointer to the current char in *this
                    for (i = 0; i < len; i++)
                        if (s[i] == *p)
                            return ret;
                    if (!ret)
                        break;
                }
                ret = npos;
            } else
                ret = npos;
            return ret;
        }

        charT *getBuffer() {
            return _buf;
        }

        charT getCharAt(size_type pos) const {
            return pos < _len ? _buf[pos] : traits::nul;
        }

        StringT &insert(size_type pos, charT ch) {
            return insert(pos, &ch, 1);
        }

        StringT &insert(size_type pos, const StringT &s) {
            return insert(pos, s.data(), s.length());
        }

        StringT &insert(size_type pos, const charT *s) {
            return insert(pos, s, traits::length(s));
        }

        StringT &insert(size_type pos, const charT *s, size_type len) {
            if (len > 0 && pos <= _len) {
                if (_len + len >= _size)
                    resize(_len + len);
                if (!_len)
                    *_buf = traits::nul;
                traits::memmove(_buf + pos + len, _buf + pos, _len - pos + 1);
                traits::memmove(_buf + pos, s, len);
                _len += len;
            }
            return *this;
        }

        size_type length() const {
            return _len;
        }

        StringT &replace(size_type pos, size_type cnt, const StringT &s, size_type start = 0, size_type len = npos) {
            if (len == npos)
                len = s.length() - start;
            return replace(pos, cnt, s.data() + start, len);
        }

        StringT &replace(size_type pos, size_type cnt, const charT *s) {
            return replace(pos, cnt, s, traits::length(s));
        }

        StringT &replace(size_type pos, size_type cnt, const charT *s, size_type len) {
            if (pos <= _len) {
                if (pos + cnt > _len)
                    cnt = _len - pos;
                if (cnt < len) {
                    if (_size - _len <= len - cnt)
                        resize(_len + len - cnt);
                    if (_len - pos > cnt)
                        traits::memmove(_buf + pos + len, _buf + pos + cnt, _len - pos - cnt);
                    _len += len - cnt;
                } else if (cnt > len) {
                    traits::memmove(_buf + pos + len, _buf + pos + cnt, _len - pos - cnt);
                    _len -= cnt - len;
                }
                if (len > 0)
                    traits::memmove(_buf + pos, s, len);
                _buf[_len] = traits::nul;
            }
            return *this;
        }


        StringT &replaceAll(const StringT &oldstr, const StringT &newstr) {
            size_type pos = 0;

            do {
                pos = find(oldstr, pos);
                if (pos != npos) {
                    replace(pos, oldstr.length(), newstr);
                    pos += newstr.length();
                }
            } while (pos != npos);
            return *this;
        }


        StringT &replaceAll(charT oldch, charT newch) {
            size_type pos;

            for (pos = 0; pos < _len; pos++)
                if (_buf[pos] == oldch)
                    _buf[pos] = newch;
            return *this;
        }

        void resize(size_type n) {
            charT *buf;

            if (n >= _size) {
                n++;              // terminating 0-byte
                if (n % 8 != 0)   // allocate in multiples of 8
                    n += 8 - (n % 8);
                if (_buf) {
                    if ((buf = static_cast<charT*>(realloc(_buf, n * sizeof(charT)))) == NULL)
                        throw std::bad_alloc();
                    _buf = buf;
                } else {
                    if ((_buf = static_cast<charT*>(malloc(n * sizeof(charT)))) == NULL)
                        throw std::bad_alloc();
                }
                _size = n;
            }
        }

        size_type rfind(const StringT &s, size_type pos = npos, bool icase = false) const {
            return rfind(s.data(), pos, s.length(), icase);
        }

        size_type rfind(const charT *s, size_type pos = npos, bool icase = false) const {
            return rfind(s, pos, traits::length(s), icase);
        }

        size_type rfind(const charT *s, size_type pos, size_type len, bool icase = false) const {
            size_type i;
            size_type ret = npos;

            if (pos == npos || pos + len > _len) {
                if (len <= _len)
                    pos = _len - len;
                else
                    len = 0;   // search string is larger than this string -> cannot be found
            }
            if (len > 0) {
                if (icase) {
                    for (i = 0; pos != npos; ) {
                        if (traits::tolower(s[i]) == traits::tolower(_buf[pos + i])) {
                            if (++i >= len) {
                                ret = pos;
                                break;
                            }
                        } else {
                            i = 0;
                            pos--;
                        }
                    }
                } else {
                    for (i = 0; pos != npos; ) {
                        if (s[i] == _buf[pos + i]) {
                            if (++i >= len) {
                                ret = pos;
                                break;
                            }
                        } else {
                            i = 0;
                            pos--;
                        }
                    }
                }
            }

            return ret;
        }

        size_type rfind(charT ch, size_type pos = npos) const {
            size_type ret;

            if (pos == npos)
                pos = _len - 1;
            for (ret = pos; ret != npos && _buf[ret] != ch; ret--) ;

            return ret;
        }

        void setCharAt(size_type pos, charT ch) {
            if (pos < _len)
                _buf[pos] = ch;
        }

        void setLength(size_type len) {
            if (len) {
                if (len >= _size)
                    resize(len);
                _buf[len] = traits::nul;
            } else {
                if (_buf)
                    *_buf = traits::nul;
            }
            _len = len;
        }

        size_type size() const {
            return _len;
        }


        std::vector<StringT> split(const charT *delim) const {
            size_type            nxpos;
            size_type            pos;
            std::vector<StringT> ret;
            StringT              tmp;

            for (pos = 0; pos != npos; pos = nxpos) {
                if ((nxpos = find_first_of(delim, pos)) == npos)
                    tmp = substr(pos);
                else {
                    tmp = substr(pos, nxpos - pos);
                    nxpos++;
                }
                if (!tmp.trim().empty())
                    ret.push_back(tmp);
            }
            return ret;
        }


        charT *stealBuffer(size_type *rlen = NULL, size_type *rsize = NULL) {
            charT *ret;

            if (rlen)
                *rlen = _len;
            if (rsize)
                *rsize = _size;
            _len = _size = 0;
            ret = _buf;
            _buf = NULL;
            return ret;
        }

        StringT substr(size_type pos = 0, size_type len = npos) const {
            StringT ret;

            if (pos < _len) {
                if (len > _len - pos)
                    len = _len - pos;
                if (len > 0)
                    ret.assign(_buf + pos, len);
            }
            return ret;
        }

        StringT left(size_type len) const {
            return substr(0, len);
        }

        StringT &ltrim() {
            size_type i;

            if (_len) {
                for (i = 0; i < _len; i++)
                    if (!traits::isspace(_buf[i]))
                        break;
                if (i > 0) {
                    _len -= i;
                    if (_len > 0)
                        traits::memmove(_buf, _buf + i, _len);
                }
                _buf[_len] = traits::nul;
            }
            return *this;
        }

        StringT right(size_type len) const {
            return substr(len < _len ? _len - len : 0, len);
        }

        StringT &rtrim() {
            size_type i;

            if (_len) {
                for (i = _len - 1; i != npos; i--)
                    if (!traits::isspace(_buf[i]))
                        break;
                _buf[_len = i + 1] = traits::nul;
            }
            return *this;
        }

        StringT &toLowerCase() {
            size_type i;

            for (i = 0; i < _len; i++)
                _buf[i] = traits::tolower(_buf[i]);
            return *this;
        }

        StringT &toUpperCase() {
            size_type i;

            for (i = 0; i < _len; i++)
                _buf[i] = traits::toupper(_buf[i]);
            return *this;
        }

        StringT &trim() {
            size_type i;

            if (_len) {
                for (i = _len - 1; i != npos; i--)
                    if (!traits::isspace(_buf[i]))
                        break;
                _len = i + 1;
                for (i = 0; i < _len; i++)
                    if (!traits::isspace(_buf[i]))
                        break;
                if (i > 0) {
                    _len -= i;
                    if (_len > 0)
                        traits::memmove(_buf,_buf+i,_len);
                }
                _buf[_len] = traits::nul;
            }
            return *this;
        }

        StringT &trim(charT c) {
            size_type i;

            if (_len) {
                for (i = _len - 1; i != npos; i--)
                    if (_buf[i] != c)
                        break;
                _len = i + 1;
                for (i = 0; i < _len; i++)
                    if (_buf[i] != c)
                        break;
                if (i > 0) {
                    _len -= i;
                    if (_len > 0)
                        traits::memmove(_buf,_buf+i,_len);
                }
                _buf[_len] = traits::nul;
            }
            return *this;
        }


        void useBuffer(charT *buf) {
            size_type len;

            len = traits::length(buf);
            useBuffer(buf, len, len + 1);
        }

        void useBuffer(charT *buf, size_type len, size_type bufsize) {
            if (_buf)
                free(_buf);
            if ((_buf = buf) != NULL) {
                _len = len;
                _size = bufsize;
            } else
                _len = _size = 0;
        }

        void releaseBuffer() {
            _buf = NULL;
            _len = _size = 0;
        }

        charT &operator[](size_type pos) {
            if (pos >= _len)
                throw std::range_error(StringT<char>().assignf("base::StringT[] index out of range: %u >= %u", pos, _len).c_str());
            return _buf[pos];
        }

        charT operator[](size_type pos) const {
            return pos < _len ? _buf[pos] : traits::nul;
        }

        operator void*() const {
            return _len <= 0 ? NULL : _buf;
        }

        bool operator!() const {
            return _len <= 0;
        }

        StringT &operator=(const StringT &s) {
            return assign(s);
        }

        template<typename T> StringT &operator=(T t) {
            return assign(t);
        }

        template<typename T> StringT &operator+=(T t) {
            return append(t);
        }

        bool operator==(const StringT &s) const {
            return compare(s) == 0;
        }

        bool operator==(const charT *s) const {
            return compare(s) == 0;
        }

        bool operator!=(const StringT &s) const {
            return compare(s) != 0;
        }

        bool operator!=(const charT *s) const {
            return compare(s) != 0;
        }

        bool operator<(const StringT &s) const {
            return compare(s) < 0;
        }

        bool operator<(const charT *s) const {
            return compare(s) < 0;
        }

        bool operator<=(const StringT &s) const {
            return compare(s) <= 0;
        }

        bool operator<=(const charT *s) const {
            return compare(s) <= 0;
        }

        bool operator>(const StringT &s) const {
            return compare(s) > 0;
        }

        bool operator>(const charT *s) const {
            return compare(s) > 0;
        }

        bool operator>=(const StringT &s) const {
            return compare(s) >= 0;
        }

        bool operator>=(const charT *s) const {
            return compare(s) >= 0;
        }

    protected:
        charT     *_buf;   
        size_type  _len;   
        size_type  _size;  
    };

    typedef StringT<char>    String;   
    typedef StringT<wchar_t> WString;  

    template<class charT, class traits, class T> StringT<charT, traits> operator+(const StringT<charT, traits> &s, T t) {
        StringT<charT, traits> ret = s;
        ret.append(t);
        return ret;
    }

    template<class streamT, class charT, class traits> streamT &operator<<(streamT &out, const StringT<charT, traits> &s) {
        return out.write(s.data(), static_cast<std::streamsize>(s.length()));
    }

    template<class streamT, class charT, class traits> streamT &operator>>(streamT &in, StringT<charT, traits> &s) {
        charT ch;

        while (in.get(ch) && traits::isspace(ch)) ;
        if (in) {
            s = ch;
            while (in.get(ch) && !traits::isspace(ch))
                s.append(ch);
        }
        return in;
    }

    template<class charT, class intT>
    size_t uinttostr(intT i, charT *str, size_t size, unsigned char nbase = 10, charT ca = CharTraits<charT>::chA) {
        size_t ret = 0;

        if (nbase < 2 || nbase > 36)
            throw std::invalid_argument("base::uinttostr invalid nbase");

        if (str != NULL && size > 0) {
            size_t                                  a;
            size_t                                  b;
            charT                                   c;
            typename IntTraits<intT>::unsigned_type n = i;
            unsigned char                           j;

            do {
                if (ret == size)
                    break;
                j = n % nbase;
                if (j < 10)
                    str[ret++] = CharTraits<charT>::ch0 + j;
                else
                    str[ret++] = ca + (j - 10);
                n /= nbase;
            } while (n != 0);

            if (ret < size) {
                // add terminating null byte
                str[ret] = CharTraits<charT>::nul;
                // reverse string
                for (a = 0, b = ret / 2; a < b; a++) {
                    c = str[a];
                    str[a] = str[ret - a - 1];
                    str[ret - a - 1] = c;
                }
            } else
                str[0] = CharTraits<charT>::nul;
        }

        return ret;
    }

    template<class charT, class intT>
    StringT<charT> uinttostr(intT i, unsigned char nbase = 10, charT ca = CharTraits<charT>::chA) {
        charT buf[128];

        if (uinttostr(i, buf, sizeof(buf) / sizeof(charT), nbase, ca) == sizeof(buf) / sizeof(charT)) {
            // should not happen
            throw std::length_error("base::uinttostr buffer too small");
        }

        return buf;
    }

    template<class charT, class intT>
    size_t inttostr(intT i, charT *str, size_t size, unsigned char nbase = 10, charT ca = CharTraits<charT>::chA) {
        size_t ret = 0;

        if (nbase < 2 || nbase > 36)
            throw std::invalid_argument("base::inttostr invalid nbase");

        if (str != NULL && size > 0) {
            typename IntTraits<intT>::unsigned_type n;

            if (i < 0) {
                n = -i;
                str[ret++] = '-';
                size--;
                str++;
            } else
                n = i;

            ret += uinttostr(n, str, size, nbase, ca);
        }

        return ret;
    }

    template<class charT, class intT>
    StringT<charT> inttostr(intT i, unsigned char nbase = 10, charT ca = CharTraits<charT>::chA) {
        charT buf[128];

        if (inttostr(i, buf, sizeof(buf) / sizeof(charT), nbase, ca) == sizeof(buf) / sizeof(charT)) {
            // should not happen
            throw std::length_error("base::inttostr buffer too small");
        }

        return buf;
    }

    template<class charT, class intT>
    bool strtoint(const charT *str, intT *rint, int nbase = 0, const charT **rpos = NULL) {
        bool neg;
        intT ret = 0;
        intT tmp;

        *rint = 0;
        if (rpos)
            *rpos = str;
        if (str == NULL)
            return false;
        while (CharTraits<charT>::isspace(*str))
            str++;
        if (*str == CharTraits<charT>::ch_neg) {
            neg = true;
            str++;
        } else
            neg = false;
        if (nbase == 0) {
            if (*str == CharTraits<charT>::ch0) {
                str++;
                if (*str == CharTraits<charT>::chx || *str == CharTraits<charT>::chX) {
                    nbase = 16;
                    str++;
                } else if (*str == CharTraits<charT>::nul) {
                    nbase = 10;   // plain "0"
                    str--;
                } else
                    nbase = 8;
            } else
                nbase = 10;
        }
        if (*str == CharTraits<charT>::nul) {
            if (rpos)
                *rpos = str;
            return false;
        }
        if (nbase > 1 && nbase <= 10) {
            while (*str >= CharTraits<charT>::ch0 && *str < CharTraits<charT>::ch0 + nbase) {
                tmp = ret;
                ret *= nbase;
                if (ret < tmp) {   // overflow
                    if (rpos)
                        *rpos = str;
                    return false;
                }
                ret += *str - CharTraits<charT>::ch0;
                str++;
            }
        } else if (nbase > 10 && nbase <= 36) {
            for (;;) {
                if (*str >= CharTraits<charT>::ch0 && *str < CharTraits<charT>::ch0 + 10) {
                    ret *= nbase;
                    ret += *str - CharTraits<charT>::ch0;
                } else if (*str >= CharTraits<charT>::cha && *str < CharTraits<charT>::cha + nbase - 10) {
                    ret *= nbase;
                    ret += *str - CharTraits<charT>::cha + 10;
                } else if (*str >= CharTraits<charT>::chA && *str < CharTraits<charT>::chA + nbase - 10) {
                    ret *= nbase;
                    ret += *str - CharTraits<charT>::chA + 10;
                } else
                    break;
                str++;
            }
        } else
            return false;
        if (*str != CharTraits<charT>::nul && rpos == NULL) {
            while (*str != CharTraits<charT>::nul && CharTraits<charT>::isspace(*str))
                str++;
            if (*str != CharTraits<charT>::nul)
                return false;
        }
        if (rpos != NULL)
            *rpos = str;
        if (neg) {
        #ifdef _MSC_VER
            #pragma warning (suppress: 4146)   // unary minus operator applied to unsigned type, result still unsigned
        #endif
            *rint = -ret;
        } else
            *rint = ret;
        return true;
    }

    template<class charT, class intT>
    bool strtoint(const StringT<charT> &str, intT *rint, int nbase = 0, const charT **rpos = NULL) {
        return strtoint(str.c_str(), rint, nbase, rpos);
    }

}   // namespace base

#endif