Struct ServerMultiAction 

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

A MultiAction that can be used to call a server function.

Implementations

impl<S> ServerMultiAction<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() -> ServerMultiAction<S>

Creates a new MultiAction which, when dispatched, will call the server function S.

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

pub fn dispatch(&self, input: I)

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

This can be called any number of times: each submission will be dispatched, running concurrently, and its status can be checked via the submissions() signal.

async fn send_new_todo_to_api(task: String) -> usize {
  // do something...
  // return a task id
  42
}
let add_todo = MultiAction::new(|task: &String| {
  // `task` is given as `&String` because its value is available in `input`
  send_new_todo_to_api(task.clone())
});

let submissions = add_todo.submissions();
let pending_submissions = move || {
  submissions.with(|subs| subs.iter().filter(|sub| sub.pending().get()).count())
};

add_todo.dispatch("Buy milk".to_string());
assert_eq!(submissions.with(Vec::len), 1);
assert_eq!(pending_submissions(), 1);

add_todo.dispatch("???".to_string());
add_todo.dispatch("Profit!!!".to_string());

assert_eq!(submissions.with(Vec::len), 3);
assert_eq!(pending_submissions(), 3);

// when submissions resolve, they are not removed from the set
// however, their `pending` signal is now `false`, and this can be used to filter them
assert_eq!(submissions.with(Vec::len), 3);
assert_eq!(pending_submissions(), 0);

pub fn dispatch_sync(&self, value: O)

Synchronously adds a submission with the given value.

This takes the output value, rather than the input, because it is adding a result, not an input.

This can be useful for use cases like handling errors, where the error can already be known on the client side.

async fn send_new_todo_to_api(task: String) -> usize {
  // do something...
  // return a task id
  42
}
let add_todo = MultiAction::new(|task: &String| {
  // `task` is given as `&String` because its value is available in `input`
  send_new_todo_to_api(task.clone())
});

let submissions = add_todo.submissions();
let pending_submissions = move || {
  submissions.with(|subs| subs.iter().filter(|sub| sub.pending().get()).count())
};

add_todo.dispatch("Buy milk".to_string());
assert_eq!(submissions.with(Vec::len), 1);
assert_eq!(pending_submissions(), 1);

add_todo.dispatch_sync(42);

assert_eq!(submissions.with(Vec::len), 2);
assert_eq!(pending_submissions(), 1);

pub fn submissions(&self) -> ReadSignal<Vec<ArcSubmission<I, O>>>

The set of all submissions to this multi-action.

async fn send_new_todo_to_api(task: String) -> usize {
  // do something...
  // return a task id
  42
}
let add_todo = MultiAction::new(|task: &String| {
  // `task` is given as `&String` because its value is available in `input`
  send_new_todo_to_api(task.clone())
});

let submissions = add_todo.submissions();

add_todo.dispatch("Buy milk".to_string());
add_todo.dispatch("???".to_string());
add_todo.dispatch("Profit!!!".to_string());

assert_eq!(submissions.with(Vec::len), 3);

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

How many times an action has successfully resolved.

async fn send_new_todo_to_api(task: String) -> usize {
  // do something...
  // return a task id
  42
}
let add_todo = MultiAction::new(|task: &String| {
  // `task` is given as `&String` because its value is available in `input`
  send_new_todo_to_api(task.clone())
});

let version = add_todo.version();

add_todo.dispatch("Buy milk".to_string());
add_todo.dispatch("???".to_string());
add_todo.dispatch("Profit!!!".to_string());

assert_eq!(version.get(), 0);

// when they've all resolved
assert_eq!(version.get(), 3);

Trait Implementations

impl<S> Clone for ServerMultiAction<S>

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

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<S> Copy for ServerMultiAction<S>

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

impl<S> Default for ServerMultiAction<S>

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

fn default() -> ServerMultiAction<S>

Returns the “default value” for a type.

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

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

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

The resulting type after dereferencing.

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

Dereferences the value.

impl<S> From<ServerMultiAction<S>> for MultiAction<S, Result<<S as ServerFn>::Output, ServerFnError<<S as ServerFn>::Error>>>

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

fn from( value: ServerMultiAction<S>, ) -> MultiAction<S, Result<<S as ServerFn>::Output, ServerFnError<<S as ServerFn>::Error>>>

Converts to this type from the input type.