Trait ResizableMutator 

pub trait ResizableMutator<T> {
    // Required methods
    fn resize(&mut self, new_len: usize, value: T);
    fn extend<'a, I: IntoIterator<Item = &'a T>>(&mut self, iter: I)
       where T: 'a;
    fn splice<R, I>(
        &mut self,
        range: R,
        replace_with: I,
    ) -> Splice<'_, I::IntoIter> 
       where R: RangeBounds<usize>,
             I: IntoIterator<Item = T>;
    fn drain<R>(&mut self, range: R) -> Drain<'_, T> 
       where R: RangeBounds<usize>;
}

Contains resizable bytes

Required Methods

fn resize(&mut self, new_len: usize, value: T)

Resize the mutator content to a given new size. Use value to fill new slots in case the buffer grows. See Vec::splice.

fn extend<'a, I: IntoIterator<Item = &'a T>>(&mut self, iter: I)

where T: 'a,

Extends the given buffer with an iterator. See alloc::vec::Vec::extend

fn splice<R, I>(&mut self, range: R, replace_with: I) -> Splice<'_, I::IntoIter>

where R: RangeBounds<usize>, I: IntoIterator<Item = T>,

Splices the given target values according to Vec::splice’s rules

fn drain<R>(&mut self, range: R) -> Drain<'_, T>

where R: RangeBounds<usize>,

Drains the given target value according to Vec::drain’s rules

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementations on Foreign Types

impl ResizableMutator<u8> for &mut Vec<u8>

fn resize(&mut self, new_len: usize, value: u8)

fn extend<'b, I: IntoIterator<Item = &'b u8>>(&mut self, iter: I)

fn splice<R, I>(&mut self, range: R, replace_with: I) -> Splice<'_, I::IntoIter>

where R: RangeBounds<usize>, I: IntoIterator<Item = u8>,

fn drain<R>(&mut self, range: R) -> Drain<'_, u8>

where R: RangeBounds<usize>,

impl<T> ResizableMutator<T> for Vec<T>

where T: Copy + 'static,

fn resize(&mut self, new_len: usize, value: T)

fn extend<'a, I: IntoIterator<Item = &'a T>>(&mut self, iter: I)

fn splice<R, I>(&mut self, range: R, replace_with: I) -> Splice<'_, I::IntoIter>

where R: RangeBounds<usize>, I: IntoIterator<Item = T>,

fn drain<R>(&mut self, range: R) -> Drain<'_, T>

where R: RangeBounds<usize>,

Implementors

impl ResizableMutator<u8> for BytesInput

impl<I> ResizableMutator<u8> for BytesSubInput<'_, I>

where I: ResizableMutator<u8> + HasMutatorBytes + HasLen,