dwstring.cpp.svn-base

来自「ffshow源码」· SVN-BASE 代码 · 共 2,010 行 · 第 1/4 页

{
    assert(aBuf != 0);
    if (aBuf != 0) {
        _replace(mLength, 0, aBuf, aLen);
    }
    return *this;
}


template<class tchar> DwString<tchar>& DwString<tchar>::append(const tchar* aCstr)
{
    assert(aCstr != 0);
    size_t len = (aCstr) ? strlen(aCstr) : 0;
    _replace(mLength, 0, aCstr, len);
    return *this;
}


template<class tchar> DwString<tchar>& DwString<tchar>::append(size_t aLen, tchar aChar)
{
    _replace(mLength, 0, aLen, aChar);
    return *this;
}


template<class tchar> DwString<tchar>& DwString<tchar>::assign(const DwString<tchar>& aStr)
{
    if (this != &aStr) {
        assign(aStr, 0, aStr.mLength);
    }
    return *this;
}


template<class tchar> DwString<tchar>& DwString<tchar>::assign(const DwString<tchar>& aStr, size_t aPos, size_t aLen)
{
    assert(aPos <= aStr.mLength);
    size_t pos = std::min(aPos, aStr.mLength);
    size_t len = std::min(aLen, aStr.mLength - pos);
    if (mRep == aStr.mRep) {
        mStart = aStr.mStart + pos;
        mLength = len;
    }
    else {
        delete_rep_safely(mRep);
        mRep = new_rep_reference(aStr.mRep);
        mStart = aStr.mStart + pos;
        mLength = len;
    }
    return *this;
}


template<class tchar> DwString<tchar>& DwString<tchar>::assign(const tchar* aBuf, size_t aLen)
{
    assert(aBuf != 0);
    assert(aLen != (size_t)-1);
    _replace(0, mLength, aBuf, aLen);
    return *this;
}


template<class tchar> DwString<tchar>& DwString<tchar>::assign(const tchar* aCstr)
{
    assert(aCstr != 0);
    size_t len = (aCstr) ? strlen(aCstr) : 0;
    _replace(0, mLength, aCstr, len);
    return *this;
}


template<class tchar> DwString<tchar>& DwString<tchar>::assign(size_t aLen, tchar aChar)
{
    assert(aLen != (size_t)-1);
    _replace(0, mLength, aLen, aChar);
    return *this;
}


template<class tchar> DwString<tchar>& DwString<tchar>::insert(size_t aPos, const DwString<tchar>& aStr)
{
    return insert(aPos, aStr, 0, aStr.mLength);
}


template<class tchar> DwString<tchar>& DwString<tchar>::insert(size_t aPos1, const DwString<tchar>& aStr, size_t aPos2, size_t aLen2)
{
    assert(aPos1 <= mLength);
    assert(aPos2 <= aStr.mLength);
    size_t pos2 = std::min(aPos2, aStr.mLength);
    size_t len2 = std::min(aLen2, aStr.mLength - pos2);
    if (&aStr == this) {
        DwString<tchar> temp(aStr);
        _replace(aPos1, 0, &temp.mRep->mBuffer[temp.mStart+pos2], len2);
    }
    else {
        _replace(aPos1, 0, &aStr.mRep->mBuffer[aStr.mStart+pos2], len2);
    }
    return *this;
}


template<class tchar> DwString<tchar>& DwString<tchar>::insert(size_t aPos, const tchar* aBuf, size_t aLen)
{
    assert(aBuf != 0);
    _replace(aPos, 0, aBuf, aLen);
    return *this;
}


template<class tchar> DwString<tchar>& DwString<tchar>::insert(size_t aPos, const tchar* aCstr)
{
    assert(aCstr != 0);
    size_t len = (aCstr) ? strlen(aCstr) : 0;
    _replace(aPos, 0, aCstr, len);
    return *this;
}


template<class tchar> DwString<tchar>& DwString<tchar>::insert(size_t aPos, size_t aLen, tchar aChar)
{
    _replace(aPos, 0, aLen, aChar);
    return *this;
}


template<class tchar> DwString<tchar>& DwString<tchar>::erase(size_t aPos, size_t aLen)
{
    assert(aPos <= mLength);
    size_t pos = std::min(aPos, mLength);
    size_t len = std::min(aLen, mLength - pos);
    _replace(pos, len, _L(""), 0);
    return *this;
}


template<class tchar> DwString<tchar>& DwString<tchar>::replace(size_t aPos1, size_t aLen1, const DwString<tchar>& aStr)
{
    return replace(aPos1, aLen1, aStr, 0, aStr.mLength);
}


template<class tchar> DwString<tchar>& DwString<tchar>::replace(size_t aPos1, size_t aLen1, const DwString<tchar>& aStr, size_t aPos2, size_t aLen2)
{
    assert(aPos2 <= aStr.mLength);
    size_t pos2 = std::min(aPos2, aStr.mLength);
    size_t len2 = std::min(aLen2, aStr.mLength - pos2);
    if (&aStr == this) {
        DwString<tchar> temp(aStr);
        _replace(aPos1, aLen1, &temp.mRep->mBuffer[temp.mStart+pos2], len2);
    }
    else {
        _replace(aPos1, aLen1, &aStr.mRep->mBuffer[aStr.mStart+pos2], len2);
    }
    return *this;
}


template<class tchar> DwString<tchar>& DwString<tchar>::replace(size_t aPos1, size_t aLen1, const tchar* aBuf, size_t aLen2)
{
    _replace(aPos1, aLen1, aBuf, aLen2);
    return *this;
}


template<class tchar> DwString<tchar>& DwString<tchar>::replace(size_t aPos1, size_t aLen1, const tchar* aCstr)
{
    size_t len2 = (aCstr) ? strlen(aCstr) : 0;
    _replace(aPos1, aLen1, aCstr, len2);
    return *this;
}


template<class tchar> DwString<tchar>& DwString<tchar>::replace(size_t aPos1, size_t aLen1, size_t aLen2, tchar aChar)
{
    _replace(aPos1, aLen1, aLen2, aChar);
    return *this;
}


template<class tchar> size_t DwString<tchar>::copy(tchar* aBuf, size_t aLen, size_t aPos) const
{
    assert(aPos <= mLength);
    assert(aBuf != 0);
    size_t pos = std::min(aPos, mLength);
    size_t len = std::min(aLen, mLength - pos);
    tchar* to = aBuf;
    const tchar* from = mRep->mBuffer + mStart + pos;
    mem_copy(from, len, to);
    return len;
}


template<class tchar> void DwString<tchar>::swap(DwString<tchar>& aStr)
{
    DwStringRep<tchar>* rep = mRep;
    mRep = aStr.mRep;
    aStr.mRep = rep;
    size_t n = mStart;
    mStart = aStr.mStart;
    aStr.mStart = n;
    n = mLength;
    mLength = aStr.mLength;
    aStr.mLength = n;
}


template<class tchar> size_t DwString<tchar>::find(const DwString<tchar>& aStr, size_t aPos) const
{
    return find(&aStr.mRep->mBuffer[aStr.mStart], aPos, aStr.mLength);
}


template<class tchar> size_t DwString<tchar>::find(const tchar* aBuf, size_t aPos, size_t aLen) const
{
    assert(aBuf != 0);
    if (aBuf == 0) return (size_t)-1;
    if (aLen > mLength) return (size_t)-1;
    if (aPos > mLength-aLen) return (size_t)-1;
    if (aLen == 0) return aPos;
    const tchar* buf = mRep->mBuffer + mStart;
    for (size_t i=aPos; i <= mLength-aLen; ++i) {
        size_t k = i;
        size_t j = 0;
        while (j < aLen && aBuf[j] == buf[k]) {
            ++j; ++k;
        }
        if (j == aLen) return i;
    }
    return (size_t)-1;
}


template<class tchar> size_t DwString<tchar>::find(const tchar* aCstr, size_t aPos) const
{
    assert(aCstr != 0);
    if (aCstr == 0) return (size_t)-1;
    size_t len = strlen(aCstr);
    return find(aCstr, aPos, len);
}


template<class tchar> size_t DwString<tchar>::find(tchar aChar, size_t aPos) const
{
    if (aPos >= mLength) return (size_t)-1;
    const tchar* buf = mRep->mBuffer + mStart;
    for (size_t i=aPos; i < mLength; ++i) {
        if (buf[i] == aChar) return i;
    }
    return (size_t)-1;
}


template<class tchar> size_t DwString<tchar>::rfind(const DwString<tchar>& aStr, size_t aPos) const
{
    return rfind(&aStr.mRep->mBuffer[aStr.mStart], aPos, aStr.mLength);
}


template<class tchar> size_t DwString<tchar>::rfind(const tchar* aBuf, size_t aPos, size_t aLen) const
{
    assert(aBuf != 0);
    if (aBuf == 0) return (size_t)-1;
    if (aLen > mLength) return (size_t)-1;
    size_t pos = std::min(aPos, mLength - aLen);
    if (aLen == 0) return pos;
    const tchar* buf = mRep->mBuffer + mStart;
    for (size_t i=0; i <= pos; ++i) {
        size_t k = pos - i;
        size_t j = 0;
        while (j < aLen && aBuf[j] == buf[k]) {
            ++j; ++k;
        }
        if (j == aLen) return pos - i;
    }
    return (size_t)-1;
}


template<class tchar> size_t DwString<tchar>::rfind(const tchar* aCstr, size_t aPos) const
{
    assert(aCstr != 0);
    size_t len = (aCstr) ? strlen(aCstr) : 0;
    return rfind(aCstr, aPos, len);
}


template<class tchar> size_t DwString<tchar>::rfind(tchar aChar, size_t aPos) const
{
    size_t pos = std::min(aPos, mLength - 1);
    const tchar* buf = mRep->mBuffer + mStart;
    for (size_t i=0; i <= pos; ++i) {
        size_t k = pos - i;
        if (buf[k] == aChar) return k;
    }
    return (size_t)-1;
}


template<class tchar> size_t DwString<tchar>::find_first_of(const DwString<tchar>& aStr, size_t aPos) const
{
    return find_first_of(&aStr.mRep->mBuffer[aStr.mStart], aPos, aStr.mLength);
}


template<class tchar> size_t DwString<tchar>::find_first_of(const tchar* aBuf, size_t aPos, size_t aLen) const
{
    assert(aBuf != 0);
    if (aBuf == 0) return (size_t)-1;
    if (aPos >= mLength) return (size_t)-1;
    if (aLen == 0) return aPos;
    tchar table[256];
    memset(table, 0, sizeof(table));
    for (size_t j=0; j < aLen; ++j) {
        table[aBuf[j]&0xff] = 1;
    }
    const tchar* buf = mRep->mBuffer + mStart;
    for (size_t i=aPos; i < mLength; ++i) {
        if (table[buf[i]&0xff]) return i;
    }
    return (size_t)-1;
}


template<class tchar> size_t DwString<tchar>::find_first_of(const tchar* aCstr, size_t aPos) const
{
    assert(aCstr != 0);
    if (aCstr == 0) return (size_t)-1;
    size_t len = strlen(aCstr);
    return find_first_of(aCstr, aPos, len);
}


template<class tchar> size_t DwString<tchar>::find_last_of(const DwString<tchar>& aStr, size_t aPos) const
{
    return find_last_of(&aStr.mRep->mBuffer[aStr.mStart], aPos, aStr.mLength);
}


template<class tchar> size_t DwString<tchar>::find_last_of(const tchar* aBuf, size_t aPos, size_t aLen) const
{
    assert(aBuf != 0);
    if (aBuf == 0) return (size_t)-1;
    if (mLength == 0) return (size_t)-1;
    size_t pos = std::min(aPos, mLength - 1);
    if (aLen == 0) return pos;
    tchar table[256];
    memset(table, 0, sizeof(table));
    for (size_t j=0; j < aLen; ++j) {
        table[aBuf[j]&0xff] = 1;
    }
    const tchar* buf = mRep->mBuffer + mStart;
    for (size_t k=0; k <= pos; ++k) {
        size_t i = pos - k;
        if (table[buf[i]&0xff]) return i;
    }
    return (size_t)-1;
}


template<class tchar> size_t DwString<tchar>::find_last_of(const tchar* aCstr, size_t aPos) const
{
    assert(aCstr != 0);
    if (aCstr == 0) return (size_t)-1;
    size_t len = strlen(aCstr);
    return find_last_of(aCstr, aPos, len);
}


template<class tchar> size_t DwString<tchar>::find_first_not_of(const DwString<tchar>& aStr, size_t aPos) const
{
    return find_first_not_of(&aStr.mRep->mBuffer[aStr.mStart], aPos, aStr.mLength);
}


template<class tchar> size_t DwString<tchar>::find_first_not_of(const tchar* aBuf, size_t aPos, size_t aLen) const
{
    assert(aBuf != 0);
    if (aBuf == 0) return (size_t)-1;
    if (aPos >= mLength) return (size_t)-1;
    if (aLen == 0) return (size_t)-1;
    tchar table[256];
    memset(table, 1, sizeof(table));
    for (size_t j=0; j < aLen; ++j) {
        table[aBuf[j]&0xff] = 0;
    }
    const tchar* buf = mRep->mBuffer + mStart;
    for (size_t i=aPos; i < mLength; ++i) {
        if (table[buf[i]&0xff]) return i;
    }
    return (size_t)-1;
}


template<class tchar> size_t DwString<tchar>::find_first_not_of(const tchar* aCstr, size_t aPos) const
{
    assert(aCstr != 0);
    if (aCstr == 0) return (size_t)-1;
    size_t len = strlen(aCstr);
    return find_first_not_of(aCstr, aPos, len);
}


template<class tchar> size_t DwString<tchar>::find_last_not_of(const DwString<tchar>& aStr, size_t aPos) const
{
    return find_last_not_of(&aStr.mRep->mBuffer[aStr.mStart], aPos, aStr.mLength);
}


template<class tchar> size_t DwString<tchar>::find_last_not_of(const tchar* aBuf, size_t aPos, size_t aLen) const
{
    assert(aBuf != 0);
    if (aBuf == 0) return (size_t)-1;
    if (mLength == 0) return (size_t)-1;
    size_t pos = std::min(aPos, mLength - 1);
    if (aLen == 0) return (size_t)-1;
    tchar table[256];
    memset(table, 1, sizeof(table));
    for (size_t j=0; j < aLen; ++j) {
        table[aBuf[j]&0xff] = 0;
    }
    const tchar* buf = mRep->mBuffer + mStart;
    for (size_t k=0; k <= pos; ++k) {
        size_t i = pos - k;
        if (table[buf[i]&0xff]) return i;
    }
    return (size_t)-1;
}


template<class tchar> size_t DwString<tchar>::find_last_not_of(const tchar* aCstr, size_t aPos) const
{
    assert(aCstr != 0);
    if (aCstr == 0) return (size_t)-1;
    size_t len = strlen(aCstr);
    return find_last_not_of(aCstr, aPos, len);
}


template<class tchar> DwString<tchar> DwString<tchar>::substr(size_t aPos, size_t aLen) const
{
    assert(aPos <= mLength);
    size_t pos = std::min(aPos, mLength);
    size_t len = std::min(aLen, mLength - pos);
    return DwString<tchar>(*this, pos, len);
}


template<class tchar> int DwString<tchar>::compare(const DwString<tchar>& aStr) const
{
    return compare(0, mLength, aStr, 0, aStr.mLength);
}


template<class tchar> int DwString<tchar>::compare(size_t aPos1, size_t aLen1, const DwString<tchar>& aStr) const
{
    return compare(aPos1, aLen1, aStr, 0, aStr.mLength);
}


template<class tchar> int DwString<tchar>::compare(size_t aPos1, size_t aLen1, const DwString<tchar>& aStr,
        size_t aPos2, size_t aLen2) const
{
    assert(aPos1 <= mLength);
    assert(aPos2 <= aStr.mLength);
    size_t pos1 = std::min(aPos1, mLength);
    const tchar* buf1 = mRep->mBuffer + mStart + pos1;
    size_t len1 = std::min(aLen1, mLength - pos1);
    size_t pos2 = std::min(aPos2, aStr.mLength);
    const tchar* buf2 = aStr.mRep->mBuffer + aStr.mStart + pos2;
    size_t len2 = std::min(aLen2, aStr.mLength - pos2);
    size_t len = std::min(len1, len2);
    int r = strncmp(buf1, buf2, len);
    if (r == 0) {
        if (len1 < len2)
            r = -1;
        else if (len1 > len2) {
            r = 1;
        }
    }
    return r;
}


template<class tchar> int DwString<tchar>::compare(const tchar* aCstr) const
{
    assert(aCstr != 0);
    size_t len = (aCstr) ? strlen(aCstr) : 0;
    return compare(0, mLength, aCstr, len);
}


template<class tchar> int DwString<tchar>::compare(size_t aPos1, size_t aLen1, const tchar* aBuf, size_t aLen2) const
{
    assert(aBuf != 0);
    assert(aPos1 <= mLength);
    if (aBuf == 0) {
        return (aLen1 > 0) ? 1 : 0;
    }
    size_t pos1 = std::min(aPos1, mLength);
    const tchar* buf1 = mRep->mBuffer + mStart + pos1;
    size_t len1 = std::min(aLen1, mLength - pos1);
    const tchar* buf2 = aBuf;