feed()

void fl::net::http::ChunkedReader::feed

(

fl::span< const u8 >

data

)

Definition at line 20 of file chunked_encoding.cpp.hpp.

                                              {
    mBuffer.insert(mBuffer.end(), data.begin(), data.end());
 
    // Process buffer based on current state
    while (true) {
        switch (mState) {
        case READ_SIZE: {
            // Parse chunk size (hex) until CRLF
            if (parseChunkSize(mChunkSize)) {
                if (mChunkSize == 0) {
                    // Final chunk (size 0)
                    mState = STATE_FINAL;
                    return;
                } else {
                    // Start reading chunk data
                    mState = READ_DATA;
                    mBytesRead = 0;
                }
            } else {
                // Not enough data to parse size
                return;
            }
            break;
        }
        case READ_DATA: {
            // Read chunk data (mChunkSize bytes)
            size_t remaining = mChunkSize;
            size_t available = mBuffer.size();
            if (available >= remaining) {
                // Complete chunk data available, save to mCurrentChunk
                mCurrentChunk.clear();
                mCurrentChunk.reserve(remaining);
                for (size_t i = 0; i < remaining; i++) {
                    mCurrentChunk.push_back(mBuffer[i]);
                }
                consume(remaining);
                mState = READ_TRAILER;
            } else {
                // Not enough data yet
                return;
            }
            break;
        }
        case READ_TRAILER: {
            // Read trailing CRLF
            if (hasCRLF()) {
                consume(2);  // Consume CRLF
                // Chunk is now complete, add to mChunks
                mChunks.push_back(mCurrentChunk);
                mCurrentChunk.clear();
                mState = READ_SIZE;
            } else {
                // Not enough data for CRLF
                return;
            }
            break;
        }
        case STATE_FINAL:
            // No more processing
            return;
        }
    }
}

References fl::available(), fl::span< T, Extent >::begin(), consume(), fl::span< T, Extent >::end(), hasCRLF(), mBuffer, mBytesRead, mChunks, mChunkSize, mCurrentChunk, mState, parseChunkSize(), READ_DATA, READ_SIZE, READ_TRAILER, and STATE_FINAL.

Here is the call graph for this function: