Struct KeyedRequests 

pub struct KeyedRequests<K> { /* private fields */ }

Available on crate feature web03 only.

A set of pending requests with at most one for each key, kept alive until each completes.

This is like Requests, except that each request is stored under a key with KeyedRequests::insert. Storing a request under a key which already has one cancels the request stored before it, so that what is fetched for a key is always the latest. Any number of keys can have a request in flight at once, and a key is forgotten once its request completes.

Every request still pending is cancelled when the set is dropped or cleared.

Examples

use yew::prelude::*;
use musli_web::web03::prelude::*;

mod api {
    use musli::{Decode, Encode};
    use musli_web::api;

    #[derive(Encode, Decode)]
    pub struct RenameRequest<'de> {
        pub id: u32,
        pub name: &'de str,
    }

    api::define! {
        pub type Rename;

        impl Endpoint for Rename {
            impl<'de> Request for RenameRequest<'de>;
            type Response<'de> = ();
        }
    }
}

enum Msg {
    Rename(u32, String),
    Renamed(Result<ws::Packet<api::Rename>, ws::Error>),
}

#[derive(Properties, PartialEq)]
struct Props {
    ws: ws::Handle,
    rows: Vec<u32>,
}

struct Rows {
    // At most one rename in flight for each row.
    renames: ws::KeyedRequests<u32>,
}

impl Component for Rows {
    type Message = Msg;
    type Properties = Props;

    fn create(_: &Context<Self>) -> Self {
        Self {
            renames: ws::KeyedRequests::new(),
        }
    }

    fn update(&mut self, ctx: &Context<Self>, msg: Self::Message) -> bool {
        match msg {
            Msg::Rename(id, name) => {
                // Renaming a row again cancels its earlier rename, but
                // leaves the renames of other rows alone.
                self.renames.insert(
                    id,
                    ctx.props()
                        .ws
                        .request()
                        .body(api::RenameRequest { id, name: &name })
                        .on_packet(ctx.link().callback(Msg::Renamed))
                        .send(),
                );

                true
            }
            Msg::Renamed(_) => true,
        }
    }

    fn view(&self, ctx: &Context<Self>) -> Html {
        html! {
            {for ctx.props().rows.iter().copied().map(|id| {
                let onclick = ctx.link().callback(move |_: MouseEvent| {
                    Msg::Rename(id, format!("Row {id}"))
                });

                let label = if self.renames.is_pending(&id) {
                    String::from("Renaming...")
                } else {
                    format!("Rename #{id}")
                };

                html!(<button {onclick}>{label}</button>)
            })}
        }
    }
}

Implementations

impl<K> KeyedRequests<K>

pub fn new() -> Self

Construct an empty set of requests.

Examples

use musli_web::web03::prelude::*;

let requests = ws::KeyedRequests::<u32>::new();
assert!(requests.is_empty());

pub fn len(&self) -> usize

The number of keys whose request is still pending.

pub fn is_empty(&self) -> bool

Whether no request is pending.

pub fn keys(&self) -> impl Iterator<Item = &K>

Iterate over the keys whose request is still pending, in no particular order.

pub fn clear(&mut self)

Cancel every pending request.

impl<K> KeyedRequests<K>

where K: Eq + Hash,

pub fn insert(&mut self, key: K, request: Request)

Keep request under key until it completes, cancelling the request stored under key before it.

A request which is not pending, such as one which could not be sent, is dropped straight away, but still cancels the one before it.

pub fn remove<Q>(&mut self, key: &Q) -> bool

where K: Borrow<Q>, Q: ?Sized + Eq + Hash,

Cancel the request stored under key, returning whether it was still pending.

pub fn is_pending<Q>(&self, key: &Q) -> bool

where K: Borrow<Q>, Q: ?Sized + Eq + Hash,

Whether the request stored under key is still pending.

Trait Implementations

impl<K> Debug for KeyedRequests<K>

where K: Debug,

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<K> Default for KeyedRequests<K>

fn default() -> Self

Returns the “default value” for a type.