Struct Slice

pub struct Slice {
    pub index: u8,
    pub shared_state: SharedState,
    pub owned: Option<Vec<u8>>,
    /* private fields */
}

A contiguous block of memory, either preallocated or dynamically allocated.

It serves as a lightweight handle to a memory buffer, allowing for direct manipulation and shared access. It can either hold a reference to a preallocated memory block or own a dynamically allocated buffer (via Vec<u8>).

Fields

index: u8

Unique identifier (index) of the slice in the shared memory pool.

When in back or front mode, tracks the slice within the pool and manages memory reuse. It allows for quick identification of slices when freeing or reassigning memory. If in alloc mode, it is set to IGNORE_INDEX.

shared_state: SharedState

Shared state of the memory pool.

When in back or front mode, tracks how many slices are currently in use and ensures proper synchronization of memory access across multiple contexts.

owned: Option<Vec<u8>>

Optional dynamically allocated buffer.

If present, the slice owns the memory and is responsible for managing its lifecycle. If None, the buffer pool is in back or front mode and the slice points to memory managed by the memory pool. Is Some(Vec<u8>) when in alloc mode.

Implementations

impl Slice

pub fn len(&self) -> usize

Returns the length of the slice in bytes.

If the slice owns its memory (owned), it returns the length of the owned buffer. If the slice does not own the memory, it returns 0.

pub fn is_empty(&self) -> bool

Checks if the slice is empty.

Returns true if the slice is empty, i.e., it has no data. Otherwise, returns false.

Trait Implementations

impl AsMut<[u8]> for Slice

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

Converts the Slice into a mutable slice of bytes (&mut [u8]).

Returns the owned buffer if present, otherwise converts the raw pointer and length into a mutable slice.

impl AsRef<[u8]> for Slice

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

Converts the Slice into an immutable slice of bytes (&[u8]).

Returns the owned buffer if present, otherwise converts the raw pointer and length into an immutable slice.

impl Clone for Slice

fn clone(&self) -> Slice

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Slice

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

Formats the value using the given formatter.

impl Drop for Slice

fn drop(&mut self)

Toggles the shared state when the slice is dropped, allowing the memory to be reused.

In debug mode, it also tracks the mode of the slice when it is dropped.

impl From<Vec<u8>> for Slice

fn from(v: Vec<u8>) -> Self

Creates a Slice from a Vec<u8>, taking ownership of the vector.

Initializes the Slice with the vector’s pointer and sets the length to 0.

impl Index<Range<usize>> for Slice

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

Provides immutable slicing access to the specified range within the Slice.

Uses as_ref to get a reference to the underlying buffer and returns the specified range.

type Output = [u8]

The returned type after indexing.

impl Index<RangeFrom<usize>> for Slice

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

Provides immutable slicing access to a range starting from the given index.

Uses as_ref to get a reference to the underlying buffer and returns the range.

type Output = [u8]

The returned type after indexing.

impl Index<RangeFull> for Slice

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

Provides immutable access to the entire range of the Slice.

Uses as_ref to get a reference to the entire underlying buffer.

type Output = [u8]

The returned type after indexing.

impl Index<usize> for Slice

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

Provides immutable indexing access to the Slice at the specified position.

Uses as_ref to get a reference to the underlying buffer and returns the byte at the index.

type Output = u8

The returned type after indexing.

impl IndexMut<Range<usize>> for Slice

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

Provides mutable slicing access to the specified range within the Slice.

Uses as_mut to get a mutable reference to the underlying buffer and returns the specified range.

impl IndexMut<RangeFrom<usize>> for Slice

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

Provides mutable slicing access to a range starting from the given index.

Uses as_mut to get a mutable reference to the underlying buffer and returns the range.

impl IndexMut<usize> for Slice

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

Provides mutable indexing access to the Slice at the specified position.

Uses as_mut to get a mutable reference to the underlying buffer and returns the byte at the index.

impl Send for Slice

Allows Slice to be safely transferred between threads.

Slice contains a raw pointer (*mut u8), so Rust cannot automatically implement Send. The unsafe block asserts that memory access is thread-safe, relaying on SharedState and atomic operations to prevent data races.