Struct ArcServerMultiAction

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

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

Implementations

impl<S> ArcServerMultiAction<S>

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

pub fn new() -> ArcServerMultiAction<S>

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

Methods from Deref<Target = ArcMultiAction<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 = ArcMultiAction::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 = {
    let submissions = submissions.clone();
    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 = ArcMultiAction::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 = {
    let submissions = submissions.clone();
    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) -> ArcReadSignal<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 = ArcMultiAction::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) -> ArcRwSignal<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 = ArcMultiAction::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 ArcServerMultiAction<S>

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

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<S> Default for ArcServerMultiAction<S>

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

fn default() -> ArcServerMultiAction<S>

Returns the “default value” for a type.

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

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

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

The resulting type after dereferencing.

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

Dereferences the value.