Method write_with_cursor

src/models/buffered_io.rs:321–404

(
        &self,
        cursor_id: u64,
        buf: &[u8],
        append: bool,
    )

    }

    fn write_with_cursor(
        &self,
        cursor_id: u64,
        buf: &[u8],
        append: bool,
    ) -> Result<u64, BufIoError> {
        let curr_pos = {
            let cursors = self.cursors.read().map_err(|_| BufIoError::Locking)?;
            let cursor = cursors
                .get(&cursor_id)
                .ok_or(BufIoError::InvalidCursor(cursor_id))?;
            cursor.position
        };

        let input_size = buf.len();

        // Take write lock early to cover the entire write operation that might affect file size
        let mut file_size_guard = self.file_size.write().map_err(|_| BufIoError::Locking)?;
        let will_cross_eof = append || curr_pos + input_size as u64 >= *file_size_guard;
        let mut curr_pos = if append {
            curr_pos.max(*file_size_guard)
        } else {
            curr_pos
        };
        let start_pos = curr_pos;

        if will_cross_eof {
            let mut total_written = 0;
            while total_written < input_size {
                let region = self.get_or_create_region(curr_pos)?;
                {
                    let mut buffer = region.buffer.write().map_err(|_| BufIoError::Locking)?;
                    let buffer_pos = (curr_pos - region.start) as usize;
                    let available = self.buffer_size - buffer_pos;
                    let to_write = (input_size - total_written).min(available);
                    buffer[buffer_pos..buffer_pos + to_write]
                        .copy_from_slice(&buf[total_written..total_written + to_write]);
                    region.end.store(
                        (buffer_pos + to_write).max(region.end.load(Ordering::SeqCst)),
                        Ordering::SeqCst,
                    );
                    region.dirty.store(true, Ordering::SeqCst);
                    total_written += to_write;
                    curr_pos += to_write as u64;
                }
            }
            // Update file size using max to prevent shrinking
            *file_size_guard = (*file_size_guard).max(curr_pos);
        } else {
            // Normal write within existing file bounds
            let mut total_written = 0;
            while total_written < input_size {
                let region = self.get_or_create_region(curr_pos)?;
                {
                    let mut buffer = region.buffer.write().map_err(|_| BufIoError::Locking)?;
                    let buffer_pos = (curr_pos - region.start) as usize;
                    let available = self.buffer_size - buffer_pos;
                    let to_write = (input_size - total_written).min(available);