Struct Weak

pub struct Weak<I> { /* private fields */ }

A weak handle to a Wayland object

This handle does not keep the underlying user data alive, and can be converted back to a full resource using Weak::upgrade().

Implementations

impl<I: Resource> Weak<I>

pub fn upgrade(&self) -> Result<I, InvalidId>

Try to upgrade with weak handle back into a full resource.

This will fail if either:

• the object represented by this handle has already been destroyed at the protocol level
• the Wayland connection has already been closed

pub fn is_alive(&self) -> bool

Check if this resource is still alive

This will return false if either:

• the object represented by this handle has already been destroyed at the protocol level
• the Wayland connection has already been closed

pub fn id(&self) -> ObjectId

The underlying ObjectId

Trait Implementations

impl<I: Clone> Clone for Weak<I>

fn clone(&self) -> Weak<I>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<I: Debug> Debug for Weak<I>

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

Formats the value using the given formatter.

impl<I> Hash for Weak<I>

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<I: Resource> PartialEq<I> for Weak<I>

fn eq(&self, other: &I) -> 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 PartialEq<Weak<WlBuffer>> for WlBuffer

fn eq(&self, other: &Weak<WlBuffer>) -> 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 PartialEq<Weak<WlCallback>> for WlCallback

fn eq(&self, other: &Weak<WlCallback>) -> 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 PartialEq<Weak<WlCompositor>> for WlCompositor

fn eq(&self, other: &Weak<WlCompositor>) -> 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 PartialEq<Weak<WlDataDevice>> for WlDataDevice

fn eq(&self, other: &Weak<WlDataDevice>) -> 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 PartialEq<Weak<WlDataDeviceManager>> for WlDataDeviceManager

fn eq(&self, other: &Weak<WlDataDeviceManager>) -> 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 PartialEq<Weak<WlDataOffer>> for WlDataOffer

fn eq(&self, other: &Weak<WlDataOffer>) -> 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 PartialEq<Weak<WlDataSource>> for WlDataSource

fn eq(&self, other: &Weak<WlDataSource>) -> 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 PartialEq<Weak<WlKeyboard>> for WlKeyboard

fn eq(&self, other: &Weak<WlKeyboard>) -> 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 PartialEq<Weak<WlOutput>> for WlOutput

fn eq(&self, other: &Weak<WlOutput>) -> 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 PartialEq<Weak<WlPointer>> for WlPointer

fn eq(&self, other: &Weak<WlPointer>) -> 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 PartialEq<Weak<WlRegion>> for WlRegion

fn eq(&self, other: &Weak<WlRegion>) -> 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 PartialEq<Weak<WlSeat>> for WlSeat

fn eq(&self, other: &Weak<WlSeat>) -> 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 PartialEq<Weak<WlShell>> for WlShell

fn eq(&self, other: &Weak<WlShell>) -> 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 PartialEq<Weak<WlShellSurface>> for WlShellSurface

fn eq(&self, other: &Weak<WlShellSurface>) -> 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 PartialEq<Weak<WlShm>> for WlShm

fn eq(&self, other: &Weak<WlShm>) -> 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 PartialEq<Weak<WlShmPool>> for WlShmPool

fn eq(&self, other: &Weak<WlShmPool>) -> 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 PartialEq<Weak<WlSubcompositor>> for WlSubcompositor

fn eq(&self, other: &Weak<WlSubcompositor>) -> 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 PartialEq<Weak<WlSubsurface>> for WlSubsurface

fn eq(&self, other: &Weak<WlSubsurface>) -> 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 PartialEq<Weak<WlSurface>> for WlSurface

fn eq(&self, other: &Weak<WlSurface>) -> 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 PartialEq<Weak<WlTouch>> for WlTouch

fn eq(&self, other: &Weak<WlTouch>) -> 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<I> PartialEq for Weak<I>

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<I> Eq for Weak<I>