Struct ArcServerAction 

pub struct ArcServerAction<S>
where
    S: ServerFn + 'static,
    <S as ServerFn>::Output: 'static,
{ /* private fields */ }

An ArcAction that can be used to call a server function.

Implementations

impl<S> ArcServerAction<S>

where S: ServerFn + Clone + Send + Sync + 'static, <S as ServerFn>::Output: Send + Sync + 'static, <S as ServerFn>::Error: Send + Sync + 'static + FromServerFnError,

pub fn new() -> ArcServerAction<S>

Creates a new ArcAction that will call the server function S when dispatched.

Methods from Deref<Target = ArcAction<S, Result<<S as ServerFn>::Output, <S as ServerFn>::Error>>>

pub fn clear(&self)

Clears the value of the action, setting its current value to None.

This has no other effect: i.e., it will not cancel in-flight actions, set the input, etc.

pub fn dispatch(&self, input: I) -> ActionAbortHandle

Calls the async function with a reference to the input type as its argument.

pub fn dispatch_local(&self, input: I) -> ActionAbortHandle

Calls the async function with a reference to the input type as its argument, ensuring that it is spawned on the current thread.

pub fn version(&self) -> ArcRwSignal<usize>

The number of times the action has successfully completed.

let act = ArcAction::new(|n: &u8| {
    let n = n.to_owned();
    async move { n * 2 }
});

let version = act.version();
act.dispatch(3);
assert_eq!(version.get(), 0);

// after it resolves
assert_eq!(version.get(), 1);

pub fn input(&self) -> ArcMappedSignal<Option<I>>

The current argument that was dispatched to the async function. This value will be Some while we are waiting for it to resolve, and None after it has resolved.

let act = ArcAction::new(|n: &u8| {
    let n = n.to_owned();
    async move { n * 2 }
});

let input = act.input();
assert_eq!(input.get(), None);
act.dispatch(3);
assert_eq!(input.get(), Some(3));

// after it resolves
assert_eq!(input.get(), None);

pub fn value(&self) -> ArcMappedSignal<Option<O>>

The most recent return value of the async function. This will be None before the action has ever run successfully, and subsequently will always be Some(_), holding the old value until a new value has been received.

let act = ArcAction::new(|n: &u8| {
    let n = n.to_owned();
    async move { n * 2 }
});

let value = act.value();
assert_eq!(value.get(), None);
act.dispatch(3);
assert_eq!(value.get(), None);

// after it resolves
assert_eq!(value.get(), Some(6));
// dispatch another value, and it still holds the old value
act.dispatch(3);
assert_eq!(value.get(), Some(6));

pub fn pending(&self) -> ArcMemo<bool>

Whether the action has been dispatched and is currently waiting to resolve.

let act = ArcAction::new(|n: &u8| {
    let n = n.to_owned();
    async move { n * 2 }
});

let pending = act.pending();
assert_eq!(pending.get(), false);
act.dispatch(3);
assert_eq!(pending.get(), true);

// after it resolves
assert_eq!(pending.get(), false);

Trait Implementations

impl<S> Clone for ArcServerAction<S>

where S: ServerFn + 'static, <S as ServerFn>::Output: 'static,

fn clone(&self) -> ArcServerAction<S>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<S> Default for ArcServerAction<S>

where S: ServerFn + Clone + Send + Sync + 'static, <S as ServerFn>::Output: Send + Sync + 'static, <S as ServerFn>::Error: Send + Sync + 'static,

fn default() -> ArcServerAction<S>

Returns the “default value” for a type.

impl<S> DefinedAt for ArcServerAction<S>

where S: ServerFn + 'static, <S as ServerFn>::Output: 'static,

fn defined_at(&self) -> Option<&'static Location<'static>>

Returns the location at which the signal was defined. This is usually simply None in release mode.

impl<S> Deref for ArcServerAction<S>

where S: ServerFn + 'static, <S as ServerFn>::Output: 'static,

type Target = ArcAction<S, Result<<S as ServerFn>::Output, <S as ServerFn>::Error>>

The resulting type after dereferencing.

fn deref(&self) -> &<ArcServerAction<S> as Deref>::Target

Dereferences the value.