substring.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_substring_h
#define INCL_evo_substring_h

#include "sublist.h"
#include "string.h"
#include "strscan.h"

namespace evo {


class ExceptionSubStringMapList : public Exception
    { EVO_CREATE_EXCEPTION_IMPL(ExceptionSubStringMapList, Exception) };


struct SubString : public SubList<char,StrSizeT> {
    typedef SubString ThisType;             
    typedef ListBaseType StringBase;        

    SubString()
        { }

    SubString(const ThisType& str) : SubList<char,StrSizeT>(str)
        { }

    SubString(const StringBase& str) : SubList<char,StrSizeT>(str)
        { }

    SubString(const StringBase& str, Key index, Size size=ALL) : SubList<char,StrSizeT>(str, index, size)
        { }

    SubString(const StringBase* str) {
        if (str != NULL)
            set(*str);
    }

    SubString(const char* data, Size size) : SubList<char,StrSizeT>(data, size)
        { }

    SubString(const char* data) : SubList<char,StrSizeT>(data, data?(Size)strlen(data):0)
        { }

#if defined(EVO_CPP11)

    SubString(SubString&& src) {
        ::memcpy(this, &src, sizeof(SubString));
    }

    SubString& operator=(SubString&& src) {
        ::memcpy(this, &src, sizeof(SubString));
        return *this;
    }
#endif

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

    // SET

    SubString& operator=(const SubString& src)
        { set(src); return *this; }

    SubString& operator=(const StringBase& data)
        { set(data); return *this; }

    SubString& operator=(const StringBase* data)
        { if (data != NULL) set(*data); else set(); return *this; }

    SubString& operator=(const char* data) {
        data_ = (char*)data;
        size_ = data ? (Size)strlen(data) : 0;
        return *this;
    }

    using SubListType::set;

    SubString& set(const char* data) {
        data_ = (char*)data;
        size_ = data ? (Size)strlen(data) : 0;
        return *this;
    }

    SubString& operator=(const ValNull& val) {
        EVO_PARAM_UNUSED(val);
        set(); return *this;
    }

    SubString& operator=(const ValEmpty& val) {
        EVO_PARAM_UNUSED(val);
        setempty(); return *this;
    }

    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* cstr(String& buffer) const
        { return (size_ > 0 ? buffer.set(data_, size_).cstr() : ""); }

    // COMPARE

    using SubListType::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 SubListType::operator==;
    using SubListType::operator!=;

    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 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 char* str) const {
        return (utf8_compare(data_, size_, str) != 0);
    }

    using SubListType::starts;

    bool starts(const char* str) const {
        if (str == NULL)
            return false;
        const SizeT size = (Size)strlen(str);
        return (size > 0 && size_ >= size && DataEqual<Item>::equal(data_, str, size));
    }

    using SubListType::ends;

    bool ends(const char* str) const {
        if (str == NULL)
            return false;
        const SizeT size = (Size)strlen(str);
        return (size > 0 && size_ >= size && DataEqual<Item>::equal(data_+size_-size, str, size));
    }

    // FIND

    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, 0, i);
                right.set(*this, 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, 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, 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, 0, i);
                right.set(*this, 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, 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, i+1, ALL);
                return true;
            }
        }
        right.set();
        return false;
    }

    // TRIM/STRIP

    SubString& 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;
        if (count > 0) {
            size_ -= count;
            data_ += count;
        }
        return *this;
    }

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

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

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

    SubString& 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;
    }

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

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

    SubString& 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;
    }

    SubString& 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;
    }

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

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

    SubString& 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;
    }

    SubString& 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;
        }
        if (count > 0) {
            size_ -= count;
            data_ += count;
        }
        return *this;
    }

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

    SubString& 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;
    }

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

    // OVERRIDES

    SubString& clear()
        { SubListType::clear(); return *this; }

    SubString& set()
        { SubListType::set(); return *this; }

    SubString& set(const StringBase& data)
        { SubListType::set(data); return *this; }

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

    SubString& set(const StringBase* data)
        { SubListType::set(data); return *this; }

    SubString& set(const char* data, Size size)
        { SubListType::set(data, size); return *this; }

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

    SubString& setempty()
        { SubListType::setempty(); return *this; }

    SubString& triml(Size size)
        { SubListType::triml(size); return *this; }

    SubString& trimr(Size size)
        { SubListType::trimr(size); return *this; }

    SubString& truncate(Size size)
        { SubListType::truncate(size); return *this; }

    SubString& slice(Key index)
        { SubListType::slice(index); return *this; }

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

    SubString& slice2(Key index1, Key index2)
        { SubListType::slice2(index1, index2); return *this; }

    SubString& unshare()
        { return *this; }

    // 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_); }

    // CONVERT

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

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

    // Doxygen: Inherited methods
#ifdef DOXYGEN

    const char* data() const;

    const char& operator[](Key index) const;

    const char& item(Key index) const;

    bool operator==(const StringBase& data) const;

    bool operator!=(const StringBase& data) const;

    bool null() const;

    bool empty() const;

    Size size() const;

    bool shared() const;

    const char* first() const;

    const char* last() const;

    Key iend(Size offset) const;

    ulong hash(ulong seed) const;

    int compare(const StringBase& data) const;

    Key find(ItemVal item,Key start,Key end) const;

    Key findr(ItemVal item,Key start,Key end) const;
    
    Key findany(const char* items,Size count,Key start,Key end) const;
    
    Key findanyr(const char* items,Size count,Key start,Key end) const;

    template<class T1,class T2> bool splitat(Key index,T1& left,T2& right) const;

    template<class T1> bool splitat(Key index,T1& left) const;

    template<class T2> bool splitat(Key index,ValNull left,T2& right) const;

    bool splitat_setl(Key index);

    template<class T2> bool splitat_setl(Key index,T2& right);

    bool splitat_setr(Key index);

    template<class T1> bool splitat_setr(Key index,T1& left);

    void swap(StringBase& list);
#endif

private:
    // Doxygen: Hide unused overridden parent members from documentation
    #ifdef DOXYGEN
    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
};

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


class SubStringMapList {
public:
    SubStringMapList() : data_(NULL), size_(0) {
    }

    SubStringMapList(const SubString* data, SizeT size, bool verify_order=false) : data_((SubString*)data), size_(size) {
        if (verify_order && !verify())
            EVO_THROW(ExceptionSubStringMapList, "SubStringMapList verify order failed -- the constructor requires ordered input");
    }

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

    SizeT size() const {
        return size_;
    }

    bool empty() const {
        return (size_ == 0);
    }

    bool null() const {
        return (data_ == NULL);
    }

    SizeT find(const SubString& key) const {
        int cmp;
        SizeT left = 0, right = size_, mid = 0;
        while (left < right) {
            mid = left + ((right-left) / 2);
            cmp = key.compare(data_[mid]);
            if (cmp < 0)
                right = mid;
            else if (cmp == 0)
                return mid;
            else
                left = mid + 1;
        }
        return NONE;
    }

    template<class T>
    T find_enum(const SubString& key, T first_enum, T last_enum, T unknown) const {
        assert( (SizeT)last_enum >= (SizeT)first_enum );
        assert( (SizeT)last_enum - (SizeT)first_enum + 1 == size_ );
        SizeT i = find(key);
        if (i == NONE || (i += (SizeT)first_enum) > (SizeT)last_enum)
            return unknown;
        return (T)i;
    }

    template<class T>
    T find_enum_remap(const T* remap_array, const SubString& key, T first_enum, T last_enum, T unknown) const {
        SizeT i = find(key);
        if (i == NONE || (SizeT)last_enum < (SizeT)first_enum || i >= ((SizeT)last_enum - (SizeT)first_enum + 1))
            return unknown;
        return (T)remap_array[i];
    }

    template<class T>
    SubString get_enum_string(T enum_value, T first_enum, T last_enum) const {
        SizeT i;
        if ((SizeT)enum_value < (SizeT)first_enum || (SizeT)enum_value > (SizeT)last_enum || (i = (SizeT)enum_value - (SizeT)first_enum) >= size_)
            return SubString();
        return data_[i];
    }

    template<class T>
    SubString get_enum_string_remap(const SizeT* reverse_remap_array, T enum_value, T first_enum, T last_enum) const {
        SizeT i;
        if ((SizeT)enum_value < (SizeT)first_enum || (SizeT)enum_value > (SizeT)last_enum || (i = (SizeT)enum_value - (SizeT)first_enum) >= size_)
            return SubString();
        return data_[reverse_remap_array[i]];
    }

#if defined(EVO_CPP11)

    template<class T>
    T find_enum_class(const SubString& key) const {
        return find_enum<T>(key, (T)((SizeT)T::UNKNOWN + 1), (T)((SizeT)T::ENUM_END - 1), T::UNKNOWN);
    }

    template<class T>
    SubString get_enum_class_string(T enum_value) const {
        return get_enum_string(enum_value, (T)((SizeT)T::UNKNOWN + 1), (T)((SizeT)T::ENUM_END - 1));
    }
#endif

    bool verify() const {
        for (SizeT i = 1; i < size_; ++i)
            if (data_[i-1].compare(data_[i]) >= 0)
                return false;
        return true;
    }

    template<class T>
    struct ReverseRemap {
        typedef typename T::Type EnumType;      

        static const int SIZE = (int)T::LAST - (int)T::FIRST + 1;   

        SizeT array[SIZE];  

        EVO_ONCPP14_FULL(constexpr) ReverseRemap(const EnumType* remap_array) EVO_ONCPP14_FULL(: array()) {
            for (SizeT i = 0; i < (uint)SIZE; ++i)
                array[(int)remap_array[i] - (int)T::FIRST] = i;
        }
    };

private:
    SubString* data_;
    SizeT size_;
};


}
#endif