Struct ResHandle 

pub struct ResHandle<R = Resource> {
    node: NodeId,
    strong: Arc<()>,
    kind: PhantomData<fn() -> R>,
}

Handle to a resource stored in a ResourceGraph, typed by its kind.

R is the ResourceKind the id names, which is also what the graph hands back for it: a ResHandle<wgpu::Buffer> resolves to a buffer, a ResHandle<wgpu::TextureView> to a view. The default, Resource, is the erased kind — an id to a resource whose kind is known only at runtime — which is what graph-wide reads like ResourceGraph::dependencies hand out.

An id names a strong reference to its resource: cloning one takes another reference, dropping one gives it up, and ResourceGraph::maintain collects the resource once the last reference is gone. That is what makes an id safe to hold — the resource it names outlives every id to it, and a caller that drops its last id lets the graph free the resource without any further call.

An id therefore resolves for as long as the caller holds it: the graph never collects a resource some id still names. Letting go of the last id is the only way to give a resource up, and it takes effect at the next ResourceGraph::maintain.

An id is not Copy: cloning one adds a reference, which a copy could not tell apart from a move. Pass one to a graph method by reference.

Fields

node: NodeId

strong: Arc<()>

The strong reference this id carries. Its liveness is the token’s own reference count.

kind: PhantomData<fn() -> R>

Implementations

impl<R> ResHandle<R>

pub fn index(&self) -> usize

The graph index this id refers to.

Only meaningful while the resource lives, but stable across the resource’s lifetime: callers can group or sort by it (ordering draws so consecutive ones share a bind group, for example) without holding a borrow. The index alone does not identify the resource across a removal and reuse of its slot; ResHandle::id does.

pub fn id(&self) -> ResId

The resource’s ResId, for an API that stores ids but does not know the type — an inspector that reports one, or a transport that carries it.

The id names the resource but holds no reference to it, so it is Copy. Resolve it back through the graph with ResourceGraph::resolve, which reports None once the slot has been recycled.

pub fn erase(&self) -> ResHandle

Forget the kind, yielding an id to the same resource that claims none.

This is how a typed id is handed to an API that works in any kind — the erased ResHandle<Resource> that ResourceGraph::dependencies speaks in, or a stored field a caller only ever passes back to the graph. The kind is the only thing that changes: a strong id stays strong through the call, so the erased id names the same reference and both ids keep the resource alive.

impl<R> ResHandle<R>

fn shared<K>(&self) -> ResHandle<K>

A second id to the same resource, taking one more strong reference to it.

The new id may name any kind: the node is what both ids resolve through, and the kind only says which accessor fits. Both Clone and Self::erase go through here so that a new id always counts, whichever way it was made.

Trait Implementations

impl<R> Clone for ResHandle<R>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<R> Debug for ResHandle<R>

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

Formats the value using the given formatter.

impl<R> Eq for ResHandle<R>

impl<R> Hash for ResHandle<R>

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<R> Ord for ResHandle<R>

fn cmp(&self, other: &Self) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

fn clamp_to<R>(self, range: R) -> Self

where Self: Sized, R: ClampBounds<Self>,

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

Restrict a value to a certain range.

impl<R> PartialEq for ResHandle<R>

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

Equality operator ==.

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

Inequality operator !=.

impl<R> PartialOrd for ResHandle<R>

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.