Struct SubSlice

pub struct SubSlice<'a, T> { /* private fields */ }

An immutable leasable buffer implementation.

A leasable buffer can be used to pass a section of a larger mutable buffer but still get the entire buffer back in a callback.

Implementations

impl<'a, T> SubSlice<'a, T>

pub fn new(buffer: &'a [T]) -> Self

Create a SubSlice from a passed reference to a raw buffer.

pub fn take(self) -> &'a [T]

Retrieve the raw buffer used to create the SubSlice. Consumes the SubSlice.

pub fn reset(&mut self)

Resets the SubSlice to its full size, making the entire buffer accessible again.

This should only be called by layer that created the SubSlice, and not layers that were passed a SubSlice. Layers which are using a SubSlice should treat the SubSlice as a traditional Rust slice and not consider any additional size to the underlying buffer.

Most commonly, this is called once a sliced leasable buffer is returned through a callback.

pub fn len(&self) -> usize

Returns the length of the currently accessible portion of the SubSlice.

pub fn as_ptr(&self) -> *const T

Returns a pointer to the currently accessible portion of the SubSlice.

pub fn as_slice(&self) -> &[T]

Returns a slice of the currently accessible portion of the LeasableBuffer.

pub fn is_sliced(&self) -> bool

Returns true if the LeasableBuffer is sliced internally.

This is a useful check when switching between code that uses LeasableBuffers and code that uses traditional slice-and-length. Since slice-and-length only supports using the entire buffer it is not valid to try to use a sliced LeasableBuffer.

pub fn slice<R: RangeBounds<usize>>(&mut self, range: R)

Reduces the range of the SubSlice that is accessible.

This should be called whenever a layer wishes to pass only a portion of a larger buffer to another layer.

For example, if the application layer has a 1500 byte packet buffer, but wishes to send a 250 byte packet, the upper layer should slice the SubSlice down to its first 250 bytes before passing it down:

let buffer = unsafe {
   core::slice::from_raw_parts(core::ptr::addr_of!(_ptr_in_flash), 1500)
};
let s = SubSlice::new(buffer);
s.slice(0..250);
network.send(s);

Trait Implementations

impl<'a, T: Debug> Debug for SubSlice<'a, T>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'a, T> From<&'a [T]> for SubSlice<'a, T>

fn from(internal: &'a [T]) -> Self

Converts to this type from the input type.

impl<T, I> Index<I> for SubSlice<'_, T>

where I: SliceIndex<[T]>,

type Output = <I as SliceIndex<[T]>>::Output

The returned type after indexing.

fn index(&self, idx: I) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<'a, T: PartialEq> PartialEq for SubSlice<'a, T>

fn eq(&self, other: &SubSlice<'a, T>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a, T> StructuralPartialEq for SubSlice<'a, T>