write() [2/11]

fl::size fl::basic_string::write	(	const char *	str,
		fl::size	n )

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

                                                    {
    fl::size newLen = mLength + n;
 
    // Handle non-owning storage
    if (isNonOwning()) {
        const char* existingData = constData();
        fl::size existingLen = mLength;
        if (newLen + 1 <= mInlineCapacity) {
            if (existingLen > 0 && existingData) {
                fl::memcpy(inlineBufferPtr(), existingData, existingLen);
            }
            fl::memcpy(inlineBufferPtr() + existingLen, str, n);
            inlineBufferPtr()[newLen] = '\0';
            mStorage.reset();
            mLength = newLen;
        } else {
            NotNullStringHolderPtr newData = NotNullStringHolderPtr(fl::make_shared<StringHolder>(newLen));
            if (existingLen > 0 && existingData) {
                fl::memcpy(newData->data(), existingData, existingLen);
            }
            fl::memcpy(newData->data() + existingLen, str, n);
            newData->data()[newLen] = '\0';
            mStorage = newData;
            mLength = newLen;
        }
        return mLength;
    }
 
    if (hasHeapData() && heapData().get().use_count() <= 1) {
        NotNullStringHolderPtr& heap = heapData();
        if (!heap->hasCapacity(newLen)) {
            // Check if str points into our buffer (self-referential write).
            // grow() uses realloc which can relocate the buffer.
            const char* bufStart = heap->data();
            fl::size grow_length = fl::max(3, newLen * 3 / 2);
            if (str >= bufStart && str < bufStart + mLength + 1) {
                fl::size offset = static_cast<fl::size>(str - bufStart);
                heap->grow(grow_length);
                str = heap->data() + offset; // update to new location
            } else {
                heap->grow(grow_length);
            }
        }
        fl::memcpy(heap->data() + mLength, str, n);
        mLength = newLen;
        heap->data()[mLength] = '\0';
        return mLength;
    } else if (hasHeapData()) {
        // Copy-on-write
        NotNullStringHolderPtr newData = NotNullStringHolderPtr(fl::make_shared<StringHolder>(newLen));
        {
            const NotNullStringHolderPtr& heap = heapData();
            fl::memcpy(newData->data(), heap->data(), mLength);
            fl::memcpy(newData->data() + mLength, str, n);
            newData->data()[newLen] = '\0';
            mStorage = newData;
            mLength = newLen;
        }
        return mLength;
    }
    if (newLen + 1 <= mInlineCapacity) {
        FL_DISABLE_WARNING_PUSH
        FL_DISABLE_WARNING(array-bounds)
        fl::memcpy(inlineBufferPtr() + mLength, str, n);
        FL_DISABLE_WARNING_POP
        mLength = newLen;
        inlineBufferPtr()[mLength] = '\0';
        return mLength;
    }
    // Transition from inline to heap
    NotNullStringHolderPtr newData = NotNullStringHolderPtr(fl::make_shared<StringHolder>(newLen));
    {
        fl::memcpy(newData->data(), inlineBufferPtr(), mLength);
        fl::memcpy(newData->data() + mLength, str, n);
        newData->data()[newLen] = '\0';
        mStorage = newData;
        mLength = newLen;
    }
    return mLength;
}