Struct SharedAllocationController 

pub struct SharedAllocationController { /* private fields */ }

Allocation controller that shares a view into another Bytes behind an Arc.

The shared content is lazily copied into a private buffer on first mutable access (copy-on-write), behind a Once so the private buffer is materialized exactly once.

Trait Implementations

impl AllocationController for SharedAllocationController

fn alloc_align(&self) -> usize

The alignment this allocation was created with.

fn property(&self) -> AllocationProperty

Returns memory property for the current allocation.

fn capacity(&self) -> usize

The total byte capacity of the allocation, WITHOUT materializing lazy storage.

fn memory( &self, policy: AccessPolicy, ) -> Result<&[MaybeUninit<u8>], AccessError>

Returns a view of the memory of the whole allocation, subject to policy.

unsafe fn memory_mut( &mut self, policy: AccessPolicy, ) -> Result<&mut [MaybeUninit<u8>], AccessError>

Returns a mutable view of the memory of the whole allocation, subject to policy.

fn split( &mut self, offset: usize, ) -> Result<(Box<dyn AllocationController>, Box<dyn AllocationController>), SplitError>

Splits the current allocation in multiple separate allocations.

fn view( &self, start: usize, end: usize, ) -> Option<Box<dyn AllocationController>>

Returns a zero-copy controller over the sub-range [start, end) of this allocation when the backend supports cheap sub-views (files and shared buffers), borrowing &self. Returns None otherwise.

fn duplicate(&self) -> Option<Box<dyn AllocationController>>

Duplicates the current allocation with a clone on write strategy if the allocation controller supports it.

unsafe fn copy_into(&self, buf: &mut [u8])

Reads the data from the current allocation controller and copy its content into the provided buffer.

fn grow(&mut self, size: usize, align: usize) -> Result<(), AllocationError>

Extends the provided Allocation to a new size with specified alignment.

fn try_detach(&mut self) -> Option<NonNull<u8>>

Indicates whether the allocation uses the Rust alloc crate and can be safely managed by another data structure.