libafl::inputs

Trait ResizableMutator

Source 
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>;
}
Expand description

Contains resizable bytes

Required Methods§

Source

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.

Source

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

Source

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

Source

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", so this trait is not object safe.

Implementations on Foreign Types§

Source§

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

Source§

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

Source§

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

Source§

fn splice<R, I>(&mut self, range: R, replace_with: I) -> Splice<'_, I::IntoIter>
where R: RangeBounds<usize>, I: IntoIterator<Item = u8>,

Source§

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

Source§

impl<T> ResizableMutator<T> for Vec<T>
where T: Copy + 'static,

Source§

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

Source§

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

Source§

fn splice<R, I>(&mut self, range: R, replace_with: I) -> Splice<'_, I::IntoIter>
where R: RangeBounds<usize>, I: IntoIterator<Item = T>,

Source§

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

Implementors§