ustring.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_ustring_h
#define INCL_evo_ustring_h

#include "string.h"

namespace evo {


class UnicodeString : public List<wchar16,StrSizeT> {
public:
    typedef UnicodeString          ThisType;        
    typedef List<wchar16,StrSizeT> ListType;        
    typedef StrSizeT               Size;            

    UnicodeString()
        { }

    UnicodeString(const UnicodeString& str) : List<wchar16,Size>(str)
        { }

    UnicodeString(const wchar16* str, Size size)
        { set(str, size); }

    UnicodeString(const wchar16* str)
        { set(str); }

    UnicodeString(const StringBase& str)
        { set(str); }

    UnicodeString(const char* str, Size size)
        { set(str, size); }

    UnicodeString(const char* str)
        { set(str); }

    UnicodeString(const PtrBase<wchar16>& str) {
        if (str.ptr_ != NULL) {
            const ulong len = utf16_strlen(str.ptr_);
            assert( len < IntegerT<Size>::MAX );
            copy(str.ptr_, (Size)len);
        }
    }

#if defined(EVO_CPP11)

    UnicodeString(UnicodeString&& src) : List(std::move(src)) {
    }

    UnicodeString(const char16_t* str, Size size) {
        assert( sizeof(char16_t) == sizeof(wchar16) );
        set((const wchar16*)str, size);
    }

    UnicodeString(const char16_t* str) {
        assert( sizeof(char16_t) == sizeof(wchar16) );
        set((const wchar16*)str);
    }

    UnicodeString& operator=(UnicodeString&& src) {
        List::operator=(std::move(src));
        return *this;
    }

    UnicodeString& operator=(const char16_t* str) {
        assert( sizeof(char16_t) == sizeof(wchar16) );
        set((const wchar16*)str);
        return *this;
    }
#endif

    // SET

    UnicodeString& operator=(const UnicodeString& str)
        { return set(str); }

    UnicodeString& operator=(const ListBaseType& str)
        { return set(str); }

    UnicodeString& operator=(const wchar16* str)
        { return set(str); }

    UnicodeString& operator=(const StringBase& str)
        { return set(str); }

    UnicodeString& operator=(const char* str)
        { return set(str); }

    UnicodeString& operator=(const PtrBase<wchar16>& str)
        { return set(str); }

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

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

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

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

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

    UnicodeString& set(const wchar16* str) {
        if (str == NULL)
            ListType::set();
        else
            set(str, utf16_strlen(str));
        return *this;
    }

    UnicodeString& set(const StringBase& str) {
        set(str.data_, str.size_);
        return *this;
    }

    UnicodeString& set(const char* str, Size size, UtfMode mode=umREPLACE_INVALID) {
        if (str == NULL) {
            set();
        } else {
            setempty();
            if (size > 0) {
                const char* p = str;
                const char* end = p + size;
                ulong newsize = utf8_to16(p, end, NULL, 0, mode);
                if (newsize > 0) {
                    wchar16* buf = advBuffer(++newsize);
                    const ulong written = utf8_to16(str, end, buf, newsize, mode);
                    if (written > 0)
                        advSize(written);
                }
            }
        }
        return *this;
    }

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

    UnicodeString& set(const PtrBase<wchar16>& str) {
        if (str.ptr_ == NULL) {
            set();
        } else {
            const ulong len = utf16_strlen(str.ptr_);
            assert( len < IntegerT<Size>::MAX );
            copy(str.ptr_, (Size)len);
        }
        return *this;
    }

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

    UnicodeString& operator=(const WCHAR* str)
        { return set((const wchar16*)str); }

    UnicodeString& set(const WCHAR* str, Size size)
        { return set((const wchar16*)str, size); }

    UnicodeString& set(const WCHAR* str)
        { return set((const wchar16*)str); }

    UnicodeString& copy(const WCHAR* str, Size size)
        { return copy((const wchar16*)str, size); }

    UnicodeString& copy(const WCHAR* str)
        { return copy((const wchar16*)str); }

    UnicodeString& set_win32(const char* str, int size) {
        if (str == NULL) {
            set();
        } else {
            setempty();
            if (size > 0) {
                assert( size < IntegerT<Size>::MAX );
                int newsize = ::MultiByteToWideChar(CP_UTF8, 0, str, size, NULL, 0);
                if (newsize > 0) {
                    WCHAR* buf = (WCHAR*)advBuffer(++newsize); // leave a space for terminator
                    const int written = ::MultiByteToWideChar(CP_UTF8, 0, str, size, buf, newsize);
                    if (written >= 0)
                        advSize(written);
                }
            }
        }
        return *this;
    }

    UnicodeString& set_win32(const char* str) {
        if (str == NULL) {
            set();
        } else {
            setempty();
            if (*str != NULL) {
                ulong size = (ulong)strlen(str);
                assert( size < IntegerT<Size>::MAX );
                int newsize = ::MultiByteToWideChar(CP_UTF8, 0, str, size, NULL, 0);
                if (newsize > 0) {
                    WCHAR* buf = (WCHAR*)advBuffer(++newsize); // leave a space for terminator
                    const int written = ::MultiByteToWideChar(CP_UTF8, 0, str, size, buf, newsize);
                    if (written >= 0)
                        advSize(written);
                }
            }
        }
        return *this;
    }
#endif

    // INFO

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

    const wchar16* cstr(UnicodeString& buffer) const {
        static const wchar16 EMPTY = 0;
        return (size_ > 0 ? buffer.set(*this).cstr() : &EMPTY);
    }

    const wchar16* cstr() {
        static const wchar16 EMPTY = 0;
        const wchar16* result = &EMPTY;
        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 wchar16* cstrM() const {
        static const wchar16 EMPTY = 0;
        return (size_ > 0 ? const_cast<UnicodeString*>(this)->cstr() : &EMPTY);
    }

    // COMPARE

    int compare(const ListBaseType& data) const
        { return utf16_compare(data_, size_, data.data_, data.size_); }

    int compare(const StringBase& data) const
        { return utf16_compare8(data_, size_, data.data_, data.size_); }

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

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

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

    bool operator==(const StringBase& str) const
        { return (utf16_compare8(data_, size_, str.data_, str.size_) == 0); }

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

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

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

    bool operator!=(const StringBase& str) const
        { return (utf16_compare8(data_, size_, str.data_, str.size_) != 0); }

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

    // COPY

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

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

    UnicodeString& copy(const wchar16* str) {
        if (str == NULL)
            ListType::set();
        else
            ListType::copy(str, utf16_strlen(str));
        return *this;
    }

    // OVERRIDES

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    UnicodeString& addnew(Size size=1)
        { ListType::addnew(size); return *this; }

    UnicodeString& add(const Item* data, Size size)
        { ListType::add(data, size); return *this; }

    UnicodeString& add(const ListBaseType& data)
        { ListType::add(data); return *this; }

    UnicodeString& add(const Item& data)
        { ListType::add(data); return *this; }

    UnicodeString& operator<<(const Item& data)
        { ListType::operator<<(data); return *this; }

    UnicodeString& operator<<(const ListBaseType& data)
        { ListType::operator<<(data); return *this; }

    UnicodeString& operator<<(const ValNull& val)
        { ListType::operator<<(val); return *this; }

    UnicodeString& operator<<(const ValEmpty& val)
        { ListType::operator<<(val); return *this; }

    UnicodeString& prependnew(Size size=1)
        { ListType::prependnew(size); return *this; }

    UnicodeString& prepend(const Item* data, Size size)
        { ListType::prepend(data, size); return *this; }

    UnicodeString& prepend(const ListBaseType& data)
        { ListType::prepend(data); return *this; }

    UnicodeString& prepend(const Item& data)
        { ListType::prepend(data); return *this; }

    UnicodeString& fill(const Item& item, Key index=0, Size size=ALL)
        { ListType::fill(item, index, size); return *this; }

    UnicodeString& replace(Key index, Size rsize, const Item* data, Size size)
        { ListType::replace(index, rsize, data, size); return *this; }

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

private:
    UnicodeString& reverse() EVO_ONCPP11(= delete);
};


}
#endif