Struct FfiBuffer

#[repr(C)]
pub struct FfiBuffer<'a> {
    pub data: *mut u8,
    pub data_len: usize,
    /* private fields */
}

A Rust u8 mutable slice, but compatible with FFI. Assume the lifetime is only valid until the callee returns to the caller.

Fields

data: *mut u8

A pointer to where the data can be put

data_len: usize

The maximum number of bytes we can store in this buffer

Implementations

impl<'a> FfiBuffer<'a>

pub fn new(s: &'a mut [u8]) -> FfiBuffer<'a>

Create a new buffer we can send over the FFI.

This buffer is a mutable borrow of some storage space allocated elsewhere. If you are given this type in an API, assume it is only valid for as long as the function call you were given in it.

pub fn empty() -> FfiBuffer<'static>

Make an empty slice.

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

Turn this buffer into a Rust byte slice.

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

Turn this buffer into a Rust mutable byte slice.

You will get None if the buffer is empty (i.e. has zero length).

Trait Implementations

impl<'a> Clone for FfiBuffer<'a>

fn clone(&self) -> FfiBuffer<'a>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for FfiBuffer<'_>

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

Formats the value using the given formatter.

impl<'a> From<&'a mut [u8]> for FfiBuffer<'a>

fn from(input: &'a mut [u8]) -> FfiBuffer<'a>

Convert from a Rust byte slice into an FFI compatible byte slice

impl<'a> Ord for FfiBuffer<'a>

fn cmp(&self, rhs: &FfiBuffer<'a>) -> Ordering

Compare two ApiBuffers.

We just make some actual slices and compare then.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl<'a> PartialEq for FfiBuffer<'a>

fn eq(&self, rhs: &FfiBuffer<'a>) -> bool

Check if two ApiBuffers are equal.

We just make some actual slices and compare then.

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> PartialOrd for FfiBuffer<'a>

fn partial_cmp(&self, rhs: &FfiBuffer<'a>) -> Option<Ordering>

Compare two ApiBuffers.

We are Ord so we can defer to that.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<'a> Eq for FfiBuffer<'a>