String.h

#pragma once


#include <libutl/FlagsMI.h>


UTL_NS_BEGIN;



class String : public Object, public FlagsMI
{
    UTL_CLASS_DECL(String, Object);

public:
    String(const char* s, bool owner = true, bool duplicate = true, bool caseSensitive = true);

    String(size_t size);

    String(char c)
    {
        _s = new char[8];
        _s[0] = c;
        _s[1] = '\0';
        _size = 8;
        _length = size_t_max;
    }

    virtual int compare(const Object& rhs) const;

    virtual void copy(const Object& rhs);

    virtual void steal(Object& rhs);

    virtual size_t hash(size_t size) const;

    virtual void serialize(Stream& stream, uint_t io, uint_t mode = ser_default);

    virtual size_t innerAllocatedSize() const;

    virtual String toString() const;



    bool
    isOwner() const
    {
        return (_size != 0);
    }

    void
    setOwner(bool owner)
    {
        if (owner)
        {
            if (_size == 0) _size = length() + 1;
        }
        else
        {
            _size = 0;
        }
    }

    bool
    isCaseSensitive() const
    {
        return !getFlag(flg_caseInsensitive);
    }

    void
    setCaseSensitive(bool caseSensitive)
    {
        setFlag(flg_caseInsensitive, !caseSensitive);
    }

    bool
    isMarked() const
    {
        return getFlag(flg_marked);
    }

    void
    setMarked(bool marked = true)
    {
        setFlag(flg_marked, marked);
    }



    int compareSubstring(size_t begin, const String& rhs, size_t n);

    int
    compareSubstring(size_t begin, const char* rhs, size_t len)
    {
        return compareSubstring(begin, String(rhs, false), len);
    }

    int comparePrefix(const String& rhs) const;

    int
    comparePrefix(const char* rhs) const
    {
        return comparePrefix(String(rhs, false));
    }

    int compareSuffix(const String& rhs) const;

    int
    compareSuffix(const char* rhs) const
    {
        return compareSuffix(String(rhs, false));
    }

    inline int
    strcmp(const char* lhs, const char* rhs) const
    {
        if (isCaseSensitive())
        {
            int d = (int)*lhs - (int)*rhs;
            if (d != 0) return d;
            return ::strcmp(lhs + 1, rhs + 1);
        }
        else
        {
            int d = tolower(*lhs) - tolower(*rhs);
            if (d != 0) return d;
            return ::strcasecmp(lhs + 1, rhs + 1);
        }
    }

    inline std::function<int(const char*, const char*)>
    strcmp() const
    {
        return isCaseSensitive() ? ::strcmp : ::strcasecmp;
    }

    inline int
    strncmp(const char* lhs, const char* rhs, size_t n) const
    {
        return isCaseSensitive() ? ::strncmp(lhs, rhs, n) : ::strncasecmp(lhs, rhs, n);
    }

    inline std::function<int(const char*, const char*, size_t)>
    strncmp() const
    {
        return isCaseSensitive() ? ::strncmp : ::strncasecmp;
    }



    String
    backslashEscaped(const char* specials) const
    {
        return backslashEscaped(String(specials, false));
    }

    String backslashEscaped(const String& specials) const;

    String backslashUnescaped() const;

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

    size_t find(const String& str, size_t begin = 0) const;

    size_t
    find(const char* str, size_t begin = 0) const
    {
        return find(String(str, false), begin);
    }

    size_t find(char c, size_t begin = 0) const;

    size_t findBM(const String& str, size_t begin = 0) const;

    size_t
    findBM(const char* str, size_t begin = 0) const
    {
        return findBM(String(str, false), begin);
    }

    char
    firstChar() const
    {
        return *_s;
    }

    char
    lastChar() const
    {
        size_t len = length();
        if (len == 0) return '\0';
        return _s[len - 1];
    }

    const char*
    get() const
    {
        return _s;
    }

    size_t
    length() const
    {
        if (_length == size_t_max) _length = strlen(_s);
        ASSERTD(_length == strlen(_s));
        return _length;
    }

    void
    lengthInvalidate() const
    {
        _length = size_t_max;
    }

    String
    prefix(size_t n) const
    {
        return subString(0, n);
    }

    size_t
    size() const
    {
        return _size;
    }

    String subString(size_t begin, size_t len = size_t_max) const;

    String
    suffix(size_t n) const
    {
        size_t len = length();
        if (n >= len) return self;
        return subString(len - n, n);
    }

    String reversed() const;

    String nextToken(size_t& idx, char delim = ' ', bool processQuotes = false) const;



    String&
    clear()
    {
        if (isOwner())
            *_s = '\0';
        else
            _s = &nullChar;
        _length = 0;
        return self;
    }

    String& excise();

    char*
    get()
    {
        return _s;
    }

    char
    get(size_t i) const
    {
        ASSERTD(i <= length());
        return _s[i];
    }

    inline String&
    assertOwner()
    {
        if (_size == 0) _assertOwner();
        return *this;
    }

    inline void
    assertOwner(size_t size, size_t increment = 8)
    {
        if (_size < size) _assertOwner(size, increment);
    }

    void economize();

    void
    reserve(size_t size, size_t increment = 8)
    {
        if (_size < size) _assertOwner(size, increment);
    }

    String& append(char c);

    String&
    append(const String& s)
    {
        return append(s._s, s.length());
    }

    String&
    append(const char* s)
    {
        ASSERTD(s != nullptr);
        return append(s, strlen(s));
    }

    String& append(const char* s, size_t len);

    String chop(size_t begin, size_t len = size_t_max);

    void remove(size_t begin, size_t len = size_t_max);

    String& replace(const String& lhs, const String& rhs);

    String&
    replace(const char* lhs, const char* rhs)
    {
        return replace(String(lhs, false), String(rhs, false));
    }

    String&
    replace(const char* lhs, const String& rhs)
    {
        return replace(String(lhs, false), rhs);
    }

    String&
    replace(const String& lhs, const char* rhs)
    {
        return replace(lhs, String(rhs, false));
    }

    String& replace(size_t begin, size_t len, const String& str);

    String& reverse();

    void set(const char* s, bool owner = true, bool duplicate = true, size_t length = size_t_max);

    String& toLower(size_t begin = 0, size_t len = size_t_max);

    String& toUpper(size_t begin = 0, size_t len = size_t_max);

    String& padBegin(size_t len, char c = ' ');

    String& padEnd(size_t len, char c = ' ');

    String& trim();

    String& trimBegin();

    String& trimEnd();



    static String repeat(char c, size_t num);

    static String spaces(size_t num);



    inline String operator+(char c) const
    {
        String res(this->length() + 2);
        res.append(self);
        res.append(c);
        return res;
    }

    inline String operator+(const char* str) const
    {
        ASSERTD(str != nullptr);
        return self + String(str, false);
    }

    inline String operator+(const String& rhs) const
    {
        String res(this->length() + rhs.length() + 1);
        res = self;
        res += rhs;
        return res;
    }

    inline String& operator+=(char c)
    {
        return append(c);
    }

    inline String& operator+=(const char* rhs)
    {
        return append(String(rhs, false));
    }

    inline String& operator+=(const String& rhs)
    {
        return append(rhs);
    }

    inline String& operator=(const char* str)
    {
        set(str);
        return self;
    }

    inline String& operator=(char c)
    {
        clear();
        append(c);
        return self;
    }

    inline char& operator[](size_t i)
    {
        ASSERTD(i <= length());
        return _s[i];
    }

    inline const char& operator[](size_t i) const
    {
        ASSERTD(i <= length());
        return _s[i];
    }

    inline operator char*()
    {
        return _s;
    }

    inline operator const char*()
    {
        return _s;
    }

    inline operator const char*() const
    {
        return _s;
    }

    inline operator void*()
    {
        return _s;
    }

    inline operator const void*()
    {
        return _s;
    }

    inline operator const void*() const
    {
        return _s;
    }

    inline bool operator<(const Object& rhs) const
    {
        return (compare(rhs) < 0);
    }
    inline bool operator<=(const Object& rhs) const
    {
        return (compare(rhs) <= 0);
    }
    inline bool operator>(const Object& rhs) const
    {
        return (compare(rhs) > 0);
    }
    inline bool operator>=(const Object& rhs) const
    {
        return (compare(rhs) >= 0);
    }
    inline bool operator==(const Object& rhs) const
    {
        return (compare(rhs) == 0);
    }
    inline bool operator!=(const Object& rhs) const
    {
        return (compare(rhs) != 0);
    }

    inline bool operator<(const String& rhs) const
    {
        return (compare(rhs) < 0);
    }
    inline bool operator<=(const String& rhs) const
    {
        return (compare(rhs) <= 0);
    }
    inline bool operator>(const String& rhs) const
    {
        return (compare(rhs) > 0);
    }
    inline bool operator>=(const String& rhs) const
    {
        return (compare(rhs) >= 0);
    }
    inline bool operator==(const String& rhs) const
    {
        return (compare(rhs) == 0);
    }
    inline bool operator!=(const String& rhs) const
    {
        return (compare(rhs) != 0);
    }
protected:
    static void
    setBounds(size_t& begin, size_t& end, size_t& len, size_t myLen)
    {
        if (begin > myLen) begin = myLen;
        if (len > myLen) len = myLen;
        end = begin + len;
        if (end > myLen) end = myLen;
        len = end - begin;
    }

protected:
    char* _s;
    size_t _size;
    mutable size_t _length;

private:
    enum flg_t
    {
        flg_marked,
        flg_caseInsensitive
    };

private:
    void
    init(bool caseSensitive = true)
    {
        _s = &nullChar;
        _size = 0;
        _length = 0;
        if (!caseSensitive) setCaseSensitive(false);
    }

    void
    deInit()
    {
// check length in DEBUG mode, and allow an easy breakpoint
#ifdef DEBUG
        bool lengthOK = ((_length == size_t_max) || (_length == strlen(_s)));
        ASSERT(lengthOK);
        ASSERT(nullChar == '\0');
#endif

        // if we own the string, delete it
        if (isOwner()) delete[] _s;
    }

    void _assertOwner();
    void _assertOwner(size_t size, size_t increment);

private:
    static char nullChar;
};


extern const String emptyString;


UTL_NS_END;


inline bool operator==(const utl::String& lhs_, const char* rhs)
{
    ASSERTD(rhs != nullptr);
    const char* lhs = lhs_.get();
    return (lhs_.strcmp(lhs, rhs) == 0);
}


inline bool operator!=(const utl::String& lhs_, const char* rhs)
{
    ASSERTD(rhs != nullptr);
    const char* lhs = lhs_.get();
    return (lhs_.strcmp(lhs, rhs) != 0);
}


inline bool operator==(const char* lhs, const utl::String& rhs_)
{
    ASSERTD(lhs != nullptr);
    const char* rhs = rhs_.get();
    return (rhs_.strcmp(lhs, rhs) == 0);
}


inline bool operator!=(const char* lhs, const utl::String& rhs_)
{
    ASSERTD(lhs != nullptr);
    const char* rhs = rhs_.get();
    return (rhs_.strcmp(lhs, rhs) != 0);
}


inline bool operator==(const utl::String& lhs_, const char rhs)
{
    ASSERTD(rhs != '\0');
    const char* lhs = lhs_.get();
    if (lhs_.isCaseSensitive()) return (*lhs == rhs) && (lhs[1] == '\0');
    return (tolower(*lhs) == tolower(rhs)) && (lhs[1] == '\0');
}


inline bool operator!=(const utl::String& lhs_, const char rhs)
{
    ASSERTD(rhs != '\0');
    const char* lhs = lhs_.get();
    if (lhs_.isCaseSensitive()) return (*lhs != rhs) || (lhs[1] != '\0');
    return (tolower(*lhs) != tolower(rhs)) || (lhs[1] != '\0');
}


inline bool operator==(char lhs, const utl::String& rhs_)
{
    ASSERTD(lhs != '\0');
    const char* rhs = rhs_.get();
    if (rhs_.isCaseSensitive()) return (lhs == *rhs) && (rhs[1] == '\0');
    return (tolower(lhs) == tolower(*rhs)) && (rhs[1] == '\0');
}


inline bool operator!=(char lhs, const utl::String& rhs_)
{
    ASSERTD(lhs != '\0');
    const char* rhs = rhs_.get();
    if (rhs_.isCaseSensitive()) return (lhs != *rhs) || (rhs[1] != '\0');
    return (tolower(lhs) != tolower(*rhs)) || (rhs[1] != '\0');
}


inline utl::String operator+(const char* lhs, const utl::String& rhs)
{
    return utl::String(lhs, false) + rhs;
}


inline utl::String operator+(char lhs, const utl::String& rhs)
{
    utl::String res(rhs.length() + 2);
    res.append(lhs);
    res.append(rhs);
    return res;
}