Struct zengine_asset::Handle

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

A handle into a specific Asset of type T

Handles contain a unique id that corresponds to a specific asset in the Assets collection.

Accessing the Asset

A handle is not the asset itself, it’s mora like a pointer to the asset. To get the actual asset, you should use Assets::get or Assets::get_mut.

Strong and Weak

A handle can be either “Strong” or “Weak”. A Strong handles keep the asset loaded.

A Weak handles do not affect the loaded status of assets.

This is due to a type of_reference counting_. When the number of Strong handles that exist for any given asset reach zero, the asset is dropped and will be unloaded.

If you want a reference to an asset but don’t want to take the responsibility of keeping it loaded that comes with a Strong handle then you need a Weak handle.

Implementations

impl<T: Asset> Handle<T>

pub fn weak(id: HandleId) -> Self

Creates a weak handle for the Asset identified by id

pub fn get_id(&self) -> HandleId

Get the handle id

pub fn clone_as_weak(&self) -> Self

Clone the handle producing a weak one that point to the same asset

pub fn as_weak(&self) -> Self

Convert an handle to a weak one

pub fn is_strong(&self) -> bool

Checks if the handle is a strong one

pub fn is_weak(&self) -> bool

Checks if the handle is a weak one

pub fn make_strong(&mut self, assets: &Assets<T>)

Makes this handle Strong if it wasn’t already

This method requires the corresponding Assets storage

Trait Implementations

impl<T: Asset> Clone for Handle<T>

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for Handle<T>

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

Formats the value using the given formatter.

impl<T> Drop for Handle<T>

fn drop(&mut self)

Executes the destructor for this type.

impl<T: Asset> From<Handle<T>> for HandleId

fn from(value: Handle<T>) -> Self

Converts to this type from the input type.

impl<T: Asset> Hash for Handle<T>

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,

Feeds a slice of this type into the given Hasher.

impl<T: Asset> Ord for Handle<T>

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

This method returns an Ordering between self and other.

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

Compares and returns the maximum of two values.

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

Compares and returns the minimum of two values.

const fn clamp(self, min: Self, max: Self) -> Selfwhere
    Self: PartialOrd<Self>,

Restrict a value to a certain interval.

impl<T: Asset> PartialEq<Handle<T>> for Handle<T>

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl<T: Asset> PartialOrd<Handle<T>> for Handle<T>

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

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

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

This method tests less than (for self and other) and is used by the < operator.

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

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

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

This method tests greater than (for self and other) and is used by the > operator.

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

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

impl<T: Asset> Eq for Handle<T>