Method repeat_slice_n_times

arrow-buffer/src/buffer/mutable.rs:311–372

Adding to this mutable buffer `slice_to_repeat` repeated `repeat_count` times. # Example ## Repeat the same string bytes multiple times ``` # use arrow_buffer::buffer::MutableBuffer; let mut buffer = MutableBuffer::new(0); let bytes_to_repeat = b"ab"; buffer.repeat_slice_n_times(bytes_to_repeat, 3); assert_eq!(buffer.as_slice(), b"ababab"); ``` # Panics Panics if the repeated slice byte length

(
        &mut self,
        slice_to_repeat: &[T],
        repeat_count: usize,
    )

    /// length overflows `usize`, or if reserving the required capacity fails for the same
    /// reasons as [`MutableBuffer::reserve`].
    pub fn repeat_slice_n_times<T: ArrowNativeType>(
        &mut self,
        slice_to_repeat: &[T],
        repeat_count: usize,
    ) {
        if repeat_count == 0 || slice_to_repeat.is_empty() {
            return;
        }

        let bytes_to_repeat = size_of_val(slice_to_repeat);
        let repeated_bytes = repeat_count
            .checked_mul(bytes_to_repeat)
            .expect("repeated slice byte length overflow");
        self.len
            .checked_add(repeated_bytes)
            .expect("mutable buffer length overflow");

        // Ensure capacity
        self.reserve(repeated_bytes);

        // Save the length before we do all the copies to know where to start from
        let length_before = self.len;

        // Copy the initial slice once so we can use doubling strategy on it
        self.extend_from_slice(slice_to_repeat);

        // This tracks how much bytes we have added by repeating so far
        let added_repeats_length = bytes_to_repeat;
        assert_eq!(
            self.len - length_before,
            added_repeats_length,
            "should copy exactly the same number of bytes"
        );

        // Number of times the slice was repeated
        let mut already_repeated_times = 1;

        // We will use doubling strategy to fill the buffer in log(repeat_count) steps
        while already_repeated_times < repeat_count {
            // How many slices can we copy in this iteration
            // (either double what we have, or just the remaining ones)
            let number_of_slices_to_copy =
                already_repeated_times.min(repeat_count - already_repeated_times);
            let number_of_bytes_to_copy = number_of_slices_to_copy * bytes_to_repeat;

            unsafe {
                // Get to the start of the data before we started copying anything
                let src = self.data.as_ptr().add(length_before) as *const u8;

                // Go to the current location to copy to (end of current data)
                let dst = self.data.as_ptr().add(self.len);

                // SAFETY: the pointers are not overlapping as there is `number_of_bytes_to_copy` or less between them
                std::ptr::copy_nonoverlapping(src, dst, number_of_bytes_to_copy)
            }

            // Advance the length by the amount of data we just copied (doubled)
            self.len += number_of_bytes_to_copy;