Struct trillium_server_common::CloneCounterObserver

pub struct CloneCounterObserver(/* private fields */);

An observer that can be cloned without modifying the clone counter, but can be used to inspect its state and awaited

Zero-indexed, but each CloneCounter retrieved with CloneCounterObserver::counter increments the count by 1.

Awaiting a CloneCounterObserver will be pending until all associated CloneCounters have been dropped, and will resolve to () when the count is 0.

Implementations

impl CloneCounterObserver

pub fn new() -> Self

returns a new observer with a zero count. use CloneCounterObserver::counter to

pub fn current(&self) -> usize

returns the current counter value

pub fn counter(&self) -> CloneCounter

creates a new CloneCounter from this observer, incrementing the count

Trait Implementations

impl Clone for CloneCounterObserver

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for CloneCounterObserver

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

Formats the value using the given formatter.

impl Default for CloneCounterObserver

fn default() -> Self

Returns the “default value” for a type.

impl From<CloneCounter> for CloneCounterObserver

fn from(value: CloneCounter) -> Self

Converts to this type from the input type.

impl From<CloneCounterObserver> for CloneCounter

fn from(value: CloneCounterObserver) -> Self

Converts to this type from the input type.

impl IntoFuture for CloneCounterObserver

type Output = ()

The output that the future will produce on completion.

type IntoFuture = CloneCounterFuture

Which kind of future are we turning this into?

fn into_future(self) -> Self::IntoFuture

Creates a future from a value.

impl PartialEq<usize> for CloneCounterObserver

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

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

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.