Enum DataAccess 

#[non_exhaustive]
pub enum DataAccess {
    HostReadable,
    MappableToHost,
    Opaque,
}

What host-access is available for a frame’s pixel data.

This is the finer-grained companion to Residency. Where Residency says where the data lives, DataAccess says how a CPU consumer can (or cannot) obtain host bytes.

Retrieve via FrameEnvelope::data_access().

Canonical usage

match frame.data_access() {
    DataAccess::HostReadable => {
        let bytes = frame.host_data().unwrap();
    }
    DataAccess::MappableToHost => {
        let pixels = frame.require_host_data()?;
    }
    DataAccess::Opaque => {
        let handle = frame.accelerated_handle::<MyAccelBuf>();
    }
    _ => { /* forward-compatible: handle additional access classes */ }
}

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

HostReadable

Host-readable bytes are directly available (zero-copy borrow).

MappableToHost

Device-resident, but host materialization is available.

The first call to FrameEnvelope::require_host_data() invokes the backend materializer and caches the result in the frame’s Arc-shared inner state. Subsequent calls return a zero-copy borrow of the cached bytes.

Opaque

Opaque accelerated data; no host view is guaranteed.

FrameEnvelope::require_host_data() returns FrameAccessError::NotHostAccessible.

Trait Implementations

impl Clone for DataAccess

fn clone(&self) -> DataAccess

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for DataAccess

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

Formats the value using the given formatter.

impl Hash for DataAccess

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for DataAccess

fn eq(&self, other: &DataAccess) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Copy for DataAccess

impl Eq for DataAccess

impl StructuralPartialEq for DataAccess