Struct Publisher 

pub struct Publisher<T> { /* private fields */ }

A feed’s end of the channel a consumer reads it through, and the age of what it holds.

A feed receives one of these from whichever consumer type runs it (SnapshotFeedStream, SnapshotFeedStreams or SnapshotFeedWatch) and cannot make one: the channel, its None seed and the task the feed runs in all belong to whoever reads the feed, so no consumer can hold a feed’s future and give it their own pace.

publishing is the whole of what a feed does with it — hand it the snapshots and the age at which one goes stale, and everything else is taken care of.

Implementations

impl<T> Publisher<T>

pub async fn publishing<E>( self, max_age: Option<Duration>, snapshots: impl Stream<Item = Result<T, E>>, ) -> Result<(), E>

Publishes every snapshot snapshots produces, withdrawing one that goes max_age without being refreshed, and resolves with the error the feed ended on. A max_age of None keeps whatever was published until the feed ends.

Resolves Ok(()) when the stream runs out, which a feed holding a connection never does, and as soon as the last receiver goes away, since everything the feed produces from then on would reach nobody.

Everything a feed does between two snapshots — ticking, fetching, connecting, reading, backing off — belongs inside snapshots: this awaits nothing else, so that is the wait staleness and the last receiver leaving can cut into. Work a feed does elsewhere runs to its end before either is noticed.

Trait Implementations

impl<T> Drop for Publisher<T>

fn drop(&mut self)

Whatever ends a feed ends its snapshot: it gave up, ran out, or its task was dropped because nobody was reading. Nothing refreshes the published snapshot after that, so it is withdrawn rather than left standing for consumers to keep using.

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.