swap_impl()

void fl::vector_basic::swap_impl

(

vector_basic &

other

)

Swap contents with another vector_basic.

Definition at line 360 of file basic_vector.cpp.hpp.

                                                {
    // Swap all members. This works correctly even with inline buffers
    // because we swap the offset too, and the inline data stays in place.
    // HOWEVER: if either vector uses inline storage, we need to handle
    // it carefully since inline buffers can't be swapped by pointer.
 
    bool this_inline = isInline();
    bool other_inline = other.isInline();
 
    if (!this_inline && !other_inline) {
        // Both on heap: just swap pointers and metadata
        void* tmp_array = mArray;
        mArray = other.mArray;
        other.mArray = tmp_array;
 
        fl::size tmp_cap = mCapacity;
        mCapacity = other.mCapacity;
        other.mCapacity = tmp_cap;
    } else if (this_inline && other_inline) {
        // Both inline: swap element data in-place
        fl::size max_size = mSize > other.mSize ? mSize : other.mSize;
        for (fl::size i = 0; i < max_size; ++i) {
            if (i < mSize && i < other.mSize) {
                if (mOps) {
                    mOps->swap_elements(element_ptr(i), other.element_ptr(i));
                } else {
                    trivial_swap(element_ptr(i), other.element_ptr(i));
                }
            } else if (i < mSize) {
                // Move this[i] to other[i], destroy this[i]
                if (mOps) {
                    mOps->move_construct(other.element_ptr(i), element_ptr(i));
                    mOps->destroy(element_ptr(i));
                } else {
                    fl::memcpy(other.element_ptr(i), element_ptr(i), mElementSize);
                }
            } else {
                // Move other[i] to this[i], destroy other[i]
                if (mOps) {
                    mOps->move_construct(element_ptr(i), other.element_ptr(i));
                    mOps->destroy(other.element_ptr(i));
                } else {
                    fl::memcpy(element_ptr(i), other.element_ptr(i), mElementSize);
                }
            }
        }
    } else if (this_inline) {
        // this is inline, other is on heap
        // Move this's inline data to a temp, take other's heap pointer,
        // move temp data to other's inline buffer
        void* other_array = other.mArray;
        fl::size other_cap = other.mCapacity;
 
        // Move this's elements to other's inline buffer
        if (other.hasInlineBuffer() && mSize <= other.mInlineCapacity) {
            other.mArray = other.inlineBufferPtr();
            other.mCapacity = other.mInlineCapacity;
            if (mOps) {
                mOps->uninitialized_move_n(other.mArray, mArray, mSize);
                mOps->destroy_n(mArray, mSize);
            } else {
                if (mSize > 0) trivial_copy(other.mArray, mArray, mSize);
            }
        } else {
            // Other has no inline buffer or data doesn't fit - allocate heap
            other.mArray = other.mResource->allocate(mSize * mElementSize);
            other.mCapacity = mSize;
            if (mOps) {
                mOps->uninitialized_move_n(other.mArray, mArray, mSize);
                mOps->destroy_n(mArray, mSize);
            } else {
                if (mSize > 0) trivial_copy(other.mArray, mArray, mSize);
            }
        }
 
        // This takes other's heap pointer
        mArray = other_array;
        mCapacity = other_cap;
    } else {
        // other is inline, this is on heap - mirror of above
        other.swap_impl(*this);
        return;
    }
 
    // Swap sizes
    fl::size tmp_size = mSize;
    mSize = other.mSize;
    other.mSize = tmp_size;
 
    // Swap resources
    memory_resource* tmp_res = mResource;
    mResource = other.mResource;
    other.mResource = tmp_res;
}

References vector_basic(), fl::memory_resource::allocate(), element_ptr(), hasInlineBuffer(), inlineBufferPtr(), isInline(), mArray, mCapacity, mElementSize, fl::memcpy(), mInlineCapacity, mOps, mResource, mSize, swap_impl(), trivial_copy(), and trivial_swap().

Referenced by fl::vector< fl::i16 >::swap(), fl::vector< fl::i16 >::swap(), and swap_impl().

Here is the call graph for this function:

Here is the caller graph for this function: