Struct Request 

pub struct Request { /* private fields */ }

A consumer’s request for a single past group, handed to a handler via track::Dynamic::requested_group.

The handler fulfills it by calling Self::accept, which inserts the group into the track cache (resolving every track::Consumer::fetch_group that joined the attempt) and returns a Producer to fill. A relay typically opens a wire FETCH and waits for the publisher to answer before accepting, so a group the publisher lacks is rejected rather than accepted and then aborted. The request carries its own producer handle, so it works the same whether or not the track has been accepted yet.

Implementations

impl Request

pub fn sequence(&self) -> u64

The group sequence the consumer wants.

pub fn priority(&self) -> u8

The delivery priority the consumer requested for this group.

pub fn frame_start(&self) -> u64

The first frame of the group the consumer wants; 0 is the whole group.

The group accept returns already starts here, so the frames a handler writes carry the indices they have in the group rather than restarting at 0. A handler serving from elsewhere moves it with start_at before the first frame.

There is no end: the handler fetches through the end of the group so the result is cacheable for anyone (see group::Fetch::frame_start).

pub fn accept(self, info: impl Into<Option<Info>>) -> Result<Producer>

Insert the fetched group into the track cache, resolving the waiting Consumer::fetch_group, and return a group::Producer to fill.

The group’s timescale comes from the track’s Info. info sets that info if the track hasn’t been accepted yet (a fetch with no live subscription), and is ignored once accepted. Returns Error::Duplicate if the group is already present, or the track’s abort error if it closed while pending.

pub fn reject(self, err: Error)

Reject the fetch, resolving every joined Consumer::fetch_group with err.

pub fn poll_unused(&self, waiter: &Waiter) -> Poll<()>

Poll for the request becoming unused (every waiting Consumer::fetch_group dropped), so a handler can stop serving and drop the request.

Once ready, a later fetch of the group starts a fresh request rather than joining this abandoned one.

Trait Implementations

impl Drop for Request

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.