Struct Handle

pub struct Handle<D: Send + Sync>(/* private fields */);

Represents a resource handle.

The resource stays in memory as long as a handle clone is alive. After the handle is dropped the resource will be removed after an indeterminate time at the discretion of the resource manager.

You can forget a handle by calling perm, this releases the handle memory but the resource stays alive for the duration of the app, unlike calling std::mem::forget no memory is leaked.

Any handle can also force_drop, meaning that even if there are various handles active the resource will be dropped regardless.

The parameter type D is any Sync data type that will be shared using the handle.

Implementations

impl<D: Send + Sync> Handle<D>

pub fn new(data: D) -> (HandleOwner<D>, Handle<D>)

Create a handle with owner pair.

pub fn dummy(data: D) -> Self

Create a handle to nothing, the handle always in the dropped state.

Note that Option<Handle<D>> takes up the same space as Handle<D> and avoids an allocation.

pub fn data(&self) -> &D

Reference the attached data.

pub fn perm(self)

Mark the handle as permanent and drops this clone of it. This causes the resource to stay in memory until the app exits, no need to hold a handle somewhere.

pub fn is_permanent(&self) -> bool

If perm was called in another clone of this handle.

If true the resource will stay in memory for the duration of the app, unless force_drop is also called.

pub fn force_drop(self)

Force drops the handle, meaning the resource will be dropped even if there are other handles active.

pub fn is_dropped(&self) -> bool

If the handle is in dropped state.

The handle is considered dropped when all handle and clones are dropped or when force_drop was called in any of the clones.

Note that in this method it can only be because force_drop was called.

pub fn downgrade(&self) -> WeakHandle<D>

Create a WeakHandle to this handle.

Trait Implementations

impl<D: Send + Sync> Clone for Handle<D>

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<D: Send + Sync> Debug for Handle<D>

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

Formats the value using the given formatter.

impl<D: Send + Sync> Drop for Handle<D>

fn drop(&mut self)

Executes the destructor for this type.

impl<D: Send + Sync> Hash for Handle<D>

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<D: Send + Sync> PartialEq for Handle<D>

fn eq(&self, other: &Self) -> 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<D: Send + Sync> Eq for Handle<D>