Struct GetOpts 

pub struct GetOpts { /* private fields */ }

What one GET may vary — everything RFC 05 §2.1 does not fix.

The §2.1 triple is not a knob and deliberately has no field here: it is applied by disciplined_get to every GET this crate issues. What a caller does choose is the timeout, the request body, an attachment riding beside it (#126), the query’s priority (RFC 04 §3, RFC 07 §2.6) and whether replies from outside the selector are accepted.

A spec struct rather than named sibling functions: fleet_get_at (priority) and fleet_get_call (attachment) used to be those siblings, and _at had come to mean two things — this axis, and the injected-clock convention (ingest_at, ZrecWriter::new_at). The greps the siblings bought survive as setter greps: “who issues bulk GETs?” is grep '\.priority(', “who sends attachments on queries?” is grep '\.attachment('.

Implementations

impl GetOpts

pub fn new(timeout: Duration) -> Self

A plain GET, bounded by timeout.

Priority::DEFAULT is Priority::Data — byte-identical to setting no priority at all, which is what every un-annotated GET did before this type existed.

pub fn payload(self, payload: Option<Vec<u8>>) -> Self

The request body, when there is one. None is the common case and costs nothing to say.

pub fn attachment(self, attachment: Option<Vec<u8>>) -> Self

A query attachment (#126), verbatim — never schema-encoded. The encode ladder is for bodies; an attachment is outside the registry’s vocabulary (#117), on a query exactly as on a publish.

pub fn priority(self, priority: Priority) -> Self

State the query’s priority (RFC 04 §3, RFC 07 §2.6).

Replies inherit the query’s QoS — a server-side setter is a no-op — so a bulk plane’s priority can only be decided here. RFC 07 §2.6 makes that a caller obligation rather than a suggestion: @blob GETs MUST ride at Priority::DataLow, or one operator fetching a debug bundle starves the telemetry and alerts sharing the link.

pub fn accept_any(self) -> Self

Accept replies on keys outside the selector (zenoh::query::ReplyKeyExpr::Any) — the querying-subscriber pattern.

The @adv cache replies with the cached sample on the sample’s own key, outside a <key>/@adv/** selector, and zenoh drops such replies unless the caller opts in. Harmless on a rung whose replies sit inside the selector anyway.

pub fn timeout(&self) -> Duration

The bound this GET runs under.

pub fn max_replies(self, max: usize) -> Self

Keep at most max replies (#339). Zero is clamped to one: a GET that kept nothing would report silence, and silence is never a verdict (RFC 05 §3.1).

pub fn reply_bound(&self) -> usize

The reply bound in force.

pub fn elided(&self) -> u64

What the bound cost: replies that arrived and were not kept, across every GET run under these options (RFC 13 §3 O6 — a bound that hides data must say so).

It rides here, on the object that states the bound, rather than in the return type, for the reason every other bounded structure in this crate keeps its own ledger (StatsTable::evicted, Retention::evicted, BoundedLru::admit): the thing that owns the ceiling owns the count of what the ceiling refused. A caller reads it beside the answers it just got:

let opts = GetOpts::new(timeout);
let answers = fleet_get(&fleet, key, &opts).await?;
if opts.elided() > 0 { /* say so — never render this as "all of them" */ }

The count is exact: past the bound the replies are still drained, they are simply not kept. Draining is what makes the number honest; keeping is what was unbounded.

pub fn reset_elided(&self)

Forget what earlier GETs under these options cost — for a caller that reuses one GetOpts and reports per GET rather than per run.

Trait Implementations

impl Clone for GetOpts

fn clone(&self) -> GetOpts

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for GetOpts

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

Formats the value using the given formatter.