Struct wlroots::utils::Handle

pub struct Handle<D: Clone, T, W: Handleable<D, T> + Sized> { /* fields omitted */ }

A non-owned reference counted handle to a resource.

The resource could be destroyed at any time, it depends on the resource.

For example an output is destroyed when it's physical output is "disconnected" on DRM. "disconnected" depends on the output (e.g. sometimes turning it off counts as "disconnected"). However, when the backend is instead headless an output lives until it is destroyed explicitly by the library user.

Some resources are completely controlled by the user. For example although you refer to a Seat with handles it is only destroyed when you call the special destroy method on the seat handle.

Please refer to the specific resource documentation for a description of the lifetime particular to that resource.

Methods

impl<D: Clone, T, W: Handleable<D, T>> Handle<D, T, W>

pub fn run<F, R>(&self, runner: F) -> HandleResult<R> where     F: FnOnce(&mut W) -> R,

Run a function with a reference to the resource if it's still alive.

Returns the result of the function, if successful.

Safety

By enforcing a rather harsh limit on the lifetime of the resource to a short lived scope of an anonymous function, this function ensures the resource does not live longer than it exists.

Panics

This function will panic if multiple mutable borrows are detected. This will happen if you call upgrade directly within this callback, or if a handle to the same resource was upgraded some where else up the stack.

pub fn is_alive(&self) -> bool

Determines if the handle is alive or not.

This does not check if it's already being borrowed.

pub fn is_borrowed(&self) -> bool

Determines if the handle is borrowed or not.

If the handle is not alive it will return false.

Trait Implementations

impl<D: Clone, T, W: Handleable<D, T>> Clone for Handle<D, T, W>

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<D: Clone, T, W: Handleable<D, T>> Eq for Handle<D, T, W>

impl<D: Default + Clone, T, W: Handleable<D, T>> Default for Handle<D, T, W>

fn default() -> Self

Constructs a new handle that is always invalid. Calling run on this will always fail.

This is useful for pre-filling a value before it's provided by the server, or for mocking/testing.

impl<D: Clone, T, W: Handleable<D, T>> PartialEq<Handle<D, T, W>> for Handle<D, T, W>

fn eq(&self, other: &Handle<D, T, W>) -> bool

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

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<D: Clone, T, W: Handleable<D, T>> Hash for Handle<D, T, W>

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<D: Clone, T, W: Handleable<D, T>> Debug for Handle<D, T, W>

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

Formats the value using the given formatter.