Trait Buffer 

pub trait Buffer {
    // Required methods
    fn len(&self) -> usize;
    fn as_ptr(&self) -> *const u8;
    fn as_mut_ptr(&mut self) -> *mut u8;
    fn as_slice(&self) -> &[u8] ;
    fn as_mut_slice(&mut self) -> &mut [u8] ;

    // Provided methods
    fn eob(&self) -> *const u8 { ... }
    fn as_ptr_range(&self) -> Range<*const u8> { ... }
    fn as_mut_ptr_range(&mut self) -> Range<*mut u8> { ... }
    fn is_empty(&self) -> bool { ... }
    fn validate_ptr(&self, ptr: *const u8) -> bool { ... }
    fn offset_to_ptr(&self, offset: usize) -> Result<*const u8, Error> { ... }
    fn offset_to_mut_ptr(&mut self, offset: usize) -> Result<*mut u8, Error> { ... }
    fn ptr_to_offset(&self, ptr: *const u8) -> Result<usize, Error> { ... }
    fn ref_to_offset<T>(&self, data: &T) -> Result<usize, Error> { ... }
    fn slice_ref_to_offset<T>(&self, data: &[T]) -> Result<usize, Error> { ... }
    fn to_vec(&self) -> Vec<u8>  { ... }
    fn swap(&mut self, a: usize, b: usize) { ... }
    fn reverse(&mut self) { ... }
    fn iter(&self) -> BufferIter<'_>  { ... }
    fn iter_mut(&mut self) -> BufferIterMut<'_>  { ... }
    fn save<P: AsRef<Path>>(&self, filename: P) -> Result<(), Error> { ... }
    fn get<I: SliceIndex<[u8]>>(&self, index: I) -> Option<&I::Output> { ... }
    fn get_mut<I: SliceIndex<[u8]>>(
        &mut self,
        index: I,
    ) -> Option<&mut I::Output> { ... }
    fn get_ref<T: Castable>(&self, offset: usize) -> Result<&T, Error> { ... }
    unsafe fn get_ref_unaligned<T>(&self, offset: usize) -> Result<&T, Error> { ... }
    unsafe fn force_get_ref<T: Castable>(
        &self,
        offset: usize,
    ) -> Result<&T, Error> { ... }
    fn get_mut_ref<T: Castable>(
        &mut self,
        offset: usize,
    ) -> Result<&mut T, Error> { ... }
    unsafe fn get_mut_ref_unaligned<T>(
        &mut self,
        offset: usize,
    ) -> Result<&mut T, Error> { ... }
    unsafe fn force_get_mut_ref<T: Castable>(
        &mut self,
        offset: usize,
    ) -> Result<&mut T, Error> { ... }
    fn make_mut_ref<T: Castable>(&mut self, data: &T) -> Result<&mut T, Error> { ... }
    unsafe fn make_mut_ref_unaligned<T>(
        &mut self,
        data: &T,
    ) -> Result<&mut T, Error> { ... }
    unsafe fn force_make_mut_ref<T: Castable>(
        &mut self,
        data: &T,
    ) -> Result<&mut T, Error> { ... }
    fn get_slice_ref<T: Castable>(
        &self,
        offset: usize,
        size: usize,
    ) -> Result<&[T], Error> { ... }
    unsafe fn get_slice_ref_unaligned<T>(
        &self,
        offset: usize,
        size: usize,
    ) -> Result<&[T], Error> { ... }
    unsafe fn force_get_slice_ref<T: Castable>(
        &self,
        offset: usize,
        size: usize,
    ) -> Result<&[T], Error> { ... }
    fn get_mut_slice_ref<T: Castable>(
        &mut self,
        offset: usize,
        size: usize,
    ) -> Result<&mut [T], Error> { ... }
    unsafe fn get_mut_slice_ref_unaligned<T>(
        &mut self,
        offset: usize,
        size: usize,
    ) -> Result<&mut [T], Error> { ... }
    unsafe fn force_get_mut_slice_ref<T: Castable>(
        &mut self,
        offset: usize,
        size: usize,
    ) -> Result<&mut [T], Error> { ... }
    fn make_mut_slice_ref<T: Castable>(
        &mut self,
        data: &[T],
    ) -> Result<&mut [T], Error> { ... }
    unsafe fn make_mut_slice_ref_unaligned<T>(
        &mut self,
        data: &[T],
    ) -> Result<&mut [T], Error> { ... }
    unsafe fn force_make_mut_slice_ref<T: Castable>(
        &mut self,
        data: &[T],
    ) -> Result<&mut [T], Error> { ... }
    fn read(&self, offset: usize, size: usize) -> Result<&[u8], Error> { ... }
    fn read_mut(
        &mut self,
        offset: usize,
        size: usize,
    ) -> Result<&mut [u8], Error> { ... }
    fn write<B: AsRef<[u8]>>(
        &mut self,
        offset: usize,
        data: B,
    ) -> Result<(), Error> { ... }
    fn write_ref<T: Castable>(
        &mut self,
        offset: usize,
        data: &T,
    ) -> Result<(), Error> { ... }
    fn write_slice_ref<T: Castable>(
        &mut self,
        offset: usize,
        data: &[T],
    ) -> Result<(), Error> { ... }
    fn start_with<B: AsRef<[u8]>>(&mut self, data: B) -> Result<(), Error> { ... }
    fn start_with_ref<T: Castable>(&mut self, data: &T) -> Result<(), Error> { ... }
    fn start_with_slice_ref<T: Castable>(
        &mut self,
        data: &[T],
    ) -> Result<(), Error> { ... }
    fn end_with<B: AsRef<[u8]>>(&mut self, data: B) -> Result<(), Error> { ... }
    fn end_with_ref<T: Castable>(&mut self, data: &T) -> Result<(), Error> { ... }
    fn end_with_slice_ref<T: Castable>(
        &mut self,
        data: &[T],
    ) -> Result<(), Error> { ... }
    fn search<B: AsRef<[u8]>>(&self, data: B) -> Result<BufferSearchIter, Error> { ... }
    fn search_ref<T: Castable>(
        &self,
        data: &T,
    ) -> Result<BufferSearchIter, Error> { ... }
    fn search_slice_ref<T: Castable>(
        &self,
        data: &[T],
    ) -> Result<BufferSearchIter, Error> { ... }
    fn search_dynamic<'a, B: AsRef<[Option<u8>]>>(
        &'a self,
        data: B,
    ) -> Result<BufferSearchDynamicIter<'a>, Error> { ... }
    fn contains<B: AsRef<[u8]>>(&self, data: B) -> bool { ... }
    fn contains_ref<T: Castable>(&self, data: &T) -> Result<bool, Error> { ... }
    fn contains_slice_ref<T: Castable>(&self, data: &[T]) -> Result<bool, Error> { ... }
    fn starts_with<B: AsRef<[u8]>>(&self, needle: B) -> bool { ... }
    fn ends_with<B: AsRef<[u8]>>(&self, needle: B) -> bool { ... }
    fn rotate_left(&mut self, mid: usize) { ... }
    fn rotate_right(&mut self, mid: usize) { ... }
    fn fill(&mut self, value: u8) { ... }
    fn fill_with<F>(&mut self, f: F)
       where F: FnMut() -> u8 { ... }
    fn clone_from_data<B: AsRef<[u8]>>(&mut self, src: B) { ... }
    fn copy_from_data<B: AsRef<[u8]>>(&mut self, src: B) { ... }
    fn copy_within<R>(&mut self, src: R, dest: usize)
       where R: RangeBounds<usize> { ... }
    fn swap_with_data<B: AsMut<[u8]>>(&mut self, other: B) { ... }
    fn is_ascii(&self) -> bool { ... }
    fn eq_ignore_ascii_case(&self, other: &[u8]) -> bool { ... }
    fn make_ascii_uppercase(&mut self) { ... }
    fn make_ascii_lowercase(&mut self) { ... }
    fn sort(&mut self) { ... }
    fn sort_by<F>(&mut self, compare: F)
       where F: FnMut(&u8, &u8) -> Ordering { ... }
    fn sort_by_key<K, F>(&mut self, f: F)
       where F: FnMut(&u8) -> K,
             K: Ord { ... }
    fn repeat(&self, n: usize) -> Vec<u8>  { ... }
}

The trait by which all buffer objects are derived.

Required Methods

fn len(&self) -> usize

Get the length of this Buffer object.

fn as_ptr(&self) -> *const u8

Get the Buffer object as a pointer.

fn as_mut_ptr(&mut self) -> *mut u8

Get the Buffer object as a mutable pointer.

fn as_slice(&self) -> &[u8]

Get the Buffer object as a slice.

fn as_mut_slice(&mut self) -> &mut [u8]

Get the Buffer object as a mutable slice.

Provided Methods

fn eob(&self) -> *const u8

Get a pointer to the end of the buffer.

Note that this pointer is not safe to use because it points at the very end of the buffer, which contains no data. It is merely a reference pointer for calculations such as boundaries and size.

fn as_ptr_range(&self) -> Range<*const u8>

Get a pointer range of this buffer. See slice::as_ptr_range for more details.

fn as_mut_ptr_range(&mut self) -> Range<*mut u8>

Get a mutable pointer range of this buffer. See slice::as_mut_ptr_range for more details.

fn is_empty(&self) -> bool

Check whether or not this buffer is empty.

fn validate_ptr(&self, ptr: *const u8) -> bool

Validate that the given pointer object is within the range of this buffer.

fn offset_to_ptr(&self, offset: usize) -> Result<*const u8, Error>

Convert an offset to a u8 pointer.

Returns an Error::OutOfBounds error if the offset is out of bounds of the buffer.

fn offset_to_mut_ptr(&mut self, offset: usize) -> Result<*mut u8, Error>

Convert an offset to a mutable u8 pointer.

Returns an Error::OutOfBounds error if the offset is out of bounds of the buffer.

fn ptr_to_offset(&self, ptr: *const u8) -> Result<usize, Error>

Convert a pointer to an offset into the buffer.

Returns an Error::InvalidPointer error if the given pointer is not within the range of this buffer.

fn ref_to_offset<T>(&self, data: &T) -> Result<usize, Error>

Convert a given reference to an object into an offset into the buffer.

Returns an Error::InvalidPointer if this reference did not come from this buffer.

fn slice_ref_to_offset<T>(&self, data: &[T]) -> Result<usize, Error>

Convert a given slice reference to an offset into the buffer.

Returns an Error::InvalidPointer error if the slice reference did not originate from this buffer.

fn to_vec(&self) -> Vec<u8>

Convert this buffer to a u8 Vec object.

fn swap(&mut self, a: usize, b: usize)

Swap two bytes at the given offsets. This panics if the offsets are out of bounds. See slice::swap for more details.

fn reverse(&mut self)

Reverse the buffer. See slice::reverse for more details.

fn iter(&self) -> BufferIter<'_>

Return an iterator object (BufferIter) into the buffer.

fn iter_mut(&mut self) -> BufferIterMut<'_>

Return a mutable iterator object (BufferIterMut) into the buffer.

fn save<P: AsRef<Path>>(&self, filename: P) -> Result<(), Error>

Save this buffer to disk.

fn get<I: SliceIndex<[u8]>>(&self, index: I) -> Option<&I::Output>

Get the given byte or range of bytes from the buffer. See slice::get for more details.

fn get_mut<I: SliceIndex<[u8]>>(&mut self, index: I) -> Option<&mut I::Output>

Get the given byte or range of bytes from the buffer as mutable. See slice::get_mut for more details.

fn get_ref<T: Castable>(&self, offset: usize) -> Result<&T, Error>

Get a reference to a given object within the buffer. Typically the main interface by which objects are retrieved.

Returns an Error::OutOfBounds error if the offset or the object’s size plus the offset results in an out-of-bounds event.

Example

use hex;
use pkbuffer::{Buffer, VecBuffer};

let buffer = VecBuffer::from_data(&hex::decode("facebabedeadbeef").unwrap());

let dword = buffer.get_ref::<u32>(4);
assert!(dword.is_ok());
assert_eq!(*dword.unwrap(), 0xEFBEADDE);

unsafe fn get_ref_unaligned<T>(&self, offset: usize) -> Result<&T, Error>

Get a reference to a given object within the buffer, but in an unaligned way.

Because of the way this function acquires a new reference, the Castable trait is unnecessary. Returns an Error::OutOfBounds error if the offset or the object’s size plus the offset results in an out-of-bounds event.

Safety

This is an unsafe function because it gets a reference that is not aligned to a proper boundary, which can trigger undefined behavior on some processors. If you’re unsure of the alignment situation on your target processor, or unsure of the alignment situation in your data, it’s best to use Buffer::get_ref instead.

unsafe fn force_get_ref<T: Castable>(&self, offset: usize) -> Result<&T, Error>

Get a reference regardless of potential alignment issues.

It is not recommended you use this function if you’re unaware of the alignment situation of your processor or data. See Buffer::get_ref_unaligned for more details.

fn get_mut_ref<T: Castable>(&mut self, offset: usize) -> Result<&mut T, Error>

Get a mutable reference to a given object within the buffer. See Buffer::get_ref.

unsafe fn get_mut_ref_unaligned<T>( &mut self, offset: usize, ) -> Result<&mut T, Error>

Get a mutable reference to a given object within the buffer, but in an unaligned way.

Because of the way this function acquires a new reference, the Castable trait is unnecessary. Returns an Error::OutOfBounds error if the offset or the object’s size plus the offset results in an out-of-bounds event.

Safety

This is an unsafe function because it gets a reference that is not aligned to a proper boundary, which can trigger undefined behavior on some processors. If you’re unsure of the alignment situation on your target processor, or unsure of the alignment situation in your data, it’s best to use Buffer::get_mut_ref instead.

unsafe fn force_get_mut_ref<T: Castable>( &mut self, offset: usize, ) -> Result<&mut T, Error>

Get a mutable reference regardless of potential alignment issues.

It is not recommended you use this function if you’re unaware of the alignment situation of your processor or data. See Buffer::get_mut_ref_unaligned for more details.

fn make_mut_ref<T: Castable>(&mut self, data: &T) -> Result<&mut T, Error>

Convert a given reference to a mutable reference within the buffer.

Returns an Error::InvalidPointer error if the reference did not originate from this buffer.

unsafe fn make_mut_ref_unaligned<T>( &mut self, data: &T, ) -> Result<&mut T, Error>

Convert a given reference to a mutable reference without alignment guarantees.

You should not do this unless you know your alignment situation. See Buffer::get_mut_ref_unaligned for an explanation as to why.

unsafe fn force_make_mut_ref<T: Castable>( &mut self, data: &T, ) -> Result<&mut T, Error>

Convert an object to a mutable reference regardless of potential alignment issues.

You should not do this unless you know your alignment situation. See Buffer::make_mut_ref_unaligned for an explanation as to why.

fn get_slice_ref<T: Castable>( &self, offset: usize, size: usize, ) -> Result<&[T], Error>

Gets a slice reference of type T at the given offset with the given size.

Returns an Error::OutOfBounds error if the offset or the offset plus its size goes out of bounds of the buffer and returns Error::BadAlignment if the acquired slice is not aligned on the alignment boundary required by type T.

Example

use hex;
use pkbuffer::{Buffer, VecBuffer};

let buffer = VecBuffer::from_data(&hex::decode("f00dbeef1deadead").unwrap());

let slice = buffer.get_slice_ref::<u16>(0, 4);
assert!(slice.is_ok());
assert_eq!(slice.unwrap(), [0x0DF0, 0xEFBE, 0xEA1D, 0xADDE]);

unsafe fn get_slice_ref_unaligned<T>( &self, offset: usize, size: usize, ) -> Result<&[T], Error>

Gets a slice ref of type T at the given offset regardless of potential alignment issues.

Returns an Error::OutOfBounds error if the offset or the offset plus its size go out of bounds of the buffer.

Safety

This is an unsafe function because it gets a slice reference that is not aligned to a proper boundary, which can trigger undefined behavior on some processors. If you’re unsure of the alignment situation on your target processor, or unsure of the alignment situation in your data, it’s best to use Buffer::get_slice_ref instead.

unsafe fn force_get_slice_ref<T: Castable>( &self, offset: usize, size: usize, ) -> Result<&[T], Error>

Get a slice reference regardless of potential alignment issues.

It is not recommended you use this function if you’re unaware of the alignment situation of your processor or data. See Buffer::get_slice_ref_unaligned for more details.

fn get_mut_slice_ref<T: Castable>( &mut self, offset: usize, size: usize, ) -> Result<&mut [T], Error>

Gets a mutable slice reference of type T at the given offset with the given size. See Buffer::get_slice_ref.

unsafe fn get_mut_slice_ref_unaligned<T>( &mut self, offset: usize, size: usize, ) -> Result<&mut [T], Error>

Gets a mutable slice reference of type T at the given offset with the given size, but without alignment checking. See Buffer::get_slice_ref_unaligned.

unsafe fn force_get_mut_slice_ref<T: Castable>( &mut self, offset: usize, size: usize, ) -> Result<&mut [T], Error>

Get a mutable slice reference regardless of potential alignment issues.

It is not recommended you use this function if you’re unaware of the alignment situation of your processor or data. See Buffer::get_slice_ref_unaligned for more details.

fn make_mut_slice_ref<T: Castable>( &mut self, data: &[T], ) -> Result<&mut [T], Error>

Convert a given slice reference to a mutable slice reference within the buffer.

Returns an Error::InvalidPointer error if the reference did not originate from this buffer.

unsafe fn make_mut_slice_ref_unaligned<T>( &mut self, data: &[T], ) -> Result<&mut [T], Error>

Convert a given slice reference to a mutable slice reference without alignment guarantees.

You should not do this unless you know your alignment situation. See Buffer::get_slice_ref_unaligned for an explanation as to why.

unsafe fn force_make_mut_slice_ref<T: Castable>( &mut self, data: &[T], ) -> Result<&mut [T], Error>

Convert an object to a mutable reference regardless of potential alignment issues.

You should not do this unless you know your alignment situation. See Buffer::get_slice_ref_unaligned for an explanation as to why.

fn read(&self, offset: usize, size: usize) -> Result<&[u8], Error>

Read an arbitrary size amount of bytes from the given offset.

Returns an Error::OutOfBounds error if the read runs out of boundaries.

fn read_mut(&mut self, offset: usize, size: usize) -> Result<&mut [u8], Error>

Read an arbitrary size amount of bytes from the given offset, but mutable.

Returns an Error::OutOfBounds error if the read runs out of boundaries.

fn write<B: AsRef<[u8]>>(&mut self, offset: usize, data: B) -> Result<(), Error>

Write an arbitrary u8 slice to the given offset.

Returns an Error::OutOfBounds error if the write runs out of boundaries of the buffer.

fn write_ref<T: Castable>( &mut self, offset: usize, data: &T, ) -> Result<(), Error>

Write a given object of type T to the given buffer at the given offset.

Returns an Error::OutOfBounds error if the write runs out of boundaries.

fn write_slice_ref<T: Castable>( &mut self, offset: usize, data: &[T], ) -> Result<(), Error>

Write a given slice object of type T to the given buffer at the given offset.

Returns an Error::OutOfBounds error if the write runs out of boundaries.

fn start_with<B: AsRef<[u8]>>(&mut self, data: B) -> Result<(), Error>

Start the buffer object with the given byte data.

Returns an Error::OutOfBounds error if the write runs out of boundaries.

fn start_with_ref<T: Castable>(&mut self, data: &T) -> Result<(), Error>

Start the buffer with the given reference data.

Returns an Error::OutOfBounds error if the write runs out of boundaries.

fn start_with_slice_ref<T: Castable>(&mut self, data: &[T]) -> Result<(), Error>

Start the buffer with the given slice reference data.

Returns an Error::OutOfBounds error if the write runs out of boundaries.

fn end_with<B: AsRef<[u8]>>(&mut self, data: B) -> Result<(), Error>

End the buffer object with the given byte data.

Returns an Error::OutOfBounds error if the write runs out of boundaries.

fn end_with_ref<T: Castable>(&mut self, data: &T) -> Result<(), Error>

End the buffer with the given reference data.

Returns an Error::OutOfBounds error if the write runs out of boundaries.

fn end_with_slice_ref<T: Castable>(&mut self, data: &[T]) -> Result<(), Error>

End the buffer with the given slice reference data.

Returns an Error::OutOfBounds error if the write runs out of boundaries.

fn search<B: AsRef<[u8]>>(&self, data: B) -> Result<BufferSearchIter, Error>

Search for the given u8 slice data within the given buffer.

On success, this returns an iterator to all found offsets which match the given search term. Typically, the error returned is an Error::OutOfBounds error, when the search term exceeds the size of the buffer.

Example

use hex;
use pkbuffer::{Buffer, VecBuffer};

let buffer = VecBuffer::from_data(&hex::decode("beefbeefb33fbeefbeef").unwrap());
let search = buffer.search(&[0xBE, 0xEF]);
assert!(search.is_ok());

let mut results = search.unwrap();
assert_eq!(results.next().unwrap(), 0);
assert_eq!(results.next().unwrap(), 2);
assert_eq!(results.next().unwrap(), 6);
assert_eq!(results.next().unwrap(), 8);
assert!(results.next().is_none());

// alternatively, you can snatch up the search results into a Vec
let search_results = buffer.search(&[0xBE, 0xEF]).unwrap().collect::<Vec<usize>>();
assert_eq!(search_results, [0,2,6,8]);

fn search_ref<T: Castable>(&self, data: &T) -> Result<BufferSearchIter, Error>

Search for the following reference of type T. This converts the object into a u8 slice. See Buffer::search.

fn search_slice_ref<T: Castable>( &self, data: &[T], ) -> Result<BufferSearchIter, Error>

Search for the following slice reference of type T. This converts the slice into a u8 slice. See Buffer::search.

fn search_dynamic<'a, B: AsRef<[Option<u8>]>>( &'a self, data: B, ) -> Result<BufferSearchDynamicIter<'a>, Error>

Return a search iterator for a dynamic byte pattern within the binary.

This function uses an Option<u8> wrapper to represent wildcards in the search terms. For example, a search term for a four-byte sequence wrapped in 0xFF, use this:

let search = vec![Some(0xFFu8), None, None, None, None, Some(0xFFu8)];

For more information about searching, see Buffer::search.

fn contains<B: AsRef<[u8]>>(&self, data: B) -> bool

Check if this buffer contains the following u8 slice sequence.

fn contains_ref<T: Castable>(&self, data: &T) -> Result<bool, Error>

Check if this buffer contains the following object of type T.

fn contains_slice_ref<T: Castable>(&self, data: &[T]) -> Result<bool, Error>

Check if this buffer contains the following slice of type T.

fn starts_with<B: AsRef<[u8]>>(&self, needle: B) -> bool

Check if this buffer starts with the byte sequence needle. See slice::starts_with.

fn ends_with<B: AsRef<[u8]>>(&self, needle: B) -> bool

Check if this buffer ends with the byte sequence needle. See slice::ends_with.

fn rotate_left(&mut self, mid: usize)

Rotate the buffer left at midpoint mid. See slice::rotate_left.

fn rotate_right(&mut self, mid: usize)

Rotate the buffer right at midpoint mid. See slice::rotate_right.

fn fill(&mut self, value: u8)

Fill the given buffer with the given value. See slice::fill.

fn fill_with<F>(&mut self, f: F)

where F: FnMut() -> u8,

Fill the given buffer with the given closure f. See slice::fill_with.

fn clone_from_data<B: AsRef<[u8]>>(&mut self, src: B)

Clone the given u8 slice data src into the given buffer.

fn copy_from_data<B: AsRef<[u8]>>(&mut self, src: B)

Copy the given u8 slice data src into the given buffer.

fn copy_within<R>(&mut self, src: R, dest: usize)

where R: RangeBounds<usize>,

Copy from within the given buffer. See slice::copy_within.

fn swap_with_data<B: AsMut<[u8]>>(&mut self, other: B)

Swap the data in this buffer with the given u8 slice reference.

fn is_ascii(&self) -> bool

Check if this buffer is ASCII. See slice::is_ascii.

fn eq_ignore_ascii_case(&self, other: &[u8]) -> bool

Check if this buffer is equal while ignoring case of letters. See slice::eq_ignore_ascii_case.

fn make_ascii_uppercase(&mut self)

Make this buffer ASCII uppercase. See slice::make_ascii_uppercase.

fn make_ascii_lowercase(&mut self)

Make this buffer ASCII lowercase. See slice::make_ascii_lowercase.

fn sort(&mut self)

Sort this buffer. See slice::sort.

fn sort_by<F>(&mut self, compare: F)

where F: FnMut(&u8, &u8) -> Ordering,

Sort by the given closure comparing each individual byte. See slice::sort_by.

fn sort_by_key<K, F>(&mut self, f: F)

where F: FnMut(&u8) -> K, K: Ord,

Sorts the slice with a key extraction function. See slice::sort_by_key.

fn repeat(&self, n: usize) -> Vec<u8>

Creates a new Buffer object by repeating the current buffer n times. See slice::repeat.

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.

Implementors

impl Buffer for PtrBuffer

impl Buffer for VecBuffer