Enum FeedStream 

pub enum FeedStream {
    Rss2(Rss2FeedStream),
    Atom(AtomFeedStream),
}

Available on crate features http and rss only.

One async stream per supported feed format. Use FeedStream::new when the input format isn’t known ahead of time, or Rss2FeedStream / AtomFeedStream directly when it is.

Construction peeks the first chunk, decides the format, and builds the matching strongly-typed inner stream — the header (channel / feed-level metadata) is parsed at that point and is inspectable via channel / header or the cross-format accessors below.

Variants

Rss2(Rss2FeedStream)

Atom(AtomFeedStream)

Implementations

impl FeedStream

pub async fn new<R>(reader: R) -> Result<FeedStream, FeedParseError>

where R: AsyncBufRead + Unpin + Send + 'static,

Peek the prefix of reader, decide the format, and build the matching inner stream.

pub async fn new_strict<R>(reader: R) -> Result<FeedStream, FeedParseError>

where R: AsyncBufRead + Unpin + Send + 'static,

Strict variant of Self::new.

pub async fn from_body(body: Body) -> Result<FeedStream, FeedParseError>

Build a stream directly from an HTTP body.

pub async fn from_body_strict(body: Body) -> Result<FeedStream, FeedParseError>

Strict variant of Self::from_body.

pub fn channel(&self) -> Option<&Rss2Channel>

Borrow the RSS channel header, if this is an RSS stream.

pub fn header(&self) -> Option<&AtomHeader>

Borrow the Atom feed header, if this is an Atom stream.

pub async fn collect(self) -> Result<Feed, CollectError<Feed>>

Drain into a complete in-memory Feed. On a per-item parse error, returns a FeedCollectError whose partial field is a Feed of the same variant carrying everything parsed so far.

pub async fn collect_lossy(self) -> Feed

Drain, silently dropping (and tracing::debug!-logging) items / entries that fail to parse.

pub async fn collect_filtered<F>( self, predicate: F, ) -> Result<Feed, CollectError<Feed>>

where F: FnMut(&FeedItem) -> bool + Send,

Drain into a feed retaining only items / entries the predicate accepts. Mirrors Rss2FeedStream::collect_filtered and AtomFeedStream::collect_filtered for the format-agnostic case (the predicate sees a FeedItem so the same closure works across both formats).

pub fn title(&self) -> &str

See Feed::title.

pub fn description(&self) -> Option<&str>

See Feed::description.

pub fn link(&self) -> Option<&str>

See Feed::link.

pub fn self_link(&self) -> Option<&str>

See Feed::self_link.

pub fn id(&self) -> Option<&str>

See Feed::id.

pub fn language(&self) -> Option<&str>

See Feed::language.

pub fn copyright(&self) -> Option<&str>

See Feed::copyright.

pub fn generator(&self) -> Option<&str>

See Feed::generator.

pub fn image_url(&self) -> Option<&str>

See Feed::image_url.

pub fn icon_url(&self) -> Option<&str>

See Feed::icon_url.

pub fn published(&self) -> Option<Timestamp>

See Feed::published.

pub fn updated(&self) -> Option<Timestamp>

See Feed::updated.

pub fn authors(&self) -> impl Iterator<Item = &str>

See Feed::authors.

pub fn categories(&self) -> impl Iterator<Item = &str>

See Feed::categories.

Trait Implementations

impl Stream for FeedStream

FeedStream is itself a Stream of FeedItems: each inner stream yields its strongly-typed item, and the dispatch here wraps it in the umbrella enum so a caller can iterate format-agnostically.

type Item = Result<FeedItem, FeedParseError>

Values yielded by the stream.

fn poll_next( self: Pin<&mut FeedStream>, cx: &mut Context<'_>, ) -> Poll<Option<<FeedStream as Stream>::Item>>

Attempt to pull out the next value of this stream, registering the current task for wakeup if the value is not yet available, and returning None if the stream is exhausted.

fn size_hint(&self) -> (usize, Option<usize>)

Returns the bounds on the remaining length of the stream.