swapWith()

void fl::basic_string::swapWith ( basic_string & other )

protected

Definition at line 1233 of file basic_string.cpp.hpp.

                                               {
    if (this == &other) return;
 
    bool thisInline = isInline();
    bool otherInline = other.isInline();
 
    if (!thisInline && !otherInline) {
        // Both non-inline: swap variant + length
        fl::swap(mStorage, other.mStorage);
        fl::swap(mLength, other.mLength);
    } else if (thisInline && otherInline) {
        // Both inline: check capacity before swapping
        bool thisFits = other.mLength + 1 <= mInlineCapacity;
        bool otherFits = mLength + 1 <= other.mInlineCapacity;
        if (thisFits && otherFits) {
            // Both fit: swap buffer contents directly
            fl::size maxLen = fl::max(mLength, other.mLength);
            for (fl::size i = 0; i <= maxLen; ++i) {
                char tmp = inlineBufferPtr()[i];
                inlineBufferPtr()[i] = other.inlineBufferPtr()[i];
                other.inlineBufferPtr()[i] = tmp;
            }
            fl::swap(mLength, other.mLength);
        } else {
            // Capacity mismatch: promote to heap where needed
            NotNullStringHolderPtr thisData(
                fl::make_shared<StringHolder>(inlineBufferPtr(), mLength));
            NotNullStringHolderPtr otherData(
                fl::make_shared<StringHolder>(other.inlineBufferPtr(), other.mLength));
            fl::size thisLen = mLength;
            fl::size otherLen = other.mLength;
            if (thisFits) {
                mStorage.reset();
                fl::memcpy(inlineBufferPtr(), otherData->data(), otherLen + 1);
            } else {
                mStorage = otherData;
            }
            mLength = otherLen;
            if (otherFits) {
                other.mStorage.reset();
                fl::memcpy(other.inlineBufferPtr(), thisData->data(), thisLen + 1);
            } else {
                other.mStorage = thisData;
            }
            other.mLength = thisLen;
        }
    } else if (thisInline) {
        // this inline, other non-inline
        fl::size thisLen = mLength;
        // Take other's non-inline storage
        mStorage = fl::move(other.mStorage);
        mLength = other.mLength;
        // Put this's old inline data into other
        other.mStorage.reset();
        if (thisLen + 1 <= other.mInlineCapacity) {
            fl::memcpy(other.inlineBufferPtr(), inlineBufferPtr(), thisLen + 1);
        } else {
            other.mStorage = NotNullStringHolderPtr(
                fl::make_shared<StringHolder>(inlineBufferPtr(), thisLen));
        }
        other.mLength = thisLen;
    } else {
        // this non-inline, other inline — reverse
        other.swapWith(*this);
    }
}

References basic_string(), inlineBufferPtr(), isInline(), fl::make_shared(), fl::max(), fl::memcpy(), mInlineCapacity, mLength, fl::fl::move(), mStorage, fl::fl::swap(), and swapWith().

Referenced by operator=(), and swapWith().

Here is the call graph for this function:

Here is the caller graph for this function: