Struct leptos_server::ArcServerAction

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

Implementations

impl<S> ArcServerAction<S>

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

pub fn new() -> Self

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

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) -> ArcRwSignal<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) -> ArcRwSignal<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::Output: 'static,

fn clone(&self) -> Self

Returns a copy 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::Output: Send + Sync + 'static, S::Error: Send + Sync + 'static,

fn default() -> Self

Returns the “default value” for a type.

impl<S> DefinedAt for ArcServerAction<S>

where S: ServerFn + 'static, S::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::Output: 'static,

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

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.