Struct Action 

pub struct Action<I, T>
where
    T: 'static,
{ /* private fields */ }

Available on crate feature prelude only.

A handle to an async action created by use_action.

Call it with .call(...) to dispatch work, read results with .value(), and check progress with .pending(). Implements Copy so it can be moved into multiple event handlers freely.

Implementations

impl<I, O> Action<I, O>

where I: 'static, O: 'static,

pub fn value(&self) -> Option<Result<ReadSignal<O>, CapturedError>>

The result of the most recent call, if it has completed.

Returns None while the action is pending or has never been called. Returns Some(Ok(signal)) on success or Some(Err(e)) on failure. The returned ReadSignal is reactive — reading it in RSX will subscribe the component to updates.

pub fn pending(&self) -> bool

Returns true while a call is in flight.

pub fn reset(&mut self)

Clear the result and cancel any in-flight work.

pub fn cancel(&mut self)

Cancel the in-flight task without clearing the previous result’s state.

impl<Out> Action<(), Out>

pub fn call(&mut self) -> Dispatching<()>

Dispatch the action with no arguments.

impl<A, Out> Action<(A,), Out>

where A: 'static,

pub fn call(&mut self, A: A) -> Dispatching<()>

Dispatch the action with the given arguments.

impl<A, B, Out> Action<(A, B), Out>

where A: 'static, B: 'static,

pub fn call(&mut self, A: A, B: B) -> Dispatching<()>

Dispatch the action with the given arguments.

impl<A, B, C, Out> Action<(A, B, C), Out>

where A: 'static, B: 'static, C: 'static,

pub fn call(&mut self, A: A, B: B, C: C) -> Dispatching<()>

Dispatch the action with the given arguments.

impl<A, B, C, D, Out> Action<(A, B, C, D), Out>

where A: 'static, B: 'static, C: 'static, D: 'static,

pub fn call(&mut self, A: A, B: B, C: C, D: D) -> Dispatching<()>

Dispatch the action with the given arguments.

impl<A, B, C, D, E, Out> Action<(A, B, C, D, E), Out>

where A: 'static, B: 'static, C: 'static, D: 'static, E: 'static,

pub fn call(&mut self, A: A, B: B, C: C, D: D, E: E) -> Dispatching<()>

Dispatch the action with the given arguments.

impl<A, B, C, D, E, F, Out> Action<(A, B, C, D, E, F), Out>

where A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static,

pub fn call(&mut self, A: A, B: B, C: C, D: D, E: E, F: F) -> Dispatching<()>

Dispatch the action with the given arguments.

Trait Implementations

impl<I, T> Clone for Action<I, T>

fn clone(&self) -> Action<I, T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<I, T> Debug for Action<I, T>

where T: Debug + 'static,

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

Formats the value using the given formatter.

impl<I, T> PartialEq for Action<I, T>

fn eq(&self, other: &Action<I, T>) -> 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, T> Copy for Action<I, T>