Struct SliceSet 

pub struct SliceSet { /* private fields */ }

A set of registry slices, indexed by producer/service base name.

Implementations

impl SliceSet

pub fn topic_list( &self, producer: Option<&str>, class: Option<Class>, type_name: Option<&str>, deprecated: bool, ) -> Result<TopicList>

topic list — every registered subject in the given slices.

Declared, not observed. A pattern with a trailing rest-variable ({path...}) stands for a whole family whose real members only exist on the wire: proxy producers register {device}/{path...} by design, because their metric tree belongs to the polled device, not to us. For those, this command can only tell you the shape. zenctl echo is what tells you the members. class is a Class, so there is no validation here and no error to return for one: a caller that has a Class has already parsed it, at whatever edge it came in from. This function used to re-check a &str against its own copy of the vocabulary, with its own copy of the sentence (#351).

pub fn topic_info(&self, base: &str, key: &str) -> TopicInfo

topic info — refine one concrete wire key against the registry slices.

This is the slice-level parse direction (RFC 08 §1): the key is parsed structurally (grammar only), then its subject tail is matched against the producer’s slice, binding variables by name — which is why the output can say mount=root rather than parts[6].

pub fn service_list(&self, producer: Option<&str>) -> ServiceList

pub fn service_info( &self, producer: &str, path: Option<&str>, ) -> Result<ServiceInfo>

service info — one producer’s @rpc surface, with call keys.

Err when nothing declares the producer, listing what does: a name that answers nowhere is a typo far more often than a silent fleet, and the alternative — an empty procedure list — reads as “this producer offers nothing”, which is a verdict this cannot support (O4).

pub fn interface_list(&self) -> InterfaceList

interface list — every payload type the slices declare, with carrier counts. Field-level schema is deliberately absent: type definitions stay with the owning application (RFC 08 §5), so this maps the vocabulary, not the shapes.

pub fn interface_show(&self, type_name: &str) -> Result<InterfaceShow>

interface show — one payload type, and every subject/procedure that carries it (the reverse of the registry’s binding).

impl SliceSet

pub fn from_dirs(dirs: &[PathBuf]) -> Result<SliceSet>

Load from local registry/*.toml dirs — the offline source. What a checked-out application declares. (types.toml is the type table, not a slice — skipped.)

pub async fn from_bus(fleet: &Fleet<'_>, timeout: Duration) -> Result<SliceSet>

Discover every live producer’s served slice from the bus (crate::fleet_registry_by_origin), collapsed to one slice per producer.

The collapse is recorded rather than silent — see collapsed. A caller whose question is which host should not come here at all: go one layer down to crate::fleet_registry_by_origin, which does not deduplicate.

pub fn from_served(served: Vec<ServedSlice>) -> SliceSet

Fold an origin-attributed sweep into one slice per producer, keeping a receipt of what the fold discarded (#385).

Pure, so the collapse is testable without a bus — and separable, so a caller that ran its own sweep can reuse the fold without re-querying.

pub fn collapsed(&self) -> Asked<&[CollapsedProducer]>

Producers this set folded more than one origin’s answer into, and whether those origins agreed (#385).

Three-state on purpose (#399). NotAsked is a set built from files or from bare slices: neither carries an origin, so nothing could be collapsed and no question was put. Asked(&[]) is a bus sweep in which every producer had exactly one origin answer — the fleet agrees, and it agrees because it was asked. A bare empty slice conflated the two, which is the O4 failure this receipt exists to avoid (RFC 13 §3 O4).

pub fn entries(&self) -> impl Iterator<Item = (&RegistrySlice, &str)>

Each slice with the raw TOML it was parsed from — the pair write_cache persists. The text is empty for a set built by from_slices, which has none to give.

pub fn slices(&self) -> &[RegistrySlice]

pub fn get(&self, name: &str) -> Option<&RegistrySlice>

pub fn by_service_origin(&self, origin: &str) -> Option<&RegistrySlice>

The slice declaring a service origin (@catalog) — service keys have no producer chunk, so refinement resolves through this.

pub fn refine<'s>( &'s self, producer: &str, class: &str, tail: &[&str], ) -> Option<(&'s SubjectDecl, Vec<(String, String)>)>

Refine a subject tail against one producer’s slice: the matching subject declaration plus its named variable bindings.

pub fn from_slices(slices: Vec<RegistrySlice>) -> SliceSet

Build from already-parsed slices (no raw TOML retained — such a set is skipped by write_cache).

pub fn write_cache(&self, dir: &Path) -> Result<()>

Write the raw slice TOMLs to a cache dir (one file per producer). Repeated invocations and dynamic shell completion read this instead of round-tripping the bus.

pub fn read_cache(dir: &Path) -> SliceSet

Read a previously written cache dir. Same forgiving posture as from_dirs, but a missing dir is an empty set, not an error.

impl SliceSet

pub async fn from_union( fleet: &Fleet<'_>, dirs: &[PathBuf], timeout: Duration, ) -> Result<UnionOutcome>

Load the union of the live bus and local dirs: served wins per producer, dirs fill the gaps, and every producer where the two disagree is retained as a SliceDisagreement.

Degrades honestly: an unreachable bus yields a dirs-only union (the outcome’s from_bus is empty — the caller can see which case it got).

impl SliceSet

pub fn diff(&self, local: &SliceSet) -> RegistryDiff

Compare this set — what the fleet serves — against what a checkout declares, per producer.

Pure, so the comparison is testable without a bus, and engine-side so both explorers can make it (issue #208). The per-producer comparison is already zenkey::slice::diff; this is the set-level join that decides what to do about a producer only one side knows.

Trait Implementations

impl Clone for SliceSet

fn clone(&self) -> SliceSet

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for SliceSet

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

Formats the value using the given formatter.

impl Default for SliceSet

fn default() -> SliceSet

Returns the “default value” for a type.