Struct abi::bbqueue_ipc::bbbuffer::SplitGrantR

pub struct SplitGrantR<'a> {
    pub(crate) buf1: &'a mut [u8],
    pub(crate) buf2: &'a mut [u8],
    bbq: NonNull<BBBuffer>,
    pub(crate) to_release: usize,
}

A structure representing up to two contiguous regions of memory that may be read from, and potentially “released” (or cleared) from the queue

Fields

buf1: &'a mut [u8]

buf2: &'a mut [u8]

bbq: NonNull<BBBuffer>

to_release: usize

Implementations

impl<'a> SplitGrantR<'a>

pub fn release(self, used: usize)

Release a sequence of bytes from the buffer, allowing the space to be used by later writes. This consumes the grant.

If used is larger than the given grant, the full grant will be released.

NOTE: If the thumbv6 feature is selected, this function takes a short critical section while releasing.

pub fn bufs(&self) -> (&[u8], &[u8])

Obtain access to both inner buffers for reading

use bbqueue::BBBuffer;

// Create and split a new buffer of 6 elements
let buffer: BBBuffer<6> = BBBuffer::new();
let (mut prod, mut cons) = buffer.try_split().unwrap();

// Successfully obtain and commit a grant of four bytes
let mut grant = prod.grant_max_remaining(4).unwrap();
grant.buf().copy_from_slice(&[1, 2, 3, 4]);
grant.commit(4);

// Obtain a read grant, and copy to a buffer
let mut grant = cons.read().unwrap();
let mut buf = [0u8; 4];
buf.copy_from_slice(grant.buf());
assert_eq!(&buf, &[1, 2, 3, 4]);

pub fn bufs_mut(&mut self) -> (&mut [u8], &mut [u8])

Obtain mutable access to both parts of the read grant

This is useful if you are performing in-place operations on an incoming packet, such as decryption

pub(crate) fn release_inner(&mut self, used: usize)

pub fn to_release(&mut self, amt: usize)

Configures the amount of bytes to be released on drop.

pub fn combined_len(&self) -> usize

The combined length of both buffers

Trait Implementations

impl<'a> Debug for SplitGrantR<'a>

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

Formats the value using the given formatter.

impl<'a> Drop for SplitGrantR<'a>

fn drop(&mut self)

Executes the destructor for this type.

impl<'a> PartialEq<SplitGrantR<'a>> for SplitGrantR<'a>

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl<'a> Send for SplitGrantR<'a>

impl<'a> StructuralPartialEq for SplitGrantR<'a>