Struct Session 

pub struct Session<'a, T> { /* private fields */ }

Implementations

impl<'a, T: Copy> Session<'a, T>

pub fn next_slice(&mut self) -> SliceIndex

Create and return a new session key from the current session. This means the current session is now pointing to the end of the buffer.

pub fn insert(&mut self, pos: usize, value: T)

Insert a value into the buffer

pub fn last(&self) -> Option<&T>

Reference to the last value in the buffer, regardless of where the session is pointing.

pub fn push(&mut self, value: T)

Push a value to the buffer.

Panics

This will panic if there is no slice keys in the buffer. One can be created with self.next_slice()

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

Pop a value from the buffer. This is fine as a session is always referring to the end of the underlying buffer.

pub fn extend(&mut self, iter: impl IntoIterator<Item = T>)

Extend the buffer with the contents from the iterator

pub fn tail_drain(&mut self, size: u32)

Remove N elements from the end of the buffer

pub fn slice(&self, index: SliceIndex) -> &[T]

Get a slice of data from the underlying buffer

pub fn slice_mut(&mut self, index: SliceIndex) -> &mut [T]

Get a slice of mutable data from the underlying buffer

pub fn len(&self) -> u32

Length of the session buffer, not the total buffer

pub fn is_empty(&self) -> bool

It’s empty?

pub fn truncate(&mut self, key: SliceIndex, index: usize)

See Buffer::truncate

Trait Implementations

impl<'a, T: Debug> Debug for Session<'a, T>

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

Formats the value using the given formatter.

impl<'a, T: Copy> Index<usize> for Session<'a, T>

type Output = T

The returned type after indexing.

fn index(&self, index: usize) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<'a, T: Copy> IndexMut<usize> for Session<'a, T>

fn index_mut(&mut self, index: usize) -> &mut Self::Output

Performs the mutable indexing (container[index]) operation.