Struct Opts 

pub struct Opts {

    pub op: Op,
    pub room_id: Option<OwnedRoomId>,
    pub event_id: Option<OwnedEventId>,
    pub ts: Option<MilliSecondsSinceUnixEpoch>,
    pub dir: Option<Direction>,
    pub earliest_events: EventWindow,
    pub latest_events: EventWindow,
    pub hint: Option<OwnedServerName>,
    pub candidates: Candidates,
    pub room_version: Option<RoomVersionId>,
    pub attempt_limit: Option<NonZeroUsize>,
    pub backfill_limit: Option<NonZeroUsize>,
    pub fanout_growth: FanoutGrowth,
    pub fanout_max_width: Option<NonZeroUsize>,
    pub fanout_rounds: Option<NonZeroUsize>,
    pub check_event_id: bool,
    pub check_conforms: bool,
    pub check_hashes: bool,
    pub authoritative_redaction: bool,
    pub check_signature: bool,
}

Caller contract. event_id is the sought datum for Op::Event / Op::AuthEvent / Op::AuthChain / Op::StateIds and a reference point for the others.

Fields

op: Op

Federation endpoint this fetch targets.

room_id: Option<OwnedRoomId>

Room the fetch is scoped to, or None for an unscoped id-addressed fetch.

event_id: Option<OwnedEventId>

Event to fetch (id-addressed ops) or anchor from (room-scoped ops).

ts: Option<MilliSecondsSinceUnixEpoch>

Timestamp the Op::TimestampToEvent search starts from; None for every other op.

dir: Option<Direction>

Direction the Op::TimestampToEvent search runs; None for every other op.

earliest_events: EventWindow

Boundary events the requester already holds; an Op::MissingEvents window stops its backward walk here. Empty for every other op.

latest_events: EventWindow

Frontier events an Op::MissingEvents window fills the predecessors of. Empty for every other op.

hint: Option<OwnedServerName>

Server to try ahead of the ranked candidates.

candidates: Candidates

Caller-supplied candidate pool tried in place of the room-derived ranking; empty defers to the room-derived candidates.

room_version: Option<RoomVersionId>

Room version governing id and signature checks; None assumes V11.

attempt_limit: Option<NonZeroUsize>

Cap on candidate servers tried; None tries every candidate.

backfill_limit: Option<NonZeroUsize>

Event count requested per Op::Backfill / Op::MissingEvents batch response; defaults to 10.

fanout_growth: FanoutGrowth

Per-round width curve for staged fan-out. Fixed(1) is sequential.

fanout_max_width: Option<NonZeroUsize>

Per-round concurrency ceiling. None lets the curve run free, clamped only by the candidate pool and attempt_limit; Some(n) caps each round at n.

fanout_rounds: Option<NonZeroUsize>

Cap on escalation rounds before giving up. None runs until exhaustion.

check_event_id: bool

Reject a response whose event does not hash to the requested id.

check_conforms: bool

Reject a response that is not well-formed JSON.

check_hashes: bool

Reject a response that fails content-hash verification.

authoritative_redaction: bool

Accepted but not yet consulted; redaction-aware hash verification is unimplemented.

check_signature: bool

Reject a response that fails signature verification.

Implementations

impl Opts

pub fn new(op: Op, room_id: OwnedRoomId) -> Self

Scope a fetch to a room.

pub fn unscoped(op: Op) -> Self

A fetch with no room scope, for id-addressed callers such as get-remote-pdu; room-derived candidate ranking is skipped, leaving the hint, the caller-supplied pool, and the event id’s origin.

fn with_room_id(op: Op, room_id: Option<OwnedRoomId>) -> Self

All validation toggles default on; the caller relaxes them per request.

pub fn event_id(self, event_id: OwnedEventId) -> Self

Set the target event; required for the id-addressed ops.

pub fn ts(self, ts: MilliSecondsSinceUnixEpoch) -> Self

Set the timestamp the Op::TimestampToEvent search starts from.

pub fn dir(self, dir: Direction) -> Self

Set the direction the Op::TimestampToEvent search runs.

pub fn earliest_events<I>(self, earliest_events: I) -> Self

where I: IntoIterator<Item = OwnedEventId>,

Set the boundary the Op::MissingEvents backward walk stops at.

pub fn latest_events<I>(self, latest_events: I) -> Self

where I: IntoIterator<Item = OwnedEventId>,

Set the frontier an Op::MissingEvents window fills behind.

pub fn hint(self, hint: OwnedServerName) -> Self

Try the named server ahead of the ranked candidates.

pub fn candidates<I>(self, candidates: I) -> Self

where I: IntoIterator<Item = OwnedServerName>,

Supply the candidate pool verbatim, bypassing the room-derived ranking.

pub fn room_version(self, room_version: RoomVersionId) -> Self

Room version for Op::Event id and signature checks. None keeps the V11 default, so callers on a non-V11 room must name it to avoid a spurious rejection.

pub fn attempt_limit(self, attempt_limit: NonZeroUsize) -> Self

Cap the number of candidate servers tried.

pub fn backfill_limit(self, backfill_limit: NonZeroUsize) -> Self

Set the events requested per Op::Backfill / Op::MissingEvents batch.

pub fn fanout(self, growth: FanoutGrowth) -> Self

Set the per-round fan-out width schedule.

pub fn fanout_max_width(self, max_width: NonZeroUsize) -> Self

Cap the per-round fan-out concurrency.

pub fn fanout_rounds(self, rounds: NonZeroUsize) -> Self

Cap the number of escalation rounds.

pub fn fanout_for_op(self) -> Self

Apply the op’s advised staged-fan-out ramp. Opts::new is otherwise dark on every op, so a callsite opts in by chaining this; the generic and single-shot-batch ops keep the sequential default.

pub fn checks(self, enabled: bool) -> Self

Toggle every validation gate at once. Callers that re-validate downstream pass false to fetch raw bytes without rejecting non-V11 events.

Trait Implementations

impl Clone for Opts

fn clone(&self) -> Opts

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Opts

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

Formats the value using the given formatter.