Struct FrameRef 

pub struct FrameRef<N: Node + ?Sized>(/* private fields */);

Reference to a VPP node frame

A &mut FrameRef corresponds to vlib_frame_t * in C.

Implementations

impl<N: Node + ?Sized> FrameRef<N>

pub unsafe fn from_ptr_mut<'a>(ptr: *mut vlib_frame_t) -> &'a mut Self

Creates a &mut FrameRef directly from a pointer

Safety

• The pointer must be valid and a properly initialised vlib_frame_t.
• The pointer must stay valid and the contents must not be mutated for the duration of the lifetime of the returned object.
• scalar_offset, vector_offset, and aux_offset must be set correctly to point to the valid, initialised data areas in the frame, and n_vectors must be set correctly to indicate the number of valid vector and aux elements.

pub fn as_ptr(&self) -> *mut vlib_frame_t

Returns the raw pointer to the underlying vlib_frame_t

pub fn vector(&self) -> &[N::Vector]

Returns the vector data elements in the frame as a slice

pub fn scalar(&self) -> &N::Scalar

Returns the scalar data in the frame

pub fn aux(&self) -> &[N::Aux]

Returns the auxiliary data elements in the frame as a slice

Note: the length of the returned slice is equal to the number of vectors in the frame.

impl<N, V> FrameRef<N>

where N: Node<Vector = V> + ?Sized, V: VectorBufferIndex,

pub unsafe fn get_buffers<'me, 'vm, 'buf: 'vm + 'me, const ARRAY_N: usize>( &'me self, vm: &'vm MainRef, to: &mut ArrayVec<&'buf mut BufferRef<N::FeatureData>, ARRAY_N>, ) -> &'me [N::Vector]

Get pointers to buffers for the given buffer indices, writing them into the provided to arrayvec.

This is similar to vlib_get_buffers in the C API.

Note that although it would be more idiomatic to return an ArrayVec directly, this method takes a mutable reference to an ArrayVec to avoid an unnecessary copy when returning.

Safety

• The caller must ensure that to has enough capacity to hold all the buffers corresponding to the indices in from_indices.
• Each buffer’s feature_arc_index and current_config_index must be consistent with the FeatureData type. If they are not known (i.e. because the caller the node isn’t being executed in a feature arc), FeatureData should be a zero-sized type such as ().
• Must not be called more than once without the framing being flushed in between as Rust’s reference aliasing rules will be violated.