Struct ServerAction

pub struct ServerAction<S>
where
    S: ServerFn + 'static,
    <S as ServerFn>::Output: 'static,
{
    inner: Action<S, Result<<S as ServerFn>::Output, <S as ServerFn>::Error>>,
}

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

Fields

inner: Action<S, Result<<S as ServerFn>::Output, <S as ServerFn>::Error>>

Implementations

impl<S> ServerAction<S>

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

pub fn new() -> ServerAction<S>

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

Methods from Deref<Target = Action<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 version(&self) -> RwSignal<usize>

The number of times the action has successfully completed.

let act = Action::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 pending(&self) -> Memo<bool>

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

let act = Action::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);

pub fn input(&self) -> MappedSignal<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 = Action::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 input_local(&self) -> MappedSignal<Option<I>>

👎Deprecated: You can now use .input() for any value, whether it’s thread-safe or not.

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.

Returns a thread-local signal using [LocalStorage].

pub fn value(&self) -> MappedSignal<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 = Action::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 value_local(&self) -> MappedSignal<Option<O>>

where O: Send + Sync,

👎Deprecated: You can now use .value() for any value, whether it’s thread-safe or not.

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.

Returns a thread-local signal using [LocalStorage].

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.

Trait Implementations

impl<S> Clone for ServerAction<S>

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

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<S> Default for ServerAction<S>

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

fn default() -> ServerAction<S>

Returns the “default value” for a type.

impl<S> DefinedAt for ServerAction<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 ServerAction<S>

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

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

The resulting type after dereferencing.

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

Dereferences the value.

impl<S> From<ServerAction<S>> for Action<S, Result<<S as ServerFn>::Output, <S as ServerFn>::Error>>

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

fn from( value: ServerAction<S>, ) -> Action<S, Result<<S as ServerFn>::Output, <S as ServerFn>::Error>>

Converts to this type from the input type.

impl<S> Copy for ServerAction<S>

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