Struct inout::InOutBufReserved

pub struct InOutBufReserved<'inp, 'out, T> {
    in_ptr: *const T,
    out_ptr: *mut T,
    in_len: usize,
    out_len: usize,
    _pd: PhantomData<(&'inp T, &'out mut T)>,
}

Custom slice type which references one immutable (input) slice and one mutable (output) slice. Input and output slices are either the same or do not overlap. Length of the output slice is always equal or bigger than length of the input slice.

Fields

in_ptr: *const T

out_ptr: *mut T

in_len: usize

out_len: usize

_pd: PhantomData<(&'inp T, &'out mut T)>

Implementations

impl<'a, T> InOutBufReserved<'a, 'a, T>

pub fn from_mut_slice( buf: &'a mut [T], msg_len: usize, ) -> Result<Self, OutIsTooSmallError>

Crate InOutBufReserved from a single mutable slice.

pub unsafe fn from_raw( in_ptr: *const T, in_len: usize, out_ptr: *mut T, out_len: usize, ) -> Self

Create InOutBufReserved from raw input and output pointers.

Safety

Behavior is undefined if any of the following conditions are violated:

• in_ptr must point to a properly initialized value of type T and must be valid for reads for in_len * mem::size_of::<T>() many bytes.
• out_ptr must point to a properly initialized value of type T and must be valid for both reads and writes for out_len * mem::size_of::<T>() many bytes.
• in_ptr and out_ptr must be either equal or non-overlapping.
• If in_ptr and out_ptr are equal, then the memory referenced by them must not be accessed through any other pointer (not derived from the return value) for the duration of lifetime ’a. Both read and write accesses are forbidden.
• If in_ptr and out_ptr are not equal, then the memory referenced by out_ptr must not be accessed through any other pointer (not derived from the return value) for the duration of lifetime ’a. Both read and write accesses are forbidden. The memory referenced by in_ptr must not be mutated for the duration of lifetime 'a, except inside an UnsafeCell.
• The total size in_len * mem::size_of::<T>() and out_len * mem::size_of::<T>() must be no larger than isize::MAX.

pub fn into_raw(self) -> (*const T, *mut T)

Get raw input and output pointers.

pub fn get_in_len(&self) -> usize

Get input buffer length.

pub fn get_out_len(&self) -> usize

Get output buffer length.

impl<'inp, 'out, T> InOutBufReserved<'inp, 'out, T>

pub fn from_slices( in_buf: &'inp [T], out_buf: &'out mut [T], ) -> Result<Self, OutIsTooSmallError>

Crate InOutBufReserved from two separate slices.

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

Get input slice.

pub fn get_out<'a>(&'a mut self) -> &'a mut [T]

Get output slice.

impl<'inp, 'out> InOutBufReserved<'inp, 'out, u8>

pub fn into_padded_blocks<P, BS>( self, ) -> Result<PaddedInOutBuf<'inp, 'out, BS>, PadError>

where P: Padding<BS>, BS: ArrayLength<u8>,

Transform buffer into PaddedInOutBuf using padding algorithm P.