Struct async_progress::Progress

pub struct Progress<State> where
    State: 'static + Clone + Send + Sync + Eq + Debug,  { /* fields omitted */ }

A progress tracker.

You can call set_state and it will notify observers of the new state.

To wait for a specific state, you can call wait or once.

Progress is Clone and it’s methods only require a shared reference for convenience.

Implementations

impl<State> Progress<State> where
    State: 'static + Clone + Send + Sync + Eq + Debug, 

pub fn new(state: State) -> Self

Create a Progress with an initial state.

pub async fn set_state(&self, new_state: State)

Set a new state. Observers will be notified.

pub fn current(&self) -> State

Check the current state.

pub fn wait(&self, state: State) -> Events<State>

Create an event stream that will only fire for the given state. This is a stream and if you call set_state several times with the given state, this will yield several events.

Note that events fired before you call this will not be delivered to the stream. It’s recommended to set up all observers first and then start doing work that can call set_state.

Note that this method uses block_on to lock a mutex on the pharos object, so it might block the thread. All operations on Progress are really short, so this shouldn’t be a problem as long as you haven’t set up an observer by calling Progress::observe with a bounded channel with a low queue size. If the sending of an event (in set_state) returns pending, and this method is called, that will deadlock.

pub fn once(&self, state: State) -> impl Future + Send

Create a future that will resolve when a certain state is next triggered.

Note that events fired before you call this will not be delivered to the stream. It’s recommended to set up all observers first and then start doing work that can call set_state.

Note that this method uses block_on to lock a mutex on the pharos object, so it might block the thread. All operations on Progress are really short, so this shouldn’t be a problem as long as you haven’t set up an observer by calling Progress::observe with a bounded channel with a low queue size. If the sending of an event (in set_state) returns pending, and this method is called, that will deadlock.

Trait Implementations

impl<State: Clone> Clone for Progress<State> where
    State: 'static + Clone + Send + Sync + Eq + Debug, 

fn clone(&self) -> Progress<State>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<State> Debug for Progress<State> where
    State: 'static + Clone + Send + Sync + Eq + Debug, 

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

Formats the value using the given formatter.

impl<State> Observable<State> for Progress<State> where
    State: 'static + Clone + Send + Sync + Eq + Debug, 

fn observe(
    &mut self,
    options: ObserveConfig<State>
) -> Observe<'_, State, Self::Error>

Avoid configuring pharos with a bounded channel of a low queue size. It is possible to create a deadlock if the send in Progress::set_state returns pending and you call another method on Progress that uses block_on, notably Progress::current.

type Error = PharErr

The error type that is returned if observing is not possible.