Compiler Explorer

Source code

use std::ops::RangeFrom;
use std::ptr;

trait VecExt<T> {
    fn repeat_tail(&mut self, r: RangeFrom<usize>, n: usize)
    where
        T: Copy;
}

impl<T> VecExt<T> for Vec<T> {
    fn repeat_tail(&mut self, r: RangeFrom<usize>, n: usize)
    where
        T: Copy,
    {
        assert!(r.start <= self.len());
        let RangeFrom { start: tail } = r;

let mut len = self.len();
        let extra_len = n
            .checked_mul(len - tail)
            .expect("length overflow");
        self.reserve(extra_len);
        let target_len = len + extra_len;

loop {
            let tail_len = len - tail;
            if target_len - len > tail_len {
                // duplicate the entire tail, making the tail longer
                // so we can potentally copy even more next time
                unsafe {
                    ptr::copy_nonoverlapping(
                        self.get_unchecked(tail),
                        self.get_unchecked_mut(len),
                        tail_len,
                    );
                    len += tail_len;
                }
            } else {
                // the tail is now big enough to copy all the rest at once
                // (this is also hit immediately for n==0 or tail==len)
                unsafe {
                    ptr::copy_nonoverlapping(
                        self.get_unchecked(tail),
                        self.get_unchecked_mut(len),
                        target_len - len,
                    );
                    self.set_len(target_len);
                }
                return;
            }
        }
    }
}

pub fn demo7(x: &mut Vec<u8>) {
    let last = x.len()-1;
    x.repeat_tail(last.., 127);
}