Struct ethox::managed::Partial

pub struct Partial<C> { /* fields omitted */ }

Refer to a part of some container.

Useful to create a dynamically sized storage over a statically sized backing buffer. This covers both byte buffers, such as packets, or general type buffers to be used similar to a vector.

Usage

Use a slice as a backing storage, logically initializing it gradually. Contrary to Vec the methods push and pop return a mutable reference to their element after they have succeeded instead of operating on values. They only change the logical length when called.

let mut elements = [0; 16];
let mut storage = Partial::new(&mut elements[..]);

for el in 0..10 {
    // Note that this drops an instance. That may be undesired.
    *storage.push().unwrap() = el;
}

This is useful as a generic payload representation as well. Resizing it is as simple as setting the current length unless the request can not be fulfilled with the current buffer size. Only in that case will it resize the underlying buffer.

Methods

impl<C> Partial<C>

pub fn new(container: C) -> Self

Make an instance that initially refers to an empty part.

pub fn inner(&self) -> &C

Get a reference to the underlying buffer.

pub fn inner_mut(&mut self) -> &mut C

Get a mutable reference to the underlying buffer.

pub fn into_inner(self) -> C

Unwrap the inner buffer.

pub fn set_len_unchecked(&mut self, len: usize)

Set the length to which to refer.

This does not check that the underlying storage actually has the claimed length. Setting a wrong value will typically lead to panicking later on.

pub fn len(&self) -> usize

Get the claimed length.

Does not validate that a slice of the claimed length can actually be referred to.

pub fn is_empty(&self) -> bool

Check if the list is empty.

pub fn inc(&mut self)

Simply increase the length.

pub fn dec(&mut self)

Simply decrease the length.

impl<C, T> Partial<C> where
    C: Deref<Target = [T]>, 

pub fn new_full(inner: C) -> Self

Construct an instance referring to all of the inner container.

This sets the Partial's length based on the slice to which the container dereferences. If the containers impl of Deref is not consistent then some later calls may panic (but not this constructor).

pub fn capacity(&self) -> usize

Check how many elements can be referred to at most.

This results in the length of the underlying container, not its capacity since the Partial is not aware of reallocation or other behaviour to change the underlying containers length.

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

Get the logically active elements as a slice.

pub fn get<'a, I>(&'a self, idx: I) -> Option<&'a I::Output> where
    I: SliceIndex<[T]>,
    T: 'a, 

Retrieve the logical path of the underlying container if possible.

This is a non-panicking variant of index access.

impl<C, T> Partial<C> where
    C: Deref<Target = [T]> + DerefMut, 

pub fn init(&mut self) -> Option<&mut T>

Get a mutable reference to the element that would be pushed next.

pub fn insert_at(&mut self, pos: usize) -> Option<&mut T>

Insert the next element at some position.

Panics

This method panics if the pos is larger than the current length.

pub fn push(&mut self) -> Option<&mut T>

Insert behind the last element.

pub fn remove_at(&mut self, pos: usize) -> Option<&mut T>

Remove the element at a position.

pub fn pop(&mut self) -> Option<&mut T>

Remove the last element.

pub fn as_mut_slice(&mut self) -> &mut [T]

Get the logically active elements as a mutable slice.

pub fn get_mut<'a, I>(&'a mut self, idx: I) -> Option<&'a mut I::Output> where
    I: SliceIndex<[T]>,
    T: 'a, 

Retrieve the logical path of the underlying container if possible.

This is a non-panicking variant of index access.

Trait Implementations

impl<C, T> AsMut<[T]> for Partial<C> where
    C: AsMut<[T]>, 

fn as_mut(&mut self) -> &mut [T]

Performs the conversion.

impl<C, T> AsRef<[T]> for Partial<C> where
    C: AsRef<[T]>, 

fn as_ref(&self) -> &[T]

Performs the conversion.

impl<C: Clone> Clone for Partial<C>

fn clone(&self) -> Partial<C>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<C: Debug> Debug for Partial<C>

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

Formats the value using the given formatter.

impl<C, T> Deref for Partial<C> where
    C: Deref<Target = [T]>, 

type Target = [T]

The resulting type after dereferencing.

fn deref(&self) -> &[T]

Dereferences the value.

impl<C, T> DerefMut for Partial<C> where
    C: Deref<Target = [T]> + DerefMut, 

fn deref_mut(&mut self) -> &mut [T]

Mutably dereferences the value.

impl<C: Payload> Payload for Partial<C>

fn payload(&self) -> &payload

Get the bytes wrapped in the payload newtype.

impl<C: PayloadMut> PayloadMut for Partial<C>

fn payload_mut(&mut self) -> &mut payload

Retrieve the mutable, inner payload.

fn resize(&mut self, len: usize) -> Result<(), PayloadError>

Resize the payload.

fn reframe(&mut self, reframe: Reframe) -> Result<(), PayloadError>

Resize the payload while keeping some data.