Struct OwnedWritableCapability 

pub struct OwnedWritableCapability<T> { /* private fields */ }

RAII wrapper around a WritableCapability<T> that owns the underlying Box<T> allocation and reclaims it on Drop.

Implementations

impl<T> OwnedWritableCapability<T>

pub fn new(value: T) -> Self

Heap-allocate value and wrap it in a writable capability.

pub fn from_box(b: Box<T>) -> Self

Wrap an existing Box<T>. Full Read + Write perms.

pub fn cap(&self) -> &WritableCapability<T>

pub fn cap_mut(&mut self) -> &mut WritableCapability<T>

pub fn into_box(self) -> Box<T>

Consume and reclaim the underlying Box.

Methods from Deref<Target = WritableCapability<T>>

pub const SIGNATURE: AxisMask

pub fn has_permission(&self, p: CapabilityPermission) -> bool

pub fn is_sealed(&self) -> bool

pub fn read(&self) -> Result<T, CapabilityError>

where T: Copy,

Read through the capability.

pub fn write(&mut self, value: T) -> Result<(), CapabilityError>

Write through the capability. The &mut self receiver + the constructor’s &mut [T] / Box-consuming nature provide the unique-writer guarantee.

pub fn narrow( &self, sub_base: usize, sub_length: u32, sub_perms: u32, ) -> Result<Self, CapabilityError>

Narrow to a sub-range, returning a new WritableCapability. To narrow to a read-only view, use narrow_readable.

pub fn narrow_readable( &self, sub_base: usize, sub_length: u32, sub_perms: u32, ) -> Result<ReadableCapability<T>, CapabilityError>

Narrow to a read-only view. Returned ReadableCapability does NOT have Write perm regardless of what sub_perms contains.

pub fn as_readable(&self) -> ReadableCapability<T>

Borrow this WritableCapability as a ReadableCapability view (no Write perm, no transfer of ownership). The borrow checker prevents the writable cap from being used while the readable view is alive.

Trait Implementations

impl<T> Deref for OwnedWritableCapability<T>

type Target = WritableCapability<T>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<T> DerefMut for OwnedWritableCapability<T>

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<T> Drop for OwnedWritableCapability<T>

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.