string.h

Go to the documentation of this file.

// Evo C++ Library
/* Copyright 2019 Justin Crowell
Distributed under the BSD 2-Clause License -- see included file LICENSE.txt for details.
*/

#pragma once
#ifndef INCL_evo_string_h
#define INCL_evo_string_h

#include "list.h"
#include "strscan.h"

namespace evo {


template<class T, int PADDING=1>
struct StringInt : public ListBase<char,StrSizeT> {
    typedef StringInt<T,PADDING> ThisType;                          
    typedef StrSizeT             Size;                              

    static const int BUF_SIZE = IntegerT<T>::MAXSTRLEN + PADDING;   

    char buffer[BUF_SIZE];      

    using ListBase<char,StrSizeT>::data_;
    using ListBase<char,StrSizeT>::size_;

    StringInt()
        { }

    StringInt(T num, int base=fDEC, bool terminated=true, uint end_padding=0)
        { set(num, base, terminated, end_padding); }

    char* data()
        { return data_; }

    Size size() const
        { return size_; }

    ThisType& set() {
        data_ = NULL;
        size_ = 0;
        return *this;
    }

    char* set(T num, int base=fDEC, bool terminated=true, uint end_padding=0) {
        assert( base >= 2 );
        assert( base <= 36 );
        assert( end_padding <= BUF_SIZE - IntegerT<T>::MAXSTRLEN ); // Must have room for formatting and padding
        char* endptr = buffer + BUF_SIZE - end_padding;
        if (terminated) {
            assert( BUF_SIZE > IntegerT<T>::MAXSTRLEN );    // Terminator requires padding > 0
            *--endptr = '\0';
        }
        if (IsSigned<T>::value)
            size_ = impl::fnum(endptr, num, base);
        else
            size_ = impl::fnumu(endptr, num, base);
        data_ = endptr - size_;
        return data_;
    }

    ThisType& add(const char* data, Size size) {
        assert( data != NULL );
        assert( data_ != NULL );
        memcpy(data_ + size_, data, size);
        size_ += size;
        return *this;
    }

    char* addnew(Size size) {
        assert( data_ != NULL );
        char* p = data_ + size_;
        size_ += size;
        return p;
    }

private:
    // Disable copying
    StringInt(StringInt&);
    StringInt& operator=(StringInt&);
};


template<class T=double, int PADDING=1>
struct StringFlt : public ListBase<char,StrSizeT> {
    typedef StringFlt<T,PADDING> ThisType;                              
    typedef StrSizeT             Size;                                  

    static const int BUF_SIZE = FloatT<T>::MAXDIGITS_AUTO + PADDING;    

    char buffer[BUF_SIZE];      

    using ListBase<char,StrSizeT>::data_;
    using ListBase<char,StrSizeT>::size_;

    struct NumInfo {
        Size size;          
        T    number;        
        int  exponent;      
        int  precision;     
        bool terminated;    

        NumInfo()
            { memset(this, 0, sizeof(NumInfo)); }

        char* format(char* ptr) {
            const ulong len = impl::fnumf(ptr, number, exponent, precision);
            if (terminated)
                ptr[len] = '\0';
            assert( len < IntegerT<Size>::MAX );
            size = (Size)len;
            return ptr;
        }
    };

    StringFlt() : dbuffer_(NULL), dbuffer_size_(0)
        { }

    StringFlt(T num, int precision=fPREC_AUTO, bool terminated=true) : dbuffer_(NULL), dbuffer_size_(0)
        { set(num, precision, terminated); }

    ~StringFlt()
        { free(); }

    char* data()
        { return data_; }

    Size size() const
        { return size_; }

    ThisType& set() {
        data_ = NULL;
        size_ = 0;
        return *this;
    }

    char* set(T num, int precision=fPREC_AUTO, bool terminated=true, NumInfo* info=NULL) {
        ulong len;
        int exp = 0;
        if (precision < 0) {
            // fPREC_AUTO
            data_ = buffer;
            num = FloatT<T>::fexp10(exp, num);
            len = impl::fnumfe(data_, num, exp, false);
            assert( len <= (ulong)BUF_SIZE );
        } else {
            // Explicit precision may require allocating memory
            num = FloatT<T>::fexp10(exp, impl::fnumf_weight(num, precision));
            ulong maxsize = (ulong)FloatT<T>::maxdigits_prec(exp, precision) + PADDING;
            assert( maxsize > 0 );
            assert( maxsize < IntegerT<Size>::MAX );
            if (maxsize > (ulong)BUF_SIZE) {
                if (maxsize > dbuffer_size_) {
                    if (info != NULL) {
                        // No alloc, populate info to defer formatting
                        info->size       = maxsize;
                        info->number     = num;
                        info->exponent   = exp;
                        info->precision  = precision;
                        info->terminated = terminated;
                        return NULL;
                    }
                    free();
                    assert( maxsize < IntegerT<size_t>::MAX );
                    dbuffer_      = (char*)::malloc((size_t)maxsize);
                    dbuffer_size_ = (Size)maxsize;
                }
                data_ = dbuffer_;
            } else
                data_ = buffer;
            len = impl::fnumf(data_, num, exp, precision);
        }
        if (terminated) {
            assert( PADDING > 0 );    // Terminator requires padding > 0
            data_[len] = '\0';
        }
        assert( len < IntegerT<Size>::MAX );
        size_ = (Size)len;
        return data_;
    }

private:
    // Disable copying
    StringFlt(StringFlt&);
    StringFlt& operator=(StringFlt&);

    // Dynamic buffer
    char* dbuffer_;
    Size dbuffer_size_;

    void free() {
        if (dbuffer_ != NULL)
            ::free(dbuffer_);
    }
};


class String : public List<char,StrSizeT> {
public:
    typedef String                        ThisType;     
    typedef List<char,StrSizeT>           ListType;     
    typedef String                        Out;          

    typedef ListBaseType           StringBase;          
    typedef ListBase<wchar16,Size> UnicodeStringBase;   

    String()
        { }

    String(const String& str) : List<char,Size>(str)
        { }

    String(const ListType& str) : List<char,Size>(str)
        { }

    String(const ListType* str)
        { if (str != NULL) set(*str); }

    String(const ListType& str, Key index, Key size=ALL) : List<char,Size>(str, index, size)
        { }

    String(const StringBase& str, Key index=0, Key size=ALL) : List<char,Size>(str, index, size)
        { }

    String(const char* str, Size size) : List<char,Size>(str, size)
        { }

    String(const PtrBase<char>& str, Size size) {
        if (str.ptr_ != NULL) {
            if (size > 0)
                copy(str.ptr_, size);
            else
                setempty();
        }
    }

    String(const UnicodeStringBase& str)
        { set_unicode(str.data_, str.size_); }

    String(const char* str) : List<char,Size>(str, str?(Size)strlen(str):0) {
        #if EVO_LIST_OPT_REFTERM
            terminated_ = true;
        #endif
    }

    String(const PtrBase<char>& str) {
        if (str.ptr_ != NULL) {
            const size_t len = strlen(str.ptr_);
            assert( len < IntegerT<Size>::MAX );
            copy(str.ptr_, (Size)len);
        }
    }

#if defined(EVO_CPP11)

    String(const char16_t* str, Size size, UtfMode mode=umREPLACE_INVALID) {
        set_unicode(str, size, mode);
    }

    String(const char16_t* str, UtfMode mode=umREPLACE_INVALID) {
        set_unicode(str, mode);
    }

    String(const std::initializer_list<char>& init) {
        assert( init.size() < IntegerT<Size>::MAX );
        ListType::advAdd((Size)init.size());
        char* p = data_;
        for (auto ch : init)
            *(p++) = ch;
    }

    String(String&& src) : List<char>(std::move(src)) {
    }

    String& operator=(String&& src) {
        List<char>::operator=(std::move(src));
        return *this;
    }

    String& operator=(const char16_t* str) {
        set_unicode(str);
        return *this;
    }
#endif

    const String& asconst() const {
        return *this;
    }

    // SET

    String& operator=(const String& str)
        { set(str); return *this; }

    String& operator=(const ListType& str)
        { set(str); return *this; }

    String& operator=(const ListType* str) {
        if (str != NULL)
            set(*str);
        else
            set();
        return *this;
    }

    String& operator=(const StringBase& data)
        { ListType::operator=(data); return *this; }

    String& operator=(const char* str) {
        if (str == NULL)
            set();
        else
            ref(str, (Size)strlen(str), true);
        return *this;
    }

    String& operator=(const PtrBase<char>& str) {
        if (str.ptr_ == NULL)
            set();
        else
            copy(str.ptr_, (Size)strlen(str.ptr_));
        return *this;
    }

    template<class T>
    String& operator=(const ListBase<wchar16,T>& str) {
        assert( str.size_ < IntegerT<Size>::MAX );
        set_unicode(str.data_, str.size_);
        return *this;
    }

    String& operator=(const ValNull&)
        { set(); return *this; }

    String& operator=(const ValEmpty&)
        { setempty(); return *this; }

    String& setempty()
        { ListType::setempty(); return *this; }

    String& set()
        { ListType::set(); return *this; }

    String& set(const ListType& str)
        { ListType::set(str); return *this; }

    String& set(const ListType& str, Key index, Key size=ALL)
        { ListType::set(str, index, size); return *this; }

    String& set(const StringBase& data, Key index=0, Key size=ALL)
        { ListType::set(data, index, size); return *this; }

    String& set(const char* str, Size size)
        { ListType::set(str, size); return *this; }

    String& set(const PtrBase<char>& str, Size size) {
        if (str.ptr_ == NULL)
            ListType::set();
        else
            ListType::copy(str.ptr_, size);
        return *this;
    }

    String& set(const char* str) {
        if (str == NULL)
            ListType::set();
        else
            ref(str, (Size)strlen(str), true);
        return *this;
    }

    String& set(const PtrBase<char>& str) {
        if (str.ptr_ == NULL)
            ListType::set();
        else
            ListType::copy(str.ptr_, (Size)strlen(str.ptr_));
        return *this;
    }

    String& set2(const ListType& str, Key index1, Key index2)
        { ListType::set2(str, index1, index2); return *this; }

    String& set2(const StringBase& data, Key index1, Key index2)
        { ListType::set2(data, index1, index2); return *this; }

    String& setn(int num, int base=fDEC)
        { setnum(num, base); return *this; }

    String& setn(long num, int base=fDEC)
        { setnum(num, base); return *this; }

    String& setn(longl num, int base=fDEC)
        { setnum(num, base); return *this; }

    String& setn(uint num, int base=fDEC)
        { setnumu(num, base); return *this; }

    String& setn(ulong num, int base=fDEC)
        { setnumu(num, base); return *this; }

    String& setn(ulongl num, int base=fDEC)
        { setnumu(num, base); return *this; }

    String& setn(float num, int precision=fPREC_AUTO)
        { setnumf(num, precision); return *this; }

    String& setn(double num, int precision=fPREC_AUTO)
        { setnumf(num, precision); return *this; }

    String& setn(ldouble num, int precision=fPREC_AUTO)
        { setnumf(num, precision); return *this; }

    bool set_unicode(const wchar16* str, Size size, UtfMode mode=umREPLACE_INVALID) {
        if (str == NULL) {
            set();
        } else {
            clear();
            const wchar16* p = str;
            const wchar16* end = str + size;
            ulong bytes = utf16_to8(p, end, NULL, 0, mode);
            if (bytes == END)
                return false;
            if (bytes > 0) {
                assert( bytes < IntegerT<Size>::MAX );
                char* buf = advWrite(bytes + 1);
                bytes = utf16_to8(str, end, buf, bytes, mode);
                advWriteDone((Size)bytes);
            }
        }
        return true;
    }

    bool set_unicode(const wchar16* str, UtfMode mode=umREPLACE_INVALID) {
        return set_unicode(str, utf16_strlen(str), mode);
    }

#if defined(EVO_CPP11)

    bool set_unicode(const char16_t* str, Size size, UtfMode mode=umREPLACE_INVALID) {
        static_assert( sizeof(char16_t) == sizeof(wchar16), "ERROR: char16_t type larger than 16 bits" );
        return set_unicode((const wchar16*)str, size, mode);
    }

    bool set_unicode(const char16_t* str, UtfMode mode=umREPLACE_INVALID) {
        static_assert( sizeof(char16_t) == sizeof(wchar16), "ERROR: char16_t type larger than 16 bits" );
        return set_unicode((const wchar16*)str, mode);
    }
#endif

#if defined(_WIN32) || defined(DOXYGEN)

    String& set_win32(const WCHAR* str, int size) {
        if (str == NULL) {
            set();
        } else if (size <= 0) {
            setempty();
        } else {
            const int newsize = ::WideCharToMultiByte(CP_UTF8, 0, str, size, NULL, 0, NULL, NULL);
            if (newsize > 0) {
                clear();
                char* buf = advBuffer(newsize+1);
                int written = ::WideCharToMultiByte(CP_UTF8, 0, str, size, buf, newsize, NULL, NULL);
                if (written >= 0) {
                    buf[written] = '\0';
                    assert( written < IntegerT<Size>::MAX );
                    advSize(written);
                }
            } else
                set();
        }
        return *this;
    }

    String& set_win32(const WCHAR* str) {
        if (str == NULL) {
            set();
        } else if (*str == 0) {
            setempty();
        } else {
            const int newsize = ::WideCharToMultiByte(CP_UTF8, 0, str, -1, NULL, 0, NULL, NULL);
            if (newsize > 0) {
                clear();
                int written = ::WideCharToMultiByte(CP_UTF8, 0, str, -1, advBuffer(newsize), newsize, NULL, NULL);
                if (written > 0)
                    --written; // chop terminator
                assert( written < IntegerT<Size>::MAX );
                advSize(written);
            } else
                set();
        }
        return *this;
    }
#endif

    template<class StringT>
    bool token(StringT& value, char delim) {
        if (size_ > 0) {
            const char* ptr = (char*)memchr(data_, delim, size_);
            if (ptr != NULL) {
                Key i = (Key)(ptr - data_);
                value.set(data_, i);
                ++i;
                data_ += i;
                size_ -= i;
                return true;
            }
            value.set(data_, size_);
            clear();
            return true;
        }
        value.set();
        return false;
    }

    template<class StringT>
    bool tokenr(StringT& value, char delim) {
        if (size_ > 0) {
        #if defined(EVO_GLIBC_MEMRCHR)
            const char* ptr = (char*)memrchr(data_, delim, size_);
            if (ptr != NULL) {
                const Key i = (Key)(ptr - data_);
                const Size len = size_ - i;
                value.set(data_ + i + 1, len - 1);
                size_ -= len;
                return true;
            }
        #else
            for (Key i=size_; i > 0; ) {
                if (data_[--i] == delim) {
                    Size len = size_ - i;
                    value.set(data_ + i + 1, len - 1);
                    size_ -= len;
                    return true;
                }
            }
        #endif
            value.set(data_, size_);
            clear();
            return true;
        }
        value.set();
        return false;
    }

    template<class StringT>
    bool token_any(StringT& value, Char& found_delim, const char* delims, Size count) {
        assert( count > 0 );
        if (size_ > 0) {
            Size j;
            for (Key i=0; i < size_; ++i) {
                for (j=0; j < count; ++j) {
                    if (data_[i] == delims[j]) {
                        value.set(data_, i);
                        found_delim = data_[i];
                        ++i;
                        data_ += i;
                        size_ -= i;
                        return true;
                    }
                }
            }
            value.set(data_, size_);
            found_delim.set();
            clear();
            return true;
        }
        value.set();
        found_delim.set();
        return false;
    }

    template<class StringT>
    bool tokenr_any(StringT& value, Char& found_delim, const char* delims, Size count) {
        assert( count > 0 );
        if (size_ > 0) {
            Size j;
            for (Key i=size_; i > 0; ) {
                --i;
                for (j=0; j < count; ++j) {
                    if (data_[i] == delims[j]) {
                        Size len = size_ - i;
                        value.set(data_ + i + 1, len - 1);
                        found_delim = data_[i];
                        size_ -= len;
                        return true;
                    }
                }
            }
            value.set(data_, size_);
            found_delim.set();
            clear();
            return true;
        }
        value.set();
        found_delim.set();
        return false;
    }

    template<class StringT>
    bool token_line(StringT& line) {
        const char* NEWLINE_CHARS = "\n\r";
        Size i = findany(NEWLINE_CHARS, 2);
        if (i == END) {
            if (size_ > 0) {
                line.set(data_, size_);
                setempty();
                return true;
            }
            line.set();
            return false;
        }
        line.set(data_, i);

        if (++i < size_) {
            char ch1 = data_[i - 1];
            char ch2 = data_[i];
            if ((ch1 == '\n' && ch2 == '\r') || (ch1 == '\r' && ch2 == '\n'))
                ++i;
        }
        data_ += i;
        size_ -= i;
        return true;
    }

    template<class StringT>
    bool tokenr_line(StringT& line) {
        const char* NEWLINE_CHARS = "\n\r";
        Size i = findanyr(NEWLINE_CHARS, 2);
        if (i == END) {
            if (size_ > 0) {
                line.set(data_, size_);
                setempty();
                return true;
            }
            line.set();
            return false;
        }
        line.set(data_ + i + 1, size_ - i - 1);

        if (i > 1) {
            char ch1 = data_[i - 1];
            char ch2 = data_[i];
            if ((ch1 == '\n' && ch2 == '\r') || (ch1 == '\r' && ch2 == '\n'))
                --i;
        }
        size_ = i;
        return true;
    }

    // INFO

    const char* data() const
        { return data_; }

    const char* cstr(String& buffer) const
        { return (size_ > 0 ? buffer.set(*this).cstr() : ""); }

    const char* cstr() {
        const char* result = "";
        if (size_ > 0) {
            // Not empty
            if (buf_.ptr != NULL) {
                assert( buf_.header != NULL );
                assert( data_ >= buf_.ptr );
                assert( data_ < buf_.ptr+buf_.header->used );
                if (size_ + (data_-buf_.ptr) < buf_.header->used)
                    // End is sliced off, jump to add terminator
                    goto add_term;
            }

            // End not sliced
            #if EVO_LIST_OPT_REFTERM
            if (terminated_) {
                // Already terminated
                result = data_;
            } else
            #endif
            {
                // Add temporary terminator
            add_term:
                reserve(1);
                data_[size_] = '\0';
                result = data_;
            }
        }
        return result;
    }

    const char* cstrM() const
        { return (size_ > 0 ? const_cast<String*>(this)->cstr() : ""); }

    // COMPARE

    using ListType::compare;

    template<class T>
    int compare(const ListBase<wchar16,T>& str) {
        assert( str.size_ < ULong::MAX );
        return -utf16_compare8(str.data_, str.size_, data_, size_);
    }

    using ListType::operator==;
    using ListType::operator!=;

    bool operator==(const String& str) const
        { return ListType::operator==(str); }

    bool operator==(const char* str) const {
        return (utf8_compare(data_, size_, str) == 0);
    }

    template<class T>
    bool operator==(const ListBase<wchar16,T>& str) {
        assert( str.size_ < ULong::MAX );
        return (utf16_compare8(str.data_, str.size_, data_, size_) == 0);
    }

    bool operator!=(const String& str) const
        { return ListType::operator!=(str); }

    bool operator!=(const char* str) const {
        return (utf8_compare(data_, size_, str) != 0);
    }

    template<class T>
    bool operator!=(const ListBase<wchar16,T>& str) {
        assert( str.size_ < ULong::MAX );
        return (utf16_compare8(str.data_, str.size_, data_, size_) != 0);
    }

    using ListType::starts;
    using ListType::ends;

    bool starts(char ch) const
        { return ListType::starts(ch); }

    bool ends(char ch) const
        { return ListType::ends(ch); }

    // FIND

    Iter cbegin() const
        { return Iter(*this); }

    Iter cend() const
        { return Iter(); }

    IterM begin()
        { return IterM(*this); }

    Iter begin() const
        { return Iter(*this); }

    IterM end()
        { return IterM(); }

    Iter end() const
        { return Iter(); }

    Key find(char ch) const {
        if (size_ > 0) {
            const char* ptr = (char*)memchr(data_, ch, size_);
            if (ptr != NULL)
                return (Key)(ptr - data_);
        }
        return NONE;
    }

    Key find(char ch, Key start, Key end=END) const {
        if (start < size_) {
            if (end > size_)
                end = size_;
            if (start < end) {
                const char* ptr = (char*)memchr(data_ + start, ch, end - start);
                if (ptr != NULL)
                    return (Key)(ptr - data_);
            }
        }
        return NONE;
    }

    Key find(const char* pattern, uint pattern_size, Key start=0, Key end=END) const {
        if (start < size_ && start < end) {
            assert( pattern != NULL );
            if (end > size_)
                end = size_;
            return impl::string_search(pattern, pattern_size, data_ + start, end - start, start);
        }
        return NONE;
    }

    Key find(StringSearchAlg alg, const char* pattern, uint pattern_size, Key start=0, Key end=END) const {
        if (start < size_ && start < end) {
            assert( pattern != NULL );
            if (end > size_)
                end = size_;
            return impl::string_search(alg, pattern, pattern_size, data_ + start, end - start, start);
        }
        return NONE;
    }

    Key find(const StringBase& pattern, Key start=0, Key end=END) const {
        if (start < size_ && start < end) {
            if (end > size_)
                end = size_;
            return impl::string_search(pattern.data_, pattern.size_, data_ + start, end - start, start);
        }
        return NONE;
    }

    Key find(StringSearchAlg alg, const StringBase& pattern, Key start=0, Key end=END) const {
        if (start < size_ && start < end) {
            if (end > size_)
                end = size_;
            return impl::string_search(alg, pattern.data_, pattern.size_, data_ + start, end - start, start);
        }
        return NONE;
    }

    Key findr(char ch) const {
    #if !defined(EVO_NO_MEMRCHR) && defined(EVO_GLIBC_MEMRCHR)
        if (size_ > 0) {
            const char* ptr = (char*)memrchr(data_, ch, size_);
            if (ptr != NULL)
                return (Key)(ptr - data_);
        }
    #else
        const char* ptr = data_ + size_;
        while (ptr > data_)
            if (*--ptr == ch)
                return (Key)(ptr - data_);
    #endif
        return NONE;
    }

    Key findr(char ch, Key start, Key end=END) const {
    #if !defined(EVO_NO_MEMRCHR) && defined(EVO_GLIBC_MEMRCHR)
        if (start < size_) {
            if (end > size_)
                end = size_;
            if (start < end) {
                const char* ptr = (char*)memrchr(data_ + start, ch, end - start);
                if (ptr != NULL)
                    return (Key)(ptr - data_);
            }
        }
    #else
        if (end > size_)
            end = size_;
        while (end>start)
            if (data_[--end] == ch)
                return end;
    #endif
        return NONE;
    }

    Key findr(const char* pattern, uint pattern_size, Key start=0, Key end=END) const {
        if (start < size_ && start < end) {
            assert( pattern != NULL );
            if (end > size_)
                end = size_;
            return impl::string_search_reverse(pattern, pattern_size, data_ + start, end - start, start);
        }
        return NONE;
    }

    Key findr(StringSearchAlg alg, const char* pattern, uint pattern_size, Key start=0, Key end=END) const {
        if (start < size_ && start < end) {
            assert( pattern != NULL );
            if (end > size_)
                end = size_;
            return impl::string_search_reverse(alg, pattern, pattern_size, data_ + start, end - start, start);
        }
        return NONE;
    }

    Key findr(const StringBase& pattern, Key start=0, Key end=END) const {
        if (start < size_ && start < end) {
            if (end > size_)
                end = size_;
            return impl::string_search_reverse(pattern.data_, pattern.size_, data_ + start, end - start, start);
        }
        return NONE;
    }

    Key findr(StringSearchAlg alg, const StringBase& pattern, Key start=0, Key end=END) const {
        if (start < size_ && start < end) {
            if (end > size_)
                end = size_;
            return impl::string_search_reverse(alg, pattern.data_, pattern.size_, data_ + start, end - start, start);
        }
        return NONE;
    }

    Key findany(const char* chars, Size count, Key start=0, Key end=END) const {
        if (start < size_ && start < end && count > 0) {
            if (end > size_)
                end = size_;
            if (count == 1) {
                // Special case for single char
                const char* ptr = (char*)memchr(data_ + start, *chars, end - start);
                if (ptr != NULL)
                    return (Key)(ptr - data_);
            } else {
                const char* pend = data_ + end;
                const char* ptr  = data_ + start;
                for (; ptr < pend; ++ptr)
                    if (memchr(chars, *ptr, count) != NULL)
                        return (Key)(ptr - data_);
            }
        }
        return NONE;
    }

    Key findany(const StringBase& chars, Key start=0, Key end=END) const
        { return findany(chars.data_, chars.size_, start, end); }

    Key findanyr(const char* chars, Size count, Key start=0, Key end=END) const {
        if (count == 1)
            return findr(*chars, start, end);
        if (start < size_ && start < end && count > 0) {
            if (end > size_)
                end = size_;
            const char* pstart = data_ + start;
            const char* ptr    = data_ + end;
            while (ptr > pstart)
                if (memchr(chars, *--ptr, count) != NULL)
                    return (Key)(ptr - data_);
        }
        return NONE;
    }

    Key findanyr(const StringBase& chars, Key start=0, Key end=END) const
        { return findanyr(chars.data_, chars.size_, start, end); }

    Key findanybut(const char* chars, Size count, Key start=0, Key end=END) const {
        if (start < size_ && start < end) {
            if (count == 0)
                return start;
            if (end > size_)
                end = size_;
            const char* pend = data_ + end;
            const char* ptr  = data_ + start;
            for (; ptr < pend; ++ptr)
                if (memchr(chars, *ptr, count) == NULL)
                    return (Key)(ptr - data_);
        }
        return NONE;
    }

    Key findanybut(const StringBase& chars, Key start=0, Key end=END) const
        { return findanybut(chars.data_, chars.size_, start, end); }

    Key findanybutr(const char* chars, Size count, Key start=0, Key end=END) const {
        if (start < size_ && start < end) {
            if (end > size_)
                end = size_;
            if (count == 0)
                return end - 1;
            const char* pstart = data_ + start;
            const char* ptr    = data_ + end;
            while (ptr > pstart)
                if (memchr(chars, *--ptr, count) == NULL)
                    return (Key)(ptr - data_);
        }
        return NONE;
    }

    Key findanybutr(const StringBase& chars, Key start=0, Key end=END) const
        { return findanybutr(chars.data_, chars.size_, start, end); }

    Key findword(Key start=0, Key end=END) const {
        if (start < size_ && start < end) {
            if (end > size_)
                end = size_;
            for (; start < end; ++start)
                if (ascii_breaktype(data_[start]) == cbtWORD)
                    return start;
        }
        return NONE;
    }

    Key findwordr(Key start=0, Key end=END) const {
        if (start < size_ && start < end) {
            if (end > size_)
                end = size_;
            while (end > start)
                if (ascii_breaktype(data_[--end]) == cbtWORD)
                    return end;
        }
        return NONE;
    }

    Key findnonword(Key start=0, Key end=END) const {
        if (start < size_ && start < end) {
            if (end > size_)
                end = size_;
            for (; start < end; ++start)
                if (ascii_breaktype(data_[start]) != cbtWORD)
                    return start;
        }
        return NONE;
    }

    Key findnonwordr(Key start=0, Key end=END) const {
        if (start < size_ && start < end) {
            if (end > size_)
                end = size_;
            while (end > start)
                if (ascii_breaktype(data_[--end]) != cbtWORD)
                    return end;
        }
        return NONE;
    }

    bool contains(char ch) const
        { return find(ch) != NONE; }

    bool contains(const char* str, Size size) const 
        { return find(str, size) != NONE; }

    bool contains(const StringBase& str) const 
        { return find(str) != NONE; }

    // SPLIT

    template<class T1,class T2>
    bool split(char delim, T1& left, T2& right) const {
        for (Key i=0; i<size_; ++i) {
            if (data_[i] == delim) {
                left.set(*this).slice(0, i);
                right.set(*this).slice(i+1, ALL);
                return true;
            }
        }
        left.set(*this);
        right.set();
        return false;
    }

    template<class T1>
    bool split(char delim, T1& left) const {
        for (Key i=0; i<size_; ++i) {
            if (data_[i] == delim) {
                left.set(*this).slice(0, i);
                return true;
            }
        }
        left.set(*this);
        return false;
    }

    template<class T2>
    bool split(char delim, ValNull left, T2& right) const {
        EVO_PARAM_UNUSED(left);
        for (Key i=0; i<size_; ++i) {
            if (data_[i] == delim) {
                right.set(*this).slice(i+1, ALL);
                return true;
            }
        }
        right.set();
        return false;
    }

    template<class T1,class T2>
    bool splitr(char delim, T1& left, T2& right) const {
        for (Key i=size_; i>0; ) {
            if (data_[--i] == delim) {
                left.set(*this).slice(0, i);
                right.set(*this).slice(i+1, ALL);
                return true;
            }
        }
        left.set(*this);
        right.set();
        return false;
    }

    template<class T1>
    bool splitr(char delim, T1& left) const {
        for (Key i=size_; i>0; ) {
            if (data_[--i] == delim) {
                left.set(*this).slice(0, i);
                return true;
            }
        }
        left.set(*this);
        return false;
    }

    template<class T2>
    bool splitr(char delim, ValNull left, T2& right) const {
        EVO_PARAM_UNUSED(left);
        for (Key i=size_; i>0; ) {
            if (data_[--i] == delim) {
                right.set(*this).slice(i+1, ALL);
                return true;
            }
        }
        right.set();
        return false;
    }

    // TRIM/STRIP

    String& strip() {
        char ch;
        while ( size_ > 0 && ((ch=data_[size_-1]) == ' ' || ch == '\t') )
            --size_;
        Size count = 0;
        while ( count < size_ && ((ch=data_[count]) == ' ' || ch == '\t') )
            ++count;
        triml(count);
        return *this;
    }

    String& strip(char ch) {
        while (size_ > 0 && data_[size_-1] == ch)
            --size_;
        Size count = 0;
        while (count < size_ && data_[count] == ch)
            ++count;
        triml(count);
        return *this;
    }

    String& stripl() {
        char ch;
        Size count = 0;
        while ( count < size_ && ((ch=data_[count]) == ' ' || ch == '\t') )
            ++count;
        triml(count);
        return *this;
    }

    String& stripl(char ch, Size max=ALL) {
        Size count = 0;
        while (count < size_ && data_[count] == ch && count < max)
            ++count;
        triml(count);
        return *this;
    }

    String& stripl(const char* str, Size strsize, Size max=ALL) {
        if (strsize > 0 && strsize <= size_ && max > 0) {
            Size i, j = 0, count = 0;
            do {
                for (i=0; i < strsize; ++i, ++j)
                    if (j >= size_ || str[i] != data_[j])
                        goto break_all;
                ++count;
            } while (j < size_ && count < max);
        break_all:
            if (count > 0) {
                count *= strsize;
                size_ -= count;
                data_ += count;
            }
        }
        return *this;
    }

    String& stripr() {
        char ch;
        while ( size_ > 0 && ((ch=data_[size_-1]) == ' ' || ch == '\t') )
            --size_;
        return *this;
    }

    String& stripr(char ch, Size max=ALL) {
        for (Size i=0; size_ > 0 && data_[size_-1] == ch && i < max; ++i)
            --size_;
        return *this;
    }

    String& stripr(const char* str, Size strsize, Size max=ALL) {
        if (strsize > 0 && strsize <= size_ && max > 0) {
            Size i, j = size_, count = 0;
            do {
                for (i=strsize; i > 0; )
                    if (j == 0 || str[--i] != data_[--j])
                        goto break_all;
                ++count;
            } while (j > 0 && count < max);
        break_all:
            if (count > 0)
                size_ -= (count * strsize);
        }
        return *this;
    }

    String& strip2() {
        if (size_ > 0) {
            const char* end = data_ + size_;
            data_ = (char*)str_scan_nws(data_, end);
            size_ = (Size)(str_scan_nws_r(data_, end) - data_);
        }
        return *this;
    }

    String& stripl2() {
        if (size_ > 0) {
            const char* end = data_ + size_;
            data_ = (char*)str_scan_nws(data_, end);
            size_ = (Size)(end - data_);
        }
        return *this;
    }

    String& stripr2() {
        if (size_ > 0) {
            const char* end = data_ + size_;
            size_ = (Size)(str_scan_nws_r(data_, end) - data_);
        }
        return *this;
    }

    String& stripl_newlines() {
        char ch;
        Size count = 0;
        while ( count < size_ && ((ch=data_[count]) == '\n' || ch == '\r') )
            ++count;
        if (count > 0) {
            size_ -= count;
            data_ += count;
        }
        return *this;
    }

    String& stripl_newlines(Size max) {
        char ch;
        Size count = 0;
        for (; count < size_ && max > 0; --max) {
            ch = data_[count];
            if (ch == '\n') {
                if (count + 1 < size_ && data_[count + 1] == '\r') {
                    count += 2;
                    continue;
                }
            } else if (ch == '\r') {
                if (count + 1 < size_ && data_[count + 1] == '\n') {
                    count += 2;
                    continue;
                }
            } else
                break;
            ++count;
        }
        triml(count);
        return *this;
    }

    String& stripr_newlines() {
        char ch;
        while ( size_ > 0 && ((ch=data_[size_-1]) == '\n' || ch == '\r') )
            --size_;
        return *this;
    }

    String& stripr_newlines(Size max) {
        char ch;
        for (; size_ > 0 && max > 0; --max) {
            ch = data_[size_ - 1];
            if (ch == '\n') {
                if (size_ > 1 && data_[size_ - 2] == '\r') {
                    size_ -= 2;
                    continue;
                }
            } else if (ch == '\r') {
                if (size_ > 1 && data_[size_ - 2] == '\n') {
                    size_ -= 2;
                    continue;
                }
            } else
                break;
            --size_;
        }
        return *this;
    }

    String& strip_newlines() {
        stripl_newlines();
        stripr_newlines();
        return *this;
    }

    // COPY

    String& copy(const ListType& str)
        { ListType::copy(str); return *this; }

    String& copy(const StringBase& str)
        { ListType::copy(str); return *this; }

    String& copy(const char* str, Size size)
        { ListType::copy(str, size); return *this; }

    String& copy(const char* str) {
        if (str == NULL)
            ListType::set();
        else
            ListType::copy(str, (Size)strlen(str));
        return *this;
    }

    // ADD

    String& add(char ch)
        { ListType::add(ch); return *this; }

    String& add(char ch, Size count) {
        ListType::advAdd(count);
        if (count > 0)
            memset(data_ + size_ - count, (int)(uchar)ch, count);
        return *this;
    }

    String& add(const ListType& str)
        { ListType::add(str); return *this; }

    String& add(const StringBase& str)
        { ListType::add(str); return *this; }

    String& add(const char* str, Size size)
        { ListType::add(str, size); return *this; }

    String& add(const char* str)
        { if (str) add(str, (Size)strlen(str)); return *this; }

    String& addsep(char delim=',')
        { if (size_ > 0 && data_[size_-1] != delim) add(delim); return *this; }

    String& addn(int num, int base=fDEC)
        { writenum(num, base); return *this; }

    String& addn(long num, int base=fDEC)
        { writenum(num, base); return *this; }

    String& addn(longl num, int base=fDEC)
        { writenum(num, base); return *this; }

    String& addn(uint num, int base=fDEC)
        { writenumu(num, base); return *this; }

    String& addn(ulong num, int base=fDEC)
        { writenumu(num, base); return *this; }

    String& addn(ulongl num, int base=fDEC)
        { writenumu(num, base); return *this; }

    String& addn(float num, int precision=fPREC_AUTO)
        { writenumf(num, precision); return *this; }

    String& addn(double num, int precision=fPREC_AUTO)
        { writenumf(num, precision); return *this; }

    String& addn(ldouble num, int precision=fPREC_AUTO)
        { writenumf(num, precision); return *this; }

    String& operator<<(bool val) {
        if (val)
            add("true", 4);
        else
            add("false", 5);
        return *this;
    }

    String& operator<<(char ch)
        { return add(ch); }

    String& operator<<(const ListType& str)
        { return add(str); }

    String& operator<<(const StringBase& str)
        { return add(str); }

    String& operator<<(const char* str)
        { return add(str); }

    String& operator<<(const ValNull& val) {
        EVO_PARAM_UNUSED(val);
        return set();
    }

    String& operator<<(const ValEmpty& val) {
        EVO_PARAM_UNUSED(val);
        return setempty();
    }

    String& operator<<(Newline nl) {
        add(getnewline(nl), getnewlinesize(nl));
        return *this;
    }
    
    String& operator<<(Flush)
        { return *this; }

    String& operator<<(int num)
        { writenum(num); return *this; }

    String& operator<<(long num)
        { writenum(num); return *this; }

    String& operator<<(longl num)
        { writenum(num); return *this; }

    String& operator<<(uint num)
        { writenumu(num); return *this; }

    String& operator<<(ulong num)
        { writenumu(num); return *this; }

    String& operator<<(ulongl num)
        { writenumu(num); return *this; }

    String& operator<<(float num)
        { writenumf(num); return *this; }

    String& operator<<(double num)
        { writenumf(num); return *this; }

    String& operator<<(ldouble num)
        { writenumf(num); return *this; }

    String& operator<<(const FmtChar& fmt)
        { add(fmt.ch, fmt.count); return *this; }

    String& operator<<(const FmtString& fmt)
        { writefmtstr(fmt.str.data_, fmt.str.size_, fmt.fmt); return *this; }

    String& operator<<(const FmtStringWrap& fmt) {
        const char* newline_str = fmt.newline.getnewline();
        const uint newline_size = fmt.newline.getnewlinesize();

        const Size EST_LINES = (fmt.width > 0 ? fmt.str.size_ / fmt.width : 1) + 1;
        reserve(fmt.str.size_ + ((fmt.indent + newline_size + 1) * EST_LINES));

        String str(fmt.str.data_, fmt.str.size_), line, substr;
        for (uint notfirst=0; str.token_line(line); ) {
            for (;;) {
                if (line.empty()) {
                    add(newline_str, newline_size);
                } else {
                    if (notfirst == 0)
                        ++notfirst;
                    else if (fmt.indent > 0)
                        add(' ', fmt.indent);
                    if (fmt.width > 1 && line.size() > (Size)fmt.width) {
                        // line too long, try to find a word break
                        Size i = line.findnonwordr(0, (Size)fmt.width + 1);
                        if (i == NONE) {
                            i = (Size)fmt.width;
                        } else {
                            while (i > 0 && ascii_breaktype(line[i]) == cbtBEGIN)
                                --i;
                            if (i < (Size)fmt.width)
                                ++i;
                        }

                        substr.set(line.data(), i).stripr();
                        if (!substr.empty()) {
                            add(substr);
                            add(newline_str, newline_size);
                        }

                        line.triml(i).stripl();
                        continue;
                    }
                    add(line);
                    add(newline_str, newline_size);
                }
                break;
            }
        }
        return *this;
    }

    String& operator<<(const FmtShort& fmt)
        { writefmtnum(fmt.num, fmt.fmt); return *this; }

    String& operator<<(const FmtInt& fmt)
        { writefmtnum(fmt.num, fmt.fmt); return *this; }

    String& operator<<(const FmtLong& fmt)
        { writefmtnum(fmt.num, fmt.fmt); return *this; }

    String& operator<<(const FmtLongL& fmt)
        { writefmtnum(fmt.num, fmt.fmt); return *this; }

    String& operator<<(const FmtUShort& fmt)
        { writefmtnumu(fmt.num, fmt.fmt); return *this; }

    String& operator<<(const FmtUInt& fmt)
        { writefmtnumu(fmt.num, fmt.fmt); return *this; }

    String& operator<<(const FmtULong& fmt)
        { writefmtnumu(fmt.num, fmt.fmt); return *this; }

    String& operator<<(const FmtULongL& fmt)
        { writefmtnumu(fmt.num, fmt.fmt); return *this; }

    String& operator<<(const FmtFloat& fmt)
        { writefmtnumf(fmt.num, fmt.fmt); return *this; }

    String& operator<<(const FmtFloatD& fmt)
        { writefmtnumf(fmt.num, fmt.fmt); return *this; }

    String& operator<<(const FmtFloatL& fmt)
        { writefmtnumf(fmt.num, fmt.fmt); return *this; }

    template<class T>
    String& operator<<(const FmtFieldNum<T>& fmt) {
        if (IntegerT<T>::SIGN)
            writefmtnum(fmt.num.num, fmt.num.fmt, &fmt.field);
        else
            writefmtnumu(fmt.num.num, fmt.num.fmt, &fmt.field);
        return *this;
    }

    template<class T>
    String& operator<<(const FmtFieldFloat<T>& fmt)
        { writefmtnumf(fmt.num.num, fmt.num.fmt, &fmt.field); return *this; }

    String& operator<<(const FmtPtr& fmtptr)
        { writefmtnumu((size_t)fmtptr.ptr, fmtptr.fmt); return *this; }

    String& operator<<(const FmtDump& fmt)
        { writefmtdump(fmt, getnewline(), getnewlinesize()); return *this; }

    struct Format {
        typedef String::Size Size;  
        typedef String Out;         
        typedef Format This;        

        Out&       out;             
        FmtAttribs fmt;             

        Format(Out& out) : out(out)
            { }

        Format(const This& src) : out(src.out), fmt(src.fmt)
            { }

        This& operator=(const This& src)
            { memcpy(&fmt, &src.fmt, sizeof(FmtAttribs)); return *this; }

        Out& write_out()
            { return out; }

        // Field
        
        This& operator<<(FmtAlign align)
            { fmt.field.align = align; return *this; }

        This& operator<<(FmtWidth width)
            { fmt.field.width = width; return *this; }

        This& operator<<(const FmtSetField& field)
            { fmt.field.merge(field); return *this; }

        // Newlines/Flush

        This& operator<<(Newline nl)
            { out.add(getnewline(nl), getnewlinesize(nl)); return *this; }

        This& operator<<(Flush)
            { return *this; }

        // Null

        This& operator<<(const FmtSetNull& null)
            { fmt.null = null; return *this; }

        // Bools

        This& operator<<(bool val) {
            if (val)
                out.add("true", 4);
            else
                out.add("false", 5);
            return *this;
        }

        // Chars

        This& operator<<(char ch)
            { out.add(ch); return *this; }

        This& operator<<(const FmtChar& ch)
            { out.writefmtchar(ch.ch, ch.count, fmt.field); return *this; }

        // Strings

        This& operator<<(const char* val) {
            if (val == NULL) {
                if (fmt.null.size > 0)
                    out.writefmtstr(fmt.null.str, fmt.null.size, fmt.field);
            } else if (*val != '\0')
                out.writefmtstr(val, (Size)strlen(val), fmt.field);
            return *this;
        }

        This& operator<<(const StringBase& val) {
            if (val.data_ == NULL) {
                if (fmt.null.size > 0)
                    out.writefmtstr(fmt.null.str, fmt.null.size, fmt.field);
            } else if (val.size_ > 0)
                out.writefmtstr(val.data_, val.size_, fmt.field);
            return *this;
        }

        // Integers

        This& operator<<(FmtBase base)
            { fmt.num_int.base = base; return *this; }

        This& operator<<(FmtBasePrefix prefix)
            { fmt.num_int.prefix = prefix; return *this; }

        This& operator<<(const FmtSetInt& fmt_int)
            { fmt.num_int.merge(fmt_int); return *this; }

        This& operator<<(short num)
            { out.writefmtnum(num, fmt.num_int, &fmt.field); return *this; }

        This& operator<<(int num)
            { out.writefmtnum(num, fmt.num_int, &fmt.field); return *this; }

        This& operator<<(long num)
            { out.writefmtnum(num, fmt.num_int, &fmt.field); return *this; }

        This& operator<<(longl num)
            { out.writefmtnum(num, fmt.num_int, &fmt.field); return *this; }

        This& operator<<(ushort num)
            { out.writefmtnumu(num, fmt.num_int, &fmt.field); return *this; }

        This& operator<<(uint num)
            { out.writefmtnumu(num, fmt.num_int, &fmt.field); return *this; }

        This& operator<<(ulong num)
            { out.writefmtnumu(num, fmt.num_int, &fmt.field); return *this; }

        This& operator<<(ulongl num)
            { out.writefmtnumu(num, fmt.num_int, &fmt.field); return *this; }

        template<class T>
        This& operator<<(const IntegerT<T>& num) {
            if (num.null()) {
                if (fmt.null.size > 0)
                    out.writefmtstr(fmt.null.str, fmt.null.size, fmt.field);
            } else if (IntegerT<T>::SIGN)
                out.writefmtnum(num.value(), fmt.num_int, &fmt.field);
            else
                out.writefmtnumu(num.value(), fmt.num_int, &fmt.field);
            return *this;
        }

        // Floats

        This& operator<<(FmtPrecision prec)
            { fmt.num_flt.precision = prec; return *this; }

        This& operator<<(const FmtSetFloat& fmt_flt)
            { fmt.num_flt.merge(fmt_flt); return *this; }

        This& operator<<(float num)
            { out.writefmtnumf(num, fmt.num_flt, &fmt.field); return *this; }

        This& operator<<(double num)
            { out.writefmtnumf(num, fmt.num_flt, &fmt.field); return *this; }

        This& operator<<(ldouble num)
            { out.writefmtnumf(num, fmt.num_flt, &fmt.field); return *this; }

        template<class T>
        This& operator<<(const FloatT<T>& num) {
            if (num.null()) {
                if (fmt.null.size > 0)
                    out.writefmtstr(fmt.null.str, fmt.null.size, fmt.field);
            } else
                out.writefmtnumf(num.value(), fmt.num_flt, &fmt.field);
            return *this;
        }

        // Dump

        This& operator<<(const FmtDump& fmtdump)
            { out.writefmtdump(fmtdump, getnewline(), getnewlinesize()); return *this; }
    };

    // PREPEND

    String& prepend(char ch)
        { ListType::prepend(ch); return *this; }

    String& prepend(char ch, Size count) {
        ListType::advPrepend(count);
        if (count > 0)
            memset(data_, (int)(uchar)ch, count);
        return *this;
    }

    String& prepend(const ListType& str)
        { ListType::prepend(str); return *this; }

    String& prepend(const StringBase& str)
        { ListType::prepend(str); return *this; }

    String& prepend(const char* str, Size size)
        { ListType::prepend(str, size); return *this; }

    String& prepend(const char* str)
        { if (str) prepend(str, (Size)strlen(str)); return *this; }

    String& prependsep(char delim=',')
        { if (size_ > 0 && data_[0] != delim) prepend(delim); return *this; }

    String& prependn(int num, int base=fDEC)
        { prependnum(num, base); return *this; }

    String& prependn(long num, int base=fDEC)
        { prependnum(num, base); return *this; }

    String& prependn(longl num, int base=fDEC)
        { prependnum(num, base); return *this; }

    String& prependn(uint num, int base=fDEC)
        { prependnum(num, base); return *this; }

    String& prependn(ulong num, int base=fDEC)
        { prependnum(num, base); return *this; }

    String& prependn(ulongl num, int base=fDEC)
        { prependnum(num, base); return *this; }

    String& prependn(float num, int precision=fPREC_AUTO)
        { prependnumf(num, precision); return *this; }

    String& prependn(double num, int precision=fPREC_AUTO)
        { prependnumf(num, precision); return *this; }

    String& prependn(ldouble num, int precision=fPREC_AUTO)
        { prependnumf(num, precision); return *this; }

    // INSERT

    Size insert(Key index, char ch)
        { return ListType::insert(index, ch); }

    Size insert(Key index, char ch, Size count) {
        index = ListType::advInsert(index, count);
        if (count > 0)
            memset(data_ + index, (int)(uchar)ch, count);
        return index;
    }

    Size insert(Key index, const ListType& str)
        { return ListType::insert(index, str); }

    Size insert(Key index, const StringBase& str)
        { return ListType::insert(index, str); }

    Size insert(Key index, const char* str, Size size)
        { return ListType::insert(index, str, size); }

    String& insert(Key index, const char* str)
        { if (str) insert(index, str, (Size)strlen(str)); return *this; }

    String& insertn(Key index, int num, int base=fDEC)
        { insertnum(index, num, base); return *this; }

    String& insertn(Key index, long num, int base=fDEC)
        { insertnum(index, num, base); return *this; }

    String& insertn(Key index, longl num, int base=fDEC)
        { insertnum(index, num, base); return *this; }

    String& insertn(Key index, uint num, int base=fDEC)
        { insertnum(index, num, base); return *this; }

    String& insertn(Key index, ulong num, int base=fDEC)
        { insertnum(index, num, base); return *this; }

    String& insertn(Key index, ulongl num, int base=fDEC)
        { insertnum(index, num, base); return *this; }

    String& insertn(Key index, float num, int precision=fPREC_AUTO)
        { insertnumf(index, num, precision); return *this; }

    String& insertn(Key index, double num, int precision=fPREC_AUTO)
        { insertnumf(index, num, precision); return *this; }

    String& insertn(Key index, ldouble num, int precision=fPREC_AUTO)
        { insertnumf(index, num, precision); return *this; }

    // FILL

    String& fillch(char ch, Key index=0, Size size=ALL)
        { ListType::fill(ch, index, size); return *this; }

    // REPLACE

    String& replace(Key index, Size rsize, const StringBase& str)
        { ListType::replace(index, rsize, str.data_, str.size_); return *this; }

    String& replace(Key index, Size rsize, const char* str, Size size)
        { ListType::replace(index, rsize, str, size); return *this; }

    String& replace(Key index, Size rsize, const char* str)
        { ListType::replace(index, rsize, str, str?(Size)strlen(str):0); return *this; }

    Size findreplace(char ch, const char* str, Size size, Size max=ALL) {
        uint startmax = max;
        for (Size i = 0; max > 0; --max) {
            i = find(ch, i);
            if (i == NONE)
                break;
            ListType::replace(i, 1, str, size);
            i += size;
        }
        return startmax - max;
    }

    Size findreplace(char ch, const StringBase& str, Size max=ALL)
        { return findreplace(ch, str.data_, str.size_, max); }

    Size findreplace(const char* fstr, Size fsize, const char* str, Size size, Size max=ALL) {
        uint startmax = max;
        for (Size i = 0; max > 0; --max) {
            i = find(fstr, fsize, i);
            if (i == NONE)
                break;
            ListType::replace(i, fsize, str, size);
            i += size;
        }
        return startmax - max;
    }

    Size findreplace(const char* fstr, Size fsize, const StringBase& str, Size max=ALL)
        { return findreplace(fstr, fsize, str.data_, str.size_, max); }

    Size findreplace(const StringBase& fstr, const StringBase& str, Size max=ALL)
        { return findreplace(fstr.data_, fstr.size_, str.data_, str.size_, max); }

    Size findreplace(const StringBase& fstr, const char* str, Size size, Size max=ALL)
        { return findreplace(fstr.data_, fstr.size_, str, size, max); }

    // GETBOOL

    bool getbool(Error& error) const {
        assert( data_ > (char*)1 || size_ == 0 );
        return impl::tobool(data_, size_, error);
    }

    template<class T> T getbool() const {
        assert( data_ > (char*)1 || size_ == 0 );
        return StaticIf< IsPodType<T>::value, impl::ToBoolPod<T>, impl::ToBool<T> >::Type::getbool(data_, size_);
    }

    // GETNUM

    template<class T> T getnum(Error& error, int base=0) const {
        STATIC_ASSERT( IsPodType<T>::value, getnum_POD_Type_Required );
        assert( data_ > (char*)1 || size_ == 0 );
        return impl::tonum<T>(data_, size_, error, base);
    }

    template<class T> T getnum(int base=0) const {
        assert( data_ > (char*)1 || size_ == 0 );
        return StaticIf< IsPodType<T>::value, impl::ToNumPod<T>, impl::ToNum<T> >::Type::getnum(data_, size_, base);
    }

    template<class T> T getnumf(Error& error) const {
        STATIC_ASSERT( IsPodType<T>::value, getnumf_POD_Type_Required );
        assert( data_ > (char*)1 || size_ == 0 );
        return impl::tonumf<T>(data_, size_, error);
    }

    template<class T> T getnumf() const {
        assert( data_ > (char*)1 || size_ == 0 );
        return StaticIf< IsPodType<T>::value, impl::ToNumfPod<T>, impl::ToNumf<T> >::Type::getnum(data_, size_);
    }

    // BOOLVAL

    Bool boolval() const
        { return impl::ToBool<Bool>::getbool(data_, size_); }

    // NUM

    Int num(int base=0) const
        { return impl::ToNum<Int>::getnum(data_, size_, base); }

    Long numl(int base=0) const
        { return impl::ToNum<Long>::getnum(data_, size_, base); }

    LongL numll(int base=0) const
        { return impl::ToNum<LongL>::getnum(data_, size_, base); }

    // NUMU

    UInt numu(int base=0) const
        { return impl::ToNum<UInt>::getnum(data_, size_, base); }

    ULong numul(int base=0) const
        { return impl::ToNum<ULong>::getnum(data_, size_, base); }

    ULongL numull(int base=0) const
        { return impl::ToNum<ULongL>::getnum(data_, size_, base); }

    // NUMF

    Float numf() const
        { return impl::ToNumf<Float>::getnum(data_, size_); }

    FloatD numfd() const
        { return impl::ToNumf<FloatD>::getnum(data_, size_); }

    FloatL numfl() const
        { return impl::ToNumf<FloatL>::getnum(data_, size_); }

    // STREAM FORMATTING

    Out& write_out()
        { return *this; }

    Size writechar(char ch, Size count=1) {
        add(ch, count);
        return count;
    }

    Size writebin(const char* buf, Size size) {
        add(buf, size);
        return size;
    }

    Size writetext(const char* buf, Size size) {
        add(buf, size);
        return size;
    }

    Size writequoted(const char* buf, Size size, char delim, bool optional=false) {
        bool quote_optional = false;
        const StrQuoting::Type type = StrQuoting::get(quote_optional, buf, size, delim);
        switch (type) {
            case StrQuoting::tSINGLE:
                if (quote_optional && optional) {
                    add(buf, size);
                    return size;
                }
            case StrQuoting::tDOUBLE:
            case StrQuoting::tBACKTICK: {
                const char ch = "'\"`"[(uint)type];
                const Size result = size + 2;
                reserve(result);
                add(ch, 1);
                add(buf, size);
                add(ch, 1);
                return result;
            }
            case StrQuoting::tSINGLE3:
            case StrQuoting::tDOUBLE3:
            case StrQuoting::tBACKTICK3: {
                const char* str = &"'''\"\"\"```"[(uint(type) - 3) * 3];
                const Size result = size + 6;
                reserve(result);
                add(str, 3);
                add(buf, size);
                add(str, 3);
                return result;
            }
            case StrQuoting::tBACKTICK_DEL: {
                const char* str = "`\x7F";
                const Size result = size + 4;
                reserve(result);
                add(str, 2);
                add(buf, size);
                add(str, 2);
                return result;
            }
            case StrQuoting::tERROR:
                break;
        }
        return 0;
    }

    char* write_direct(Size size) {
        reserve(size);
        return buf_.ptr + used();
    }

    char* write_direct_multi(Size& available, Size reserve_size) {
        available = reserve_size;
        if (reserve_size == 0)
            return (char*)1; // finished
        reserve(reserve_size);
        return buf_.ptr + used();
    }

    char* write_direct_flush(Size& available, Size written_size, Size reserve_size) {
        advSize(used() + written_size);
        available = reserve_size;
        if (reserve_size == 0)
            return (char*)1; // finished
        reserve(reserve_size);
        return buf_.ptr + used();
    }

    bool write_direct_finish(Size size) {
        advSize(used() + size);
        return true;
    }

    template<class TNum>
    bool writenum(TNum num, int base=fDEC) {
        reserve(IntegerT<TNum>::maxlen(base)+1);
        const Size len = impl::fnum(data_+size_+IntegerT<TNum>::digits(num,base), num, base);
        buf_.header->used += len;
        size_             += len;
        return true;
    }

    template<class TNum>
    bool writenumu(TNum num, int base=fDEC) {
        reserve(IntegerT<TNum>::maxlen(base)+1);
        const Size len = impl::fnumu(data_+size_+IntegerT<TNum>::digits(num,base), num, base);
        buf_.header->used += len;
        size_             += len;
        return true;
    }

    template<class TNum>
    bool writenumf(TNum num, int precision=fPREC_AUTO) {
        Size len;
    #if defined(EVO_FNUMF_SPRINTF)
        char buf[impl::FNUMF_SPRINTF_BUF_SIZE];
        char* fmt;
        len = impl::fnumf_sprintf_setup(fmt, buf, num, precision);
        if (len > 0) {
            reserve(len + 1);
            ::sprintf(data_ + size_, fmt, num);
        }
    #else
        int exp = 0;
        if (precision < 0) {
            num = FloatT<TNum>::fexp10(exp, num);
            reserve(FloatT<TNum>::MAXDIGITS_AUTO + 1);
            len = impl::fnumfe(data_ + size_, num, exp, false);
        } else {
            num = FloatT<TNum>::fexp10(exp, impl::fnumf_weight(num, precision));
            reserve(FloatT<TNum>::maxdigits_prec(exp, precision) + 1);
            len = impl::fnumf(data_ + size_, num, exp, precision);
        }
    #endif
        buf_.header->used += len;
        size_             += len;
        return true;
    }

    bool writefmtchar(char ch, Size count, const FmtSetField& field) {
        const Size index = size_;
        if (field.width >= 0 && (Size)field.width > count) {
            const int fillchar = (int)(field.fill != 0 ? (uchar)field.fill : (uchar)' ');
            const uint padding = field.width - count;
            ListType::advAdd(count + padding);

            char* p = data_ + index;
            switch (field.align) {
                case faCURRENT: // fallthrough
                case fLEFT:
                    memset(p, (int)(uchar)ch, count);
                    if (padding > 0)
                        memset(p + count, fillchar, padding);
                    break;
                case fCENTER: {
                    const uint padleft = (padding / 2);
                    if (padleft > 0) {
                        memset(p, fillchar, padleft);
                        p += padleft;
                    }
                    memset(p, (int)(uchar)ch, count);
                    const uint padright = (padding - padleft);
                    if (padright > 0) {
                        p += count;
                        memset(p, fillchar, padright);
                    }
                    break;
                }
                case fRIGHT:
                    if (padding > 0) {
                        memset(p, fillchar, padding);
                        p += padding;
                    }
                    memset(p, (int)(uchar)ch, count);
                    break;
            };
        } else if (count > 0) {
            ListType::advAdd(count);
            memset(data_ + index, (int)(uchar)ch, count);
        }
        return true;
    }

    bool writefmtstr(const char* str, Size size, const FmtSetField& field) {
        const Size index = size_;
        if (field.width >= 0 && (Size)field.width > size) {
            const int fillchar = (int)(field.fill != 0 ? (uchar)field.fill : (uchar)' ');
            const uint padding = field.width - size;
            ListType::advAdd(size + padding);

            char* p = data_ + index;
            switch (field.align) {
                case faCURRENT: // fallthrough
                case fLEFT:
                    memcpy(p, str, size);
                    if (padding > 0)
                        memset(p + size, fillchar, padding);
                    break;
                case fCENTER: {
                    const uint padleft = (padding / 2);
                    if (padleft > 0) {
                        memset(p, fillchar, padleft);
                        p += padleft;
                    }
                    memcpy(p, str, size);
                    const uint padright = (padding - padleft);
                    if (padright > 0) {
                        p += size;
                        memset(p, fillchar, padright);
                    }
                    break;
                }
                case fRIGHT:
                    if (padding > 0) {
                        memset(p, fillchar, padding);
                        p += padding;
                    }
                    memcpy(p, str, size);
                    break;
            };
        } else if (size > 0) {
            ListType::advAdd(size);
            memcpy(data_ + index, str, size);
        }
        return true;
    }

    template<class TNum>
    bool writefmtnum(TNum num, const FmtSetInt& fmt, const FmtSetField* field=NULL) {
        if (fmt.base <= 0 || fmt.base == fDEC) {
            const Size index        = size_;
            const int digits        = IntegerT<TNum>::digits(num, fDEC);
            const int width         = (fmt.pad_width > digits ? fmt.pad_width : digits);
            const int align_padding = (field != NULL && field->width > width ? field->width - width : 0);
            ListType::advAdd(width + align_padding);
            fmt.impl_num_write(data_ + index, num, digits, width, align_padding, field);
        } else
            writefmtnumu((typename ToUnsigned<TNum>::Type)num, fmt, field);
        return true;
    }

    template<class TNum>
    bool writefmtnumu(TNum num, const FmtSetInt& fmt, const FmtSetField* field=NULL) {
        const int base = (fmt.base > 0 ? fmt.base : fDEC);

        char prefix_ch  = 0;
        uint prefix_len = 0;
        fmt.impl_prefix_info(prefix_ch, prefix_len);

        const int digits        = IntegerT<TNum>::digits(num, base);
        const int width         = (fmt.pad_width > digits ? fmt.pad_width : digits);
        const int full_width    = width + prefix_len;
        const int align_padding = (field != NULL && field->width > full_width ? field->width - full_width : 0);

        const Size index = size_;
        ListType::advAdd(full_width + align_padding);
        char* p = data_ + index;

        int align_padleft, align_padright;
        FmtSetField::setup_align(align_padleft, align_padright, align_padding, field);

        if (align_padleft > 0) {
            memset(p, (int)(uchar)field->fill, align_padleft);
            p += align_padleft;
        }

        FmtSetInt::impl_prefix_write(p, prefix_ch, prefix_len);

        if (digits < width) {
            const uint padlen = width - digits;
            const int ch = (fmt.pad_ch == 0 ? '0' : (int)(uchar)fmt.pad_ch);
            memset(p, ch, padlen);
            p += padlen;
        }
        p += digits;
        impl::fnumu(p, num, base);

        if (align_padright > 0)
            memset(p, (int)(uchar)field->fill, align_padright);
        return true;
    }

    template<class TNum>
    bool writefmtnumf(TNum num, const FmtSetFloat& fmt, const FmtSetField* field=NULL) {
        const int align_width = (field != NULL ? field->width : 0);
        int exp = 0, maxlen;
        fmt.impl_info(num, exp, maxlen, align_width);   // sets maxlen
        reserve(maxlen);

        const ulong len = fmt.impl_write(data_ + size_, num, exp, align_width, field);
        buf_.header->used += len;
        size_             += len;
        return true;
    }

    bool writefmtdump(const FmtDump& fmt, const char* newline, uint newlinesize) {
        assert( newlinesize <= 2 );
        if (fmt.size > 0) {
            const char* DIGITS     = (fmt.upper ? "0123456789ABCDEF" : "0123456789abcdef");
            const ulong LINE_SIZE  = (fmt.maxline > 0 ? fmt.maxline : fmt.size);

            const uchar* ptr     = (uchar*)fmt.buf;
            const uchar* ptr_end = ptr + fmt.size;
            const uchar* ptr_nl;

            FmtSetInt offset_fmt(fHEX, 0);
            ulong offset = 0;
            if (fmt.maxline > 0 && !fmt.compact) {
                offset_fmt.pad_width = Int::digits(fmt.size, fHEX);
                const ulong lines = (fmt.size / fmt.maxline) + 1;
                reserve( ((offset_fmt.pad_width + 4 + (fmt.maxline * 4) + newlinesize) * lines) + 1 );
            } else
                reserve( (fmt.size * 4) + newlinesize + 1 );

            // Loop for each line
            int padding;
            for (const uchar* ptr2; ptr < ptr_end; ) {
                // Show offset
                if (fmt.maxline > 0 && !fmt.compact) {
                    padding = offset_fmt.pad_width - IntegerT<ulong>::digits(offset, fHEX);
                    if (padding > 0)
                        memset(data_ + size_, '0', padding);
                    size_ += offset_fmt.pad_width;
                    impl::fnumu(data_ + size_, offset, fHEX);

                    offset += fmt.maxline;
                    data_[size_++] = ':';
                    data_[size_++] = ' ';
                    data_[size_++] = ' ';
                }

                // Figure newline position
                ptr_nl = ptr + LINE_SIZE;
                if (ptr_nl > ptr_end)
                    ptr_nl = ptr_end;

                // Hex dump line
                ptr2 = ptr;
                for (; ptr < ptr_nl; ++ptr) {
                    data_[size_++] = DIGITS[(*ptr >> 4) & 0x0F];
                    data_[size_++] = DIGITS[*ptr & 0x0F];
                    data_[size_++] = ' ';
                }

                if (fmt.compact) {
                    assert( size_ > 0 );
                    --size_; // trim extra space from last byte
                } else {
                    if (ptr_nl >= ptr_end && fmt.maxline > 0 && ptr2 != (uchar*)fmt.buf) {
                        // Pad last line, add separator
                        const ulong remainder = fmt.size % fmt.maxline;
                        const ulong count = (remainder > 0 ? ((fmt.maxline - remainder) * 3) + 1 : 1);
                        if (count > 0) {
                            memset(data_ + size_, ' ', count);
                            size_ += count;
                        }
                    } else
                        // Separator
                        data_[size_++] = ' ';

                    // ASCII dump line
                    for (; ptr2 < ptr_nl; ++ptr2) {
                        if (*ptr2 < ' ' || *ptr2 > '~')
                            data_[size_++] = '.';
                        else
                            data_[size_++] = (char)*ptr2;
                    }
                }

                // Newline
                memcpy(data_ + size_, newline, newlinesize);
                size_ += newlinesize;
            }
            buf_.header->used = size_;
            assert( buf_.header->used <= buf_.header->size );
        }
        return true;
    }

    bool writefmtdump(const FmtDump& fmt, Newline nl=NL_SYS) {
        writefmtdump(fmt, getnewline(nl), getnewlinesize(nl));
        return true;
    }

    // CONVERT

    template<class C> C convert() const
        // An "undefined reference" compiler error pointing here means the given conversion isn't implemented/supported
        { return Convert<String,C>::value(*this); }

    template<class C> String& convert_set(C value)
        // An "undefined reference" compiler error pointing here means the given conversion isn't implemented/supported
        { Convert<String,C>::set(*this, value); return *this; }

    template<class C> String& convert_add(C value)
        // An "undefined reference" compiler error pointing here means the given conversion isn't implemented/supported
        { Convert<String,C>::add(*this, value); return *this; }

    template<class C> bool convert_addq(C value, char delim=',')
        // An "undefined reference" compiler error pointing here means the given conversion isn't implemented/supported
        { return Convert<String,C>::addq(*this, value, delim); }

    template<class C> String& join(const C& items, char delim=',') {
        typename C::Iter iter(items);
        for (typename C::Size i=0; iter; ++iter, ++i) {
            if (i > 0)
                add(delim);
            Convert<String,typename C::Item>::add(*this, *iter);
        }
        return *this;
    }

    template<class C> String& joinq(const C& items, char delim=',') {
        typename C::Iter iter(items);
        for (typename C::Size i=0; iter; ++iter, ++i) {
            if (i > 0)
                add(delim);
            Convert<String,typename C::Item>::addq(*this, *iter, delim);
        }
        return *this;
    }

    template<class C> String& joinmap(const C& map, char delim=',', char kvdelim='=') {
        typename C::Iter iter(map);
        for (typename C::Size i=0; iter; ++iter, ++i) {
            if (i > 0)
                add(delim);
            Convert<String,typename C::Key>::add(*this, iter->first);
            add(kvdelim);
            Convert<String,typename C::Value>::add(*this, iter->second);
        }
        return *this;
    }

    template<class C> String& joinmapq(const C& map, char delim=',', char kvdelim='=') {
        typename C::Iter iter(map);
        for (typename C::Size i=0; iter; ++iter, ++i) {
            if (i > 0)
                add(delim);
            Convert<String,typename C::Key>::addq(*this, iter->first, kvdelim);
            add(kvdelim);
            Convert<String,typename C::Value>::addq(*this, iter->second, delim);
        }
        return *this;
    }

    template<class Tok,class C> typename C::Size split(C& items, char delim=',') const {
        typename C::Size count = 0;
        Tok tok(*this);
        for (; tok.next(delim); ++count)
            items.add(tok.value().template convert<typename C::Item>());
        return count;
    }

    template<class C> typename C::Size splitmap(C& map, char delim=',', char kvdelim='=') const
        { return map.addsplit(*this, delim, kvdelim); }

    // CASE

    ThisType& toupper() {
        bool found = false;
        Size index = 0;
        for (; index < size_; ++index) {
            if (ascii_type(data_[index]) == ctLOWER) {
                found = true;
                break;
            }
        }
        if (found) {
            unshare();
            for (; index < size_; ++index)
                data_[index] = ascii_toupper(data_[index]);
        }
        return *this;
    }

    ThisType& tolower() {
        bool found = false;
        Size index = 0;
        for (; index < size_; ++index) {
            if (ascii_type(data_[index]) == ctUPPER) {
                found = true;
                break;
            }
        }
        if (found) {
            unshare();
            for (; index < size_; ++index)
                data_[index] = ascii_tolower(data_[index]);
        }
        return *this;
    }

    // OVERRIDES

    String& clear()
        { ListType::clear(); return *this; }

    String& triml(Size size)
        { ListType::triml(size); return *this; }

    String& trimr(Size size)
        { ListType::trimr(size); return *this; }

    String& truncate(Size size=0)
        { ListType::truncate(size); return *this; }

    String& slice(Key index)
        { ListType::slice(index); return *this; }

    String& slice(Key index, Size size)
        { ListType::slice(index, size); return *this; }

    String& slice2(Key index1, Key index2)
        { ListType::slice2(index1, index2); return *this; }

    String& unslice()
        { ListType::unslice(); return *this; }

    Size capacity() const
        { return ListType::capacity(); }

    String& capacity(Size size)
        { ListType::capacity(size); return *this; }

    String& capacitymin(Size min)
        { ListType::capacitymin(min); return *this; }

    String& capacitymax(Size max)
        { ListType::capacitymax(max); return *this; }

    String& compact()
        { ListType::compact(); return *this; }

    String& reserve(Size size, bool prefer_realloc=false)
        { ListType::reserve(size, prefer_realloc); return *this; }

    String& unshare()
        { ListType::unshare(); return *this; }

    String& resize(Size size)
        { ListType::resize(size); return *this; }

    String& reverse()
        { ListType::reverse(); return *this; }

    String& advResize(Size size)
        { ListType::advResize(size); return *this; }

    // STATIC

    static const String& digits()
        { static const String str("0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"); return str; }

    static const String& digitsl()
        { static const String str("0123456789abcdefghijklmnopqrstuvwxyz"); return str; }

    static const String& letters()
        { static const String str("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"); return str; }

    static const String& lettersu()
        { static const String str("ABCDEFGHIJKLMNOPQRSTUVWXYZ"); return str; }

    static const String& lettersl()
        { static const String str("abcdefghijklmnopqrstuvwxyz"); return str; }

    static const String& whitespace()
        { static const String str(" \t"); return str; }

private:
    // Hide unused parent members
    ListType& fill(const char& item, Key index=0, Size size=ALL);
    String& addnew(Size);
    String& prependnew(Size);
    Size insertnew(Key, Size);
    void advAdd(Size);
    void advPrepend(Size);
    void advInsert(Key, Size);
    void advRemove(Key, Size);

    // Doxygen: Hide unused overidden parent members from documentation
#if defined(DOXYGEN)
    bool contains(ItemVal) const;
    bool starts(ItemVal) const;
    bool ends(ItemVal) const;
    ListType& operator<<(const char&);
    ListType& add(const char&);
    ListType& prepend(const char&);
    Size insert(Key,const char&);

    Size used() const;
    #if EVO_LIST_OPT_REFTERM
    bool terminated() const;
    #endif
    Size refs() const;
    const char* buffer() const;
    void iterInitMutable();
    const char* iterFirst(IterKey& key) const;
    const char* iterNext(IterKey& key) const;
    const char* iterNext(Size count,IterKey& key) const;
    const char* iterLast(IterKey& key) const;
    const char* iterPrev(IterKey& key) const;
    const char* iterPrev(Size count,IterKey& key) const;
    Size iterCount() const;
    const char* iterSet(IterKey key) const;
#endif

    // Set number
    template<class T>
    void setnum(T num, int base=fDEC) {
        clear().capacitymin(IntegerT<T>::maxlen(base)+1).unshare();
        const Size len = impl::fnum(data_+IntegerT<T>::digits(num,base), num, base);
        buf_.header->used += len;
        size_             += len;
    }
    template<class T>
    void setnumu(T num, int base=fDEC) {
        clear().capacitymin(IntegerT<T>::maxlen(base)+1).unshare();
        const Size len = impl::fnumu(data_+IntegerT<T>::digits(num,base), num, base);
        buf_.header->used += len;
        size_             += len;
    }
    template<class T>
    void setnumf(T num, int precision=fPREC_AUTO) {
        Size len;
    #if defined(EVO_FNUMF_SPRINTF)
        char buf[impl::FNUMF_SPRINTF_BUF_SIZE];
        char* fmt;
        len = impl::fnumf_sprintf_setup(fmt, buf, num, precision);
        if (len > 0) {
            clear().capacitymin(len + 1).unshare();
            ::sprintf(data_, fmt, num);
        }
    #else
        int exp = 0;
        if (precision < 0) {
            num = FloatT<T>::fexp10(exp, num);
            clear().capacitymin(FloatT<T>::MAXDIGITS_AUTO).unshare();
            len = impl::fnumfe(data_, num, exp, false);
        } else {
            num = FloatT<T>::fexp10(exp, impl::fnumf_weight(num, precision));
            clear().capacitymin(FloatT<T>::maxdigits_prec(exp, precision)).unshare();
            len = impl::fnumf(data_, num, exp, precision);
        }
    #endif
        buf_.header->used += len;
        size_             += len;
    }

    // Prepend number
    template<class T>
    void prependnum(T num, int base=fDEC) {
        StringInt<T> str(num, base, false);
        prepend(str.data(), str.size());
    }
    template<class T>
    void prependnumf(T num, int precision=fPREC_AUTO) {
        StringFlt<T> str(num, precision, false);
        prepend(str.data(), str.size());
    }

    // Insert number
    template<class T>
    void insertnum(Key index, T num, int base=fDEC) {
        StringInt<T> str(num, base, false);
        insert(index, str.data(), str.size());
    }
    template<class T>
    void insertnumf(Key index, T num, int precision=fPREC_AUTO) {
        StringFlt<T> str(num, precision, false);
        insert(index, str.data(), str.size());
    }
};

// String comparison
inline bool operator==(const char* str1, const String& str2)
    { return str2 == str1; }
inline bool operator!=(const char* str1, const String& str2)
    { return str2 != str1; }
// String conversion
// Common base types for string conversion -- used internally
template<class T> struct Convert_StringToIntBase {
    template<class V> static void set(String& dest, V value)
        { dest.setn(value); }
    template<class V> static void add(String& dest, V value)
        { dest.addn(value); }
    template<class V> static bool addq(String& dest, V value, char)
        { dest.addn(value); return true; }
    static T value(const String& src)
        { return src.getnum<T>(); }
};
template<class T> struct Convert_StringToFltBase {
    template<class V> static void set(String& dest, V value)
        { dest.setn(value); }
    template<class V> static void add(String& dest, V value)
        { dest.addn(value); }
    template<class V> static bool addq(String& dest, V value, char)
        { dest.addn(value); return true; }
    static T value(const String& src)
        { return src.getnumf<T>(); }
};
template<class T> struct Convert_StringToCIntBase {
    template<class V> static void set(String& dest, const V& value)
        { if (value.valid()) dest.setn(*value); }
    template<class V> static void add(String& dest, const V& value)
        { if (value.valid()) dest.addn(*value); }
    template<class V> static bool addq(String& dest, const V& value, char)
        { if (value.valid()) dest.addn(*value); return true; }
    static T value(const String& src)
        { return src.getnum<T>(); }
};
template<class T> struct Convert_StringToCFltBase {
    template<class V> static void set(String& dest, const V& value)
        { if (value.valid()) dest.setn(*value); }
    template<class V> static void add(String& dest, const V& value)
        { if (value.valid()) dest.addn(*value); }
    template<class V> static bool addq(String& dest, const V& value, char)
        { if (value.valid()) dest.addn(*value); return true; }
    static T value(const String& src)
        { return src.getnumf<T>(); }
};
// Conversion templates
template<> struct Convert<const char*,String> {
    static void set(String& dest, const char* value)
        { dest.set(value); }
    static void add(String& dest, const char* value)
        { dest.add(value); }
    static String value(const char* src)
        { return src; }
};
template<> struct Convert<char*,String> {
    static void set(String& dest, const char* value)
        { dest.set(value); }
    static void add(String& dest, const char* value)
        { dest.add(value); }
    static String value(const char* src)
        { return src; }
};
template<> struct Convert<String,String> {
    static void set(String& dest, const String& value)
        { dest.set(value); }
    static void add(String& dest, const String& value)
        { dest.add(value); }
    static bool addq(String& dest, const String& value, char delim)
        { return (value.size() == 0 || dest.writequoted(value.data(), value.size(), delim, true) > 0); }
    static const String& value(const String& src)
        { return src; }
};
template<> struct Convert<String,const char*> {
    static void set(String& dest, const char* value)
        { dest.set(value); }
    static void add(String& dest, const char* value)
        { dest.add(value); }
    static bool addq(String& dest, const char* value, char delim) {
        const StrSizeT len = (StrSizeT)strlen(value);
        return (len == 0 || dest.writequoted(value, (StrSizeT)strlen(value), delim, true) > 0);
    }
    // Unsafe: Converting String to const char*
    //template<class U> static const char* value(U&)
};
template<> struct Convert<String,char*> {
    static void set(String& dest, const char* value)
        { dest.set(value); }
    static void add(String& dest, const char* value)
        { dest.add(value); }
    static bool addq(String& dest, const char* value, char delim) {
        const StrSizeT len = (StrSizeT)strlen(value);
        return (len == 0 || dest.writequoted(value, (StrSizeT)strlen(value), delim, true) > 0);
    }
    // Unsafe: Converting String to char*
    //template<class U> static const char* value(U&)
};
template<> struct Convert<String,bool> {
    static void set(String& dest, bool value) {
        if (value) dest.set("true", 4);
        else       dest.set("false", 5);
    }
    static void add(String& dest, bool value) {
        if (value) dest.add("true", 4);
        else       dest.add("false", 5);
    }
    static bool addq(String& dest, bool value, char) {
        if (value) dest.add("true", 4);
        else       dest.add("false", 5);
        return true;
    }
    static bool value(const String& src)
        { return src.getbool<bool>(); }
};
template<> struct Convert<String,short>   : public Convert_StringToIntBase<short>   { };
template<> struct Convert<String,int>     : public Convert_StringToIntBase<int>     { };
template<> struct Convert<String,long>    : public Convert_StringToIntBase<long>    { };
template<> struct Convert<String,longl>   : public Convert_StringToIntBase<longl>   { };
template<> struct Convert<String,ushort>  : public Convert_StringToIntBase<ushort>  { };
template<> struct Convert<String,uint>    : public Convert_StringToIntBase<uint>    { };
template<> struct Convert<String,ulong>   : public Convert_StringToIntBase<ulong>   { };
template<> struct Convert<String,ulongl>  : public Convert_StringToIntBase<ulongl>  { };
template<> struct Convert<String,float>   : public Convert_StringToFltBase<float>   { };
template<> struct Convert<String,double>  : public Convert_StringToFltBase<double>  { };
template<> struct Convert<String,ldouble> : public Convert_StringToFltBase<ldouble> { };
template<> struct Convert<String,Bool> {
    static void set(String& dest, Bool value) {
        if (value.null()) dest.set();
        else if (*value)  dest.set("true", 4);
        else              dest.set("false", 5);
    }
    static void add(String& dest, Bool value) {
        if (value.valid()) {
            if (*value) dest.add("true", 4);
            else        dest.add("false", 5);
        }
    }
    static bool addq(String& dest, Bool value, char) {
        if (value.valid()) {
            if (*value) dest.add("true", 4);
            else        dest.add("false", 5);
        }
        return true;
    }
    static Bool value(const String& src)
        { return src.getbool<Bool>(); }
};
template<> struct Convert<String,Short>  : public Convert_StringToCIntBase<Short>   { };
template<> struct Convert<String,Int>    : public Convert_StringToCIntBase<Int>     { };
template<> struct Convert<String,Long>   : public Convert_StringToCIntBase<Long>    { };
template<> struct Convert<String,LongL>  : public Convert_StringToCIntBase<LongL>   { };
template<> struct Convert<String,UShort> : public Convert_StringToCIntBase<UShort>  { };
template<> struct Convert<String,UInt>   : public Convert_StringToCIntBase<UInt>    { };
template<> struct Convert<String,ULong>  : public Convert_StringToCIntBase<ULong>   { };
template<> struct Convert<String,ULongL> : public Convert_StringToCIntBase<ULongL>  { };
template<> struct Convert<String,Float>  : public Convert_StringToCFltBase<Float>   { };
template<> struct Convert<String,FloatD> : public Convert_StringToCFltBase<FloatD>  { };
template<> struct Convert<String,FloatL> : public Convert_StringToCFltBase<FloatL>  { };

typedef String::ListBaseType StringBase;


}
#endif