zfstring.h

Go to the documentation of this file.

 
#ifndef _ZFI_zfstring_h_
#define _ZFI_zfstring_h_
 
#include "ZFCoreTypeDef_CharType.h"
#include "ZFCoreTypeDef_ClassType.h"
#include "ZFCoreMutex.h"
#include "ZFMemPool.h"
 
ZF_NAMESPACE_GLOBAL_BEGIN

template<int minCapacityRadix>
inline void ZFCoreCapacityOptimize(ZF_IN_OUT zfindex &capacity) {
    capacity >>= minCapacityRadix;
    capacity |= capacity >> 1;
    capacity |= capacity >> 2;
    capacity |= capacity >> 4;
    capacity |= capacity >> 8;
    capacity |= capacity >> 16;
    ++capacity;
    capacity <<= minCapacityRadix;
}
 
// ============================================================
template<typename T_Char>
zfindex _ZFP_zfstring_len(ZF_IN const T_Char *s) {
    const T_Char *p = s;
    while(*p) {++p;}
    return p - s;
}
inline zfindex _ZFP_zfstring_len(ZF_IN const zfchar *s) {
    return zfslen(s);
}
template<typename T_Char>
zfint _ZFP_zfstring_cmp(
        ZF_IN const T_Char *s1
        , ZF_IN const T_Char *s1End
        , ZF_IN const T_Char *s2
        , ZF_IN const T_Char *s2End
        ) {
    while(s1 < s1End && s2 < s2End && *s1 == *s2) {++s1, ++s2;}
    if(s1 == s1End) {
        if(s2 == s2End) {
            return 0;
        }
        else {
            return -1;
        }
    }
    else {
        if(s2 == s2End) {
            return 1;
        }
        else {
            return *s1 - *s2;
        }
    }
}
 
template<typename T_Char>
zfclassNotPOD _ZFP_zfstringD {
public:
    zfuint refCount;
    // capacity: including tail '\0'
    // possible values:
    // * _ZFP_ST_Shared and length > 0 : shared string and null terminated
    // * >= _ZFP_ST_Normal : normal allocated string
    zfuint capacity;
    zfuint length;
    union {
        T_Char *buf; // capacity >= _ZFP_ST_Normal
        const T_Char *ptr; // capacity = _ZFP_ST_Shared
    } d;
public:
    _ZFP_zfstringD(void) : refCount(1), capacity(0), length(0), d() {
        d.ptr = Empty();
    }
    ~_ZFP_zfstringD(void) {
        if(this->capacity >= 2 /* _ZFP_ST_Normal */) {
            zfunsafe_zfpoolFree(this->d.buf);
        }
    }
public:
    static const T_Char *Empty(void) {
        static T_Char buf[1] = {0};
        return buf;
    }
};
template<typename T_Char>
zfclassLikePOD _ZFP_zfstringH {
public:
    _ZFP_zfstringH(void) : d(zfpoolNew(_ZFP_zfstringD<T_Char>)) {}
    ~_ZFP_zfstringH(void) {zfpoolDelete(d);}
public:
    _ZFP_zfstringD<T_Char> *d;
};
 
// ============================================================
template<typename T_Char>
zfclassLikePOD zft_zfstring {
public:
    zft_zfstring(void)
    {
        ZFCoreMutexLocker();
        d = _ZFP_Empty();
        ++(d->refCount);
    }

    zft_zfstring(ZF_IN const zft_zfstring<T_Char> &s)
    {
        ZFCoreMutexLocker();
        d = s.d;
        ++(d->refCount);
    }

    zft_zfstring(ZF_IN const zft_zfstring<T_Char> &s, ZF_IN zfindex len)
    {
        ZFCoreMutexLocker();
        d = _ZFP_Empty();
        ++(d->refCount);
        if(len >= s.length()) {
            this->assign(s);
        }
        else {
            this->assign(s.cString(), len);
        }
    }

    zft_zfstring(ZF_IN const zft_zfstring<T_Char> &s, ZF_IN zfindex pos, ZF_IN zfindex len)
    {
        ZFCoreMutexLocker();
        d = _ZFP_Empty();
        ++(d->refCount);
        if(pos < s.length()) {
            if(len > s.length() - pos) {
                len = s.length() - pos;
            }
            this->assign(s.cString() + pos, len);
        }
    }

    zft_zfstring(ZF_IN const T_Char *s)
    {
        ZFCoreMutexLocker();
        d = _ZFP_Empty();
        ++(d->refCount);
        if(s) {
            this->assign(s);
        }
    }

    zft_zfstring(ZF_IN const T_Char *s, ZF_IN zfindex len)
    {
        ZFCoreMutexLocker();
        d = _ZFP_Empty();
        ++(d->refCount);
        if(s) {
            this->assign(s, len);
        }
    }

    zft_zfstring(ZF_IN const T_Char *s, ZF_IN zfindex pos, ZF_IN zfindex len)
    {
        ZFCoreMutexLocker();
        d = _ZFP_Empty();
        ++(d->refCount);
        if(s) {
            this->assign(s + pos, len);
        }
    }

    zft_zfstring(ZF_IN const zfnullT &dummy)
    {
        ZFCoreMutexLocker();
        d = _ZFP_Empty();
        ++(d->refCount);
    }
    ~zft_zfstring(void) {
        ZFCoreMutexLocker();
        if(--(d->refCount) == 0) {
            zfunsafe_zfpoolDelete(d);
        }
    }
 
public:
    inline operator const T_Char * (void) const {
        return this->isEmpty() ? zfnull : this->cString();
    }
    inline operator zfbool (void) const {
        return !this->isEmpty();
    }
public:
    inline zft_zfstring<T_Char> &operator = (ZF_IN const zft_zfstring<T_Char> &s) {
        if(d != s.d) {
            ZFCoreMutexLocker();
            _ZFP_zfstringD<T_Char> *dTmp = d;
            d = s.d;
            ++(d->refCount);
            if(--(dTmp->refCount) == 0) {
                zfunsafe_zfpoolDelete(dTmp);
            }
        }
        return *this;
    }
    inline zft_zfstring<T_Char> &operator = (ZF_IN const T_Char *s) {return this->assign(s);}
    inline zft_zfstring<T_Char> &operator = (ZF_IN zfnullT const &dummy) {return this->assign(dummy);}
    zfbool operator == (ZF_IN const zft_zfstring<T_Char> &ref) const {return this->isEqual(ref);}
    zfbool operator != (ZF_IN const zft_zfstring<T_Char> &ref) const {return !this->isEqual(ref);}
    zfbool operator == (ZF_IN const T_Char *ref) const {return this->isEqual(ref);}
    zfbool operator != (ZF_IN const T_Char *ref) const {return !this->isEqual(ref);}
    zfbool operator == (ZF_IN zfnullT const &dummy) const {return this->isEmpty();}
    zfbool operator != (ZF_IN zfnullT const &dummy) const {return !this->isEmpty();}
public:
    /* ZFTAG_TRICKS: tricks to make zfstlmap<zfstring, xxx> works */
    inline zfbool operator < (ZF_IN const zft_zfstring<T_Char> &ref) const {return this->compare(ref) < 0;}
    inline zfbool operator <= (ZF_IN const zft_zfstring<T_Char> &ref) const {return this->compare(ref) <= 0;}
    inline zfbool operator > (ZF_IN const zft_zfstring<T_Char> &ref) const {return this->compare(ref) > 0;}
    inline zfbool operator >= (ZF_IN const zft_zfstring<T_Char> &ref) const {return this->compare(ref) >= 0;}
 
public:
    inline zft_zfstring<T_Char> &operator += (ZF_IN T_Char c) {return this->append(c);}
    inline zft_zfstring<T_Char> &operator += (ZF_IN const zft_zfstring<T_Char> &s) {return this->append(s);}
    inline zft_zfstring<T_Char> &operator += (ZF_IN const T_Char *s) {return this->append(s);}
 
    template<typename T_Int>
    inline const T_Char *operator + (ZF_IN T_Int const &offset) const {
        return this->cString() + offset;
    }
 
public:
    void set(
            ZF_IN zfindex pos
            , ZF_IN T_Char c
            ) {
        _prepareWrite(this->length());
        d->d.buf[pos] = c;
    }

    inline T_Char get(ZF_IN zfindex pos) const {
        return d->d.ptr[pos];
    }

    template<typename T_Int>
    inline T_Char operator [] (ZF_IN T_Int pos) const {
        return this->get(pos);
    }
 
public:
    void swap(ZF_IN_OUT zft_zfstring<T_Char> &ref) {
        ZFCoreMutexLocker();
        _ZFP_zfstringD<T_Char> *dTmp = d;
        d = ref.d;
        ref.d = dTmp;
    }
 
public:
    inline zft_zfstring<T_Char> &append(ZF_IN T_Char c) {
        _prepareWrite(d->length + 1);
        d->d.buf[d->length] = c;
        d->d.buf[++(d->length)] = '\0';
        return *this;
    }

    inline zft_zfstring<T_Char> &append(ZF_IN const zft_zfstring<T_Char> &s) {
        if(s) {
            if(this->capacity() != 0) {
                _appendImpl(s.cString(), s.length());
            }
            else {
                this->operator = (s);
            }
        }
        return *this;
    }

    inline zft_zfstring<T_Char> &append(
            ZF_IN const zft_zfstring<T_Char> &s
            , ZF_IN zfindex len
            ) {
        len = (len <= s.length() ? len : s.length());
        if(len > 0) {
            _appendImpl(s.cString(), len);
        }
        return *this;
    }

    inline zft_zfstring<T_Char> &append(
            ZF_IN const zft_zfstring<T_Char> &s
            , ZF_IN zfindex offset
            , ZF_IN zfindex len
            ) {
        if(offset > s.length()) {
            offset = s.length();
        }
        if(len > s.length() - offset) {
            len = s.length() - offset;
        }
        if(len > 0) {
            _appendImpl(s.cString() + offset, len);
        }
        return *this;
    }

    zft_zfstring<T_Char> &append(
            ZF_IN const void *s
            , ZF_IN_OPT zfindex len = zfindexMax()
            ) {
        if(s) {
            if(len == zfindexMax()) {
                len = _ZFP_zfstring_len((const T_Char *)s);
            }
            if(len > 0) {
                _appendImpl(s, len);
            }
        }
        return *this;
    }
private:
    void _appendImpl(
            ZF_IN const void *s
            , ZF_IN zfindex len
            ) {
        _prepareWrite(d->length + len);
        zfmemcpy(d->d.buf + d->length, s, len * sizeof(T_Char));
        d->d.buf[d->length += (zfuint)len] = '\0';
    }
 
public:
    inline zft_zfstring<T_Char> &assign(ZF_IN const zft_zfstring<T_Char> &s) {
        this->operator = (s);
        return *this;
    }

    inline zft_zfstring<T_Char> &assign(
            ZF_IN const zft_zfstring<T_Char> &s
            , ZF_IN zfindex len
            ) {
        return this->assign(s.cString(), len <= s.length() ? len : s.length());
    }

    inline zft_zfstring<T_Char> &assign(
            ZF_IN const zft_zfstring<T_Char> &s
            , ZF_IN zfindex offset
            , ZF_IN zfindex len
            ) {
        if(offset > s.length()) {
            offset = s.length();
        }
        if(len > s.length() - offset) {
            len = s.length() - offset;
        }
        return this->assign(s.cString() + offset, len);
    }

    zft_zfstring<T_Char> &assign(
            ZF_IN const void *s
            , ZF_IN_OPT zfindex len = zfindexMax()
            ) {
        if(len == zfindexMax()) {
            if(s) {
                len = _ZFP_zfstring_len((const T_Char *)s);
            }
            else {
                len = 0;
            }
        }
        if(len > 0) {
            if(len >= d->capacity || d->refCount > 1
                    || (d->capacity >= 128 && len < d->capacity / 3)
                    ) {
                _capacityChange(len, zffalse);
            }
            d->length = (zfuint)len;
            zfmemcpy(d->d.buf, s, len * sizeof(T_Char));
            d->d.buf[len] = '\0';
        }
        else {
            this->removeAll();
        }
        return *this;
    }

    inline zft_zfstring<T_Char> &assign(ZF_IN const zfnullT &dummy) {
        this->removeAll();
        return *this;
    }
 
public:
    inline zft_zfstring<T_Char> &insert(
            ZF_IN zfindex insertAt
            , ZF_IN const zft_zfstring<T_Char> &s
            ) {
        return this->insert(insertAt, s.cString(), s.length());
    }

    zft_zfstring<T_Char> &insert(
            ZF_IN zfindex insertAt
            , ZF_IN const void *s
            , ZF_IN_OPT zfindex len = zfindexMax()
            ) {
        if(insertAt >= this->length()) {
            this->append(s, len);
        }
        else if(s) {
            if(len == zfindexMax()) {
                len = _ZFP_zfstring_len((const T_Char *)s);
            }
            if(len > 0) {
                zfindex lenTmp = this->length();
                _prepareWrite(lenTmp + len);
                d->length = (zfuint)(lenTmp + len);
                zfmemmove(d->d.buf + insertAt + len, d->d.buf + insertAt, (lenTmp - insertAt) * sizeof(T_Char));
                zfmemcpy(d->d.buf + insertAt, s, len * sizeof(T_Char));
                d->d.buf[d->length] = '\0';
            }
        }
        return *this;
    }
 
public:
    inline zft_zfstring<T_Char> &replace(
            ZF_IN zfindex replacePos
            , ZF_IN zfindex replaceLen
            , ZF_IN const zft_zfstring<T_Char> &s
            ) {
        return this->replace(replacePos, replaceLen, s.cString(), s.length());
    }

    zft_zfstring<T_Char> &replace(
            ZF_IN zfindex replacePos
            , ZF_IN zfindex replaceLen
            , ZF_IN const void *s
            , ZF_IN_OPT zfindex len = zfindexMax()
            ) {
        if(replacePos >= this->length()) {
            this->append(s, len);
        }
        else if(s) {
            zfindex lenTmp = this->length();
            if(replaceLen > lenTmp - replacePos) {
                replaceLen = lenTmp - replacePos;
            }
            if(len == zfindexMax()) {
                len = _ZFP_zfstring_len((const T_Char *)s);
            }
            if(len > replaceLen) {
                _prepareWrite(lenTmp + len - replaceLen);
            }
            else {
                _prepareWrite(lenTmp);
            }
            zfmemmove(d->d.buf + replacePos + len, d->d.buf + replacePos + replaceLen, (lenTmp - replacePos - replaceLen) * sizeof(T_Char));
            zfmemcpy(d->d.buf + replacePos, s, len * sizeof(T_Char));
            d->length = (zfuint)(lenTmp + len - replaceLen);
            d->d.buf[d->length] = '\0';
        }
        return *this;
    }
 
public:
    inline const T_Char *cString(void) const {
        return d->d.ptr;
    }

    inline zfindex length(void) const {
        return (zfindex)d->length;
    }

    inline zfbool isShared(void) const {
        return d->capacity < _ZFP_ST_Normal && d->length > 0;
    }

    inline zfbool isEmpty(void) const {
        return d->length == 0;
    }

    inline zfbool isEqual(ZF_IN const zft_zfstring<T_Char> &ref) const {
        return d == ref.d || (this->length() == ref.length() && this->compare(ref) == 0);
    }

    inline zfbool isEqual(ZF_IN const T_Char *s) const {
        return 0 == _ZFP_zfstring_cmp(this->cString(), this->cString() + this->length(), s, s + (s ? _ZFP_zfstring_len(s) : 0));
    }
 
public:
    inline zfbool capacity(ZF_IN zfindex capacity) {
        if(capacity >= d->capacity) {
            return _capacityChange(capacity - 1, zftrue);
        }
        else {
            return zftrue;
        }
    }

    inline zfindex capacity(void) const {
        if(d->capacity >= _ZFP_ST_Normal) {
            return (zfindex)d->capacity;
        }
        else {
            return 0;
        }
    }

    inline void capacityTrim(void) {
        if(d->capacity >= 128 && d->length < d->capacity / 3) {
            _capacityChange(this->length(), zftrue);
        }
    }

    void remove(
            ZF_IN zfindex pos
            , ZF_IN_OPT zfindex len = zfindexMax()
            ) {
        zfindex lenTmp = this->length();
        if(pos < lenTmp) {
            if(len > lenTmp - pos) {
                len = lenTmp - pos;
            }
            if(len > 0) {
                _prepareWrite(lenTmp);
                zfmemmove(d->d.buf + pos, d->d.buf + pos + len, (lenTmp - pos - len) * sizeof(T_Char));
                d->length -= (zfuint)len;
                d->d.buf[d->length] = '\0';
            }
        }
    }

    void removeAll(void) {
        if(!this->isEmpty()) {
            ZFCoreMutexLocker();
            if(d->refCount == 1) {
                if(d->capacity >= 128) {
                    if(--(d->refCount) == 0) {
                        zfunsafe_zfpoolDelete(d);
                    }
                    d = _ZFP_Empty();
                    ++(d->refCount);
                }
                else if(d->capacity >= _ZFP_ST_Normal) {
                    d->d.buf[0] = '\0';
                    d->length = 0;
                }
                else {
                    d->d.ptr = _ZFP_zfstringD<T_Char>::Empty();
                    d->length = 0;
                }
            }
            else {
                if(--(d->refCount) == 0) {
                    zfunsafe_zfpoolDelete(d);
                }
                d = _ZFP_Empty();
                ++(d->refCount);
            }
        }
    }
 
public:
    inline zfint compare(ZF_IN const zft_zfstring<T_Char> &s) const {
        return d == s.d ? 0 : _ZFP_zfstring_cmp(this->cString(), this->cString() + this->length(), s.cString(), s.cString() + s.length());
    }

    zfint compare(
            ZF_IN const T_Char *s
            , ZF_IN zfindex len = zfindexMax()
            ) const {
        if(len == zfindexMax()) {
            len = s ? _ZFP_zfstring_len(s) : 0;
        }
        return _ZFP_zfstring_cmp(this->cString(), this->cString() + this->length(), s, s + (s ? _ZFP_zfstring_len(s) : 0));
    }
 
public:
    const void *buffer(void) const {
        return d->d.ptr;
    }

    void zfunsafe_bufferGiveUp(ZF_OUT void *&ret, ZF_OUT zfindex &length) {
        ZFCoreMutexLocker();
        _prepareWrite(this->length());
        ret = (void *)d->d.buf;
        length = d->length;
 
        d->capacity = 0;
        d->length = 0;
        d->d.ptr = _ZFP_zfstringD<T_Char>::Empty();
        zfunsafe_zfpoolDelete(d);
 
        d = _ZFP_Empty();
        ++(d->refCount);
    }

    static void zfunsafe_bufferFree(ZF_IN void *buf) {
        zfpoolFree(buf);
    }

    T_Char *zfunsafe_buffer(void) {
        _prepareWrite(this->length());
        return d->d.buf;
    }

    void zfunsafe_length(ZF_IN zfindex length) {
        _prepareWrite(this->length());
        d->length = (zfuint)length;
    }
 
private:
    enum { // string type
        _ZFP_ST_Shared = 0, // shared and null terminated
        _ZFP_ST_Normal = 1, // normal allocated
    };
private:
    _ZFP_zfstringD<T_Char> *d;
public:
    static inline const zft_zfstring<T_Char> &Empty(void) {
        static const zft_zfstring<T_Char> d;
        return d;
    }
public:
    static zft_zfstring<T_Char> shared(
            ZF_IN const void *sLiteral
            , ZF_IN_OPT zfindex length = zfindexMax()
            ) {
        ZFCoreMutexLocker();
        _ZFP_zfstringD<T_Char> *d = zfunsafe_zfpoolNew(_ZFP_zfstringD<T_Char>);
        d->d.ptr = (const T_Char *)sLiteral;
        d->length = (length != zfindexMax() ? (zfuint)length : (zfuint)_ZFP_zfstring_len((const T_Char *)sLiteral));
        d->capacity = _ZFP_ST_Shared;
        return zft_zfstring<T_Char>(d);
    }

    const zft_zfstring<T_Char> &sharedCopy(void) const {
        if(this->isShared()) {
            ZFCoreMutexLocker();
            const T_Char *ptr = d->d.ptr;
            {
                zfindex capacity = d->length;
                _capacityOptimize(capacity);
                d->capacity = (zfuint)capacity;
            }
            d->d.buf = (T_Char *)zfunsafe_zfpoolMalloc(d->capacity);
            zfmemcpy(d->d.buf, ptr, d->length);
            d->d.buf[d->length] = '\0';
        }
        return *this;
    }
private:
    explicit zft_zfstring(ZF_IN _ZFP_zfstringD<T_Char> *d)
    : d(d)
    {
    }
private:
    static _ZFP_zfstringD<T_Char> *_ZFP_Empty(void) {
        static _ZFP_zfstringH<T_Char> d;
        return d.d;
    }
    static inline void _capacityOptimize(ZF_IN_OUT zfindex &capacity) {
        ZFCoreCapacityOptimize<4>(capacity);
    }
    // capacity: excluding tail '\0'
    zfbool _capacityChange(ZF_IN zfindex capacity, zfbool keepContents) {
        _capacityOptimize(capacity);
        ZFCoreMutexLocker();
        if(d->refCount == 1) {
            if(d->capacity >= _ZFP_ST_Normal) {
                T_Char *buf = (T_Char *)zfunsafe_zfpoolRealloc(d->d.buf, capacity * sizeof(T_Char));
                if(buf == zfnull) {
                    return zffalse;
                }
                d->d.buf = buf;
            }
            else {
                const T_Char *ptr = d->d.ptr;
                T_Char *buf = (T_Char *)zfunsafe_zfpoolMalloc(capacity * sizeof(T_Char));
                if(buf == zfnull) {
                    return zffalse;
                }
                d->d.buf = buf;
                if(ptr && keepContents) {
                    zfmemcpy(d->d.buf, ptr, capacity * sizeof(T_Char));
                }
                else {
                    d->d.buf[0] = '\0';
                }
            }
        }
        else {
            T_Char *buf = (T_Char *)zfunsafe_zfpoolMalloc(capacity * sizeof(T_Char));
            if(buf == zfnull) {
                return zffalse;
            }
            _ZFP_zfstringD<T_Char> *dTmp = d;
            d = zfunsafe_zfpoolNew(_ZFP_zfstringD<T_Char>);
            d->length = dTmp->length;
            d->d.buf = buf;
            if(dTmp->length > 0 && keepContents) {
                zfmemcpy(d->d.buf, dTmp->d.ptr, dTmp->length * sizeof(T_Char));
                d->d.buf[dTmp->length] = '\0';
            }
            else {
                d->d.buf[0] = '\0';
            }
        }
        d->capacity = (zfuint)capacity;
        if(!keepContents) {
            d->length = 0;
        }
        return zftrue;
    }
    inline void _prepareWrite(ZF_IN zfindex len) {
        if(len >= d->capacity || d->refCount > 1) {
            _capacityChange(len, zftrue);
        }
    }
};

#ifndef zftext
    #define zftext(s, ...) zfstring::shared(s, ##__VA_ARGS__)
#endif
 
ZF_NAMESPACE_GLOBAL_END
 
#endif // #ifndef _ZFI_zfstring_h_