Struct sc_client_api::notifications::StorageEventStream  
source · pub struct StorageEventStream<H>(/* private fields */);Expand description
Type that implements futures::Stream of storage change events.
Trait Implementations§
source§impl<H> Stream for StorageEventStream<H>
 
impl<H> Stream for StorageEventStream<H>
§type Item = StorageNotification<H>
 
type Item = StorageNotification<H>
Values yielded by the stream.
Auto Trait Implementations§
impl<H> !RefUnwindSafe for StorageEventStream<H>
impl<H> Send for StorageEventStream<H>where H: Send,
impl<H> Sync for StorageEventStream<H>where H: Send,
impl<H> Unpin for StorageEventStream<H>
impl<H> !UnwindSafe for StorageEventStream<H>
Blanket Implementations§
source§impl<T> BorrowMut<T> for Twhere
    T: ?Sized,
 
impl<T> BorrowMut<T> for Twhere T: ?Sized,
source§fn borrow_mut(&mut self) -> &mut T
 
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more
source§impl<T> CheckedConversion for T
 
impl<T> CheckedConversion for T
§impl<T> Instrument for T
 
impl<T> Instrument for T
§fn instrument(self, span: Span) -> Instrumented<Self>
 
fn instrument(self, span: Span) -> Instrumented<Self>
§fn in_current_span(self) -> Instrumented<Self>
 
fn in_current_span(self) -> Instrumented<Self>
source§impl<T, Outer> IsWrappedBy<Outer> for Twhere
    Outer: AsRef<T> + AsMut<T> + From<T>,
    T: From<Outer>,
 
impl<T, Outer> IsWrappedBy<Outer> for Twhere Outer: AsRef<T> + AsMut<T> + From<T>, T: From<Outer>,
§impl<T> Pointable for T
 
impl<T> Pointable for T
§impl<T> SaturatedConversion for T
 
impl<T> SaturatedConversion for T
§fn saturated_from<T>(t: T) -> Selfwhere
    Self: UniqueSaturatedFrom<T>,
 
fn saturated_from<T>(t: T) -> Selfwhere Self: UniqueSaturatedFrom<T>,
§fn saturated_into<T>(self) -> Twhere
    Self: UniqueSaturatedInto<T>,
 
fn saturated_into<T>(self) -> Twhere Self: UniqueSaturatedInto<T>,
Consume self to return an equivalent value of 
T. Read more§impl<T> StreamExt for Twhere
    T: Stream + ?Sized,
 
impl<T> StreamExt for Twhere T: Stream + ?Sized,
§fn next(&mut self) -> Next<'_, Self>where
    Self: Unpin,
 
fn next(&mut self) -> Next<'_, Self>where Self: Unpin,
Creates a future that resolves to the next item in the stream. Read more
§fn into_future(self) -> StreamFuture<Self>where
    Self: Sized + Unpin,
 
fn into_future(self) -> StreamFuture<Self>where Self: Sized + Unpin,
§fn map<T, F>(self, f: F) -> Map<Self, F>where
    F: FnMut(Self::Item) -> T,
    Self: Sized,
 
fn map<T, F>(self, f: F) -> Map<Self, F>where F: FnMut(Self::Item) -> T, Self: Sized,
Maps this stream’s items to a different type, returning a new stream of
the resulting type. Read more
§fn enumerate(self) -> Enumerate<Self>where
    Self: Sized,
 
fn enumerate(self) -> Enumerate<Self>where Self: Sized,
Creates a stream which gives the current iteration count as well as
the next value. Read more
§fn filter<Fut, F>(self, f: F) -> Filter<Self, Fut, F>where
    F: FnMut(&Self::Item) -> Fut,
    Fut: Future<Output = bool>,
    Self: Sized,
 
fn filter<Fut, F>(self, f: F) -> Filter<Self, Fut, F>where F: FnMut(&Self::Item) -> Fut, Fut: Future<Output = bool>, Self: Sized,
Filters the values produced by this stream according to the provided
asynchronous predicate. Read more
§fn filter_map<Fut, T, F>(self, f: F) -> FilterMap<Self, Fut, F>where
    F: FnMut(Self::Item) -> Fut,
    Fut: Future<Output = Option<T>>,
    Self: Sized,
 
fn filter_map<Fut, T, F>(self, f: F) -> FilterMap<Self, Fut, F>where F: FnMut(Self::Item) -> Fut, Fut: Future<Output = Option<T>>, Self: Sized,
Filters the values produced by this stream while simultaneously mapping
them to a different type according to the provided asynchronous closure. Read more
§fn then<Fut, F>(self, f: F) -> Then<Self, Fut, F>where
    F: FnMut(Self::Item) -> Fut,
    Fut: Future,
    Self: Sized,
 
fn then<Fut, F>(self, f: F) -> Then<Self, Fut, F>where F: FnMut(Self::Item) -> Fut, Fut: Future, Self: Sized,
Computes from this stream’s items new items of a different type using
an asynchronous closure. Read more
§fn collect<C>(self) -> Collect<Self, C>where
    C: Default + Extend<Self::Item>,
    Self: Sized,
 
fn collect<C>(self) -> Collect<Self, C>where C: Default + Extend<Self::Item>, Self: Sized,
Transforms a stream into a collection, returning a
future representing the result of that computation. Read more
§fn unzip<A, B, FromA, FromB>(self) -> Unzip<Self, FromA, FromB>where
    FromA: Default + Extend<A>,
    FromB: Default + Extend<B>,
    Self: Sized + Stream<Item = (A, B)>,
 
fn unzip<A, B, FromA, FromB>(self) -> Unzip<Self, FromA, FromB>where FromA: Default + Extend<A>, FromB: Default + Extend<B>, Self: Sized + Stream<Item = (A, B)>,
Converts a stream of pairs into a future, which
resolves to pair of containers. Read more
§fn concat(self) -> Concat<Self>where
    Self: Sized,
    Self::Item: Extend<<Self::Item as IntoIterator>::Item> + IntoIterator + Default,
 
fn concat(self) -> Concat<Self>where Self: Sized, Self::Item: Extend<<Self::Item as IntoIterator>::Item> + IntoIterator + Default,
Concatenate all items of a stream into a single extendable
destination, returning a future representing the end result. Read more
§fn count(self) -> Count<Self>where
    Self: Sized,
 
fn count(self) -> Count<Self>where Self: Sized,
Drives the stream to completion, counting the number of items. Read more
§fn fold<T, Fut, F>(self, init: T, f: F) -> Fold<Self, Fut, T, F>where
    F: FnMut(T, Self::Item) -> Fut,
    Fut: Future<Output = T>,
    Self: Sized,
 
fn fold<T, Fut, F>(self, init: T, f: F) -> Fold<Self, Fut, T, F>where F: FnMut(T, Self::Item) -> Fut, Fut: Future<Output = T>, Self: Sized,
Execute an accumulating asynchronous computation over a stream,
collecting all the values into one final result. Read more
§fn any<Fut, F>(self, f: F) -> Any<Self, Fut, F>where
    F: FnMut(Self::Item) -> Fut,
    Fut: Future<Output = bool>,
    Self: Sized,
 
fn any<Fut, F>(self, f: F) -> Any<Self, Fut, F>where F: FnMut(Self::Item) -> Fut, Fut: Future<Output = bool>, Self: Sized,
Execute predicate over asynchronous stream, and return 
true if any element in stream satisfied a predicate. Read more§fn all<Fut, F>(self, f: F) -> All<Self, Fut, F>where
    F: FnMut(Self::Item) -> Fut,
    Fut: Future<Output = bool>,
    Self: Sized,
 
fn all<Fut, F>(self, f: F) -> All<Self, Fut, F>where F: FnMut(Self::Item) -> Fut, Fut: Future<Output = bool>, Self: Sized,
Execute predicate over asynchronous stream, and return 
true if all element in stream satisfied a predicate. Read more§fn flatten(self) -> Flatten<Self>where
    Self::Item: Stream,
    Self: Sized,
 
fn flatten(self) -> Flatten<Self>where Self::Item: Stream, Self: Sized,
Flattens a stream of streams into just one continuous stream. Read more
§fn flatten_unordered(
    self,
    limit: impl Into<Option<usize>>
) -> FlattenUnorderedWithFlowController<Self, ()>where
    Self::Item: Stream + Unpin,
    Self: Sized,
 
fn flatten_unordered( self, limit: impl Into<Option<usize>> ) -> FlattenUnorderedWithFlowController<Self, ()>where Self::Item: Stream + Unpin, Self: Sized,
Flattens a stream of streams into just one continuous stream. Polls
inner streams produced by the base stream concurrently. Read more
§fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>where
    F: FnMut(Self::Item) -> U,
    U: Stream,
    Self: Sized,
 
fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>where F: FnMut(Self::Item) -> U, U: Stream, Self: Sized,
§fn flat_map_unordered<U, F>(
    self,
    limit: impl Into<Option<usize>>,
    f: F
) -> FlatMapUnordered<Self, U, F>where
    U: Stream + Unpin,
    F: FnMut(Self::Item) -> U,
    Self: Sized,
 
fn flat_map_unordered<U, F>( self, limit: impl Into<Option<usize>>, f: F ) -> FlatMapUnordered<Self, U, F>where U: Stream + Unpin, F: FnMut(Self::Item) -> U, Self: Sized,
Maps a stream like [
StreamExt::map] but flattens nested Streams
and polls them concurrently, yielding items in any order, as they made
available. Read more§fn scan<S, B, Fut, F>(self, initial_state: S, f: F) -> Scan<Self, S, Fut, F>where
    F: FnMut(&mut S, Self::Item) -> Fut,
    Fut: Future<Output = Option<B>>,
    Self: Sized,
 
fn scan<S, B, Fut, F>(self, initial_state: S, f: F) -> Scan<Self, S, Fut, F>where F: FnMut(&mut S, Self::Item) -> Fut, Fut: Future<Output = Option<B>>, Self: Sized,
Combinator similar to [
StreamExt::fold] that holds internal state
and produces a new stream. Read more§fn skip_while<Fut, F>(self, f: F) -> SkipWhile<Self, Fut, F>where
    F: FnMut(&Self::Item) -> Fut,
    Fut: Future<Output = bool>,
    Self: Sized,
 
fn skip_while<Fut, F>(self, f: F) -> SkipWhile<Self, Fut, F>where F: FnMut(&Self::Item) -> Fut, Fut: Future<Output = bool>, Self: Sized,
Skip elements on this stream while the provided asynchronous predicate
resolves to 
true. Read more§fn take_while<Fut, F>(self, f: F) -> TakeWhile<Self, Fut, F>where
    F: FnMut(&Self::Item) -> Fut,
    Fut: Future<Output = bool>,
    Self: Sized,
 
fn take_while<Fut, F>(self, f: F) -> TakeWhile<Self, Fut, F>where F: FnMut(&Self::Item) -> Fut, Fut: Future<Output = bool>, Self: Sized,
Take elements from this stream while the provided asynchronous predicate
resolves to 
true. Read more§fn take_until<Fut>(self, fut: Fut) -> TakeUntil<Self, Fut>where
    Fut: Future,
    Self: Sized,
 
fn take_until<Fut>(self, fut: Fut) -> TakeUntil<Self, Fut>where Fut: Future, Self: Sized,
Take elements from this stream until the provided future resolves. Read more
§fn for_each<Fut, F>(self, f: F) -> ForEach<Self, Fut, F>where
    F: FnMut(Self::Item) -> Fut,
    Fut: Future<Output = ()>,
    Self: Sized,
 
fn for_each<Fut, F>(self, f: F) -> ForEach<Self, Fut, F>where F: FnMut(Self::Item) -> Fut, Fut: Future<Output = ()>, Self: Sized,
Runs this stream to completion, executing the provided asynchronous
closure for each element on the stream. Read more
§fn for_each_concurrent<Fut, F>(
    self,
    limit: impl Into<Option<usize>>,
    f: F
) -> ForEachConcurrent<Self, Fut, F>where
    F: FnMut(Self::Item) -> Fut,
    Fut: Future<Output = ()>,
    Self: Sized,
 
fn for_each_concurrent<Fut, F>( self, limit: impl Into<Option<usize>>, f: F ) -> ForEachConcurrent<Self, Fut, F>where F: FnMut(Self::Item) -> Fut, Fut: Future<Output = ()>, Self: Sized,
Runs this stream to completion, executing the provided asynchronous
closure for each element on the stream concurrently as elements become
available. Read more
§fn take(self, n: usize) -> Take<Self>where
    Self: Sized,
 
fn take(self, n: usize) -> Take<Self>where Self: Sized,
Creates a new stream of at most 
n items of the underlying stream. Read more§fn skip(self, n: usize) -> Skip<Self>where
    Self: Sized,
 
fn skip(self, n: usize) -> Skip<Self>where Self: Sized,
Creates a new stream which skips 
n items of the underlying stream. Read more§fn catch_unwind(self) -> CatchUnwind<Self>where
    Self: Sized + UnwindSafe,
 
fn catch_unwind(self) -> CatchUnwind<Self>where Self: Sized + UnwindSafe,
Catches unwinding panics while polling the stream. Read more
§fn boxed<'a>(self) -> Pin<Box<dyn Stream<Item = Self::Item> + Send + 'a>>where
    Self: Sized + Send + 'a,
 
fn boxed<'a>(self) -> Pin<Box<dyn Stream<Item = Self::Item> + Send + 'a>>where Self: Sized + Send + 'a,
Wrap the stream in a Box, pinning it. Read more
§fn boxed_local<'a>(self) -> Pin<Box<dyn Stream<Item = Self::Item> + 'a>>where
    Self: Sized + 'a,
 
fn boxed_local<'a>(self) -> Pin<Box<dyn Stream<Item = Self::Item> + 'a>>where Self: Sized + 'a,
Wrap the stream in a Box, pinning it. Read more
§fn buffered(self, n: usize) -> Buffered<Self>where
    Self::Item: Future,
    Self: Sized,
 
fn buffered(self, n: usize) -> Buffered<Self>where Self::Item: Future, Self: Sized,
An adaptor for creating a buffered list of pending futures. Read more
§fn buffer_unordered(self, n: usize) -> BufferUnordered<Self>where
    Self::Item: Future,
    Self: Sized,
 
fn buffer_unordered(self, n: usize) -> BufferUnordered<Self>where Self::Item: Future, Self: Sized,
An adaptor for creating a buffered list of pending futures (unordered). Read more
§fn zip<St>(self, other: St) -> Zip<Self, St>where
    St: Stream,
    Self: Sized,
 
fn zip<St>(self, other: St) -> Zip<Self, St>where St: Stream, Self: Sized,
An adapter for zipping two streams together. Read more
§fn chain<St>(self, other: St) -> Chain<Self, St>where
    St: Stream<Item = Self::Item>,
    Self: Sized,
 
fn chain<St>(self, other: St) -> Chain<Self, St>where St: Stream<Item = Self::Item>, Self: Sized,
Adapter for chaining two streams. Read more
§fn peekable(self) -> Peekable<Self>where
    Self: Sized,
 
fn peekable(self) -> Peekable<Self>where Self: Sized,
Creates a new stream which exposes a 
peek method. Read more§fn chunks(self, capacity: usize) -> Chunks<Self>where
    Self: Sized,
 
fn chunks(self, capacity: usize) -> Chunks<Self>where Self: Sized,
An adaptor for chunking up items of the stream inside a vector. Read more
§fn ready_chunks(self, capacity: usize) -> ReadyChunks<Self>where
    Self: Sized,
 
fn ready_chunks(self, capacity: usize) -> ReadyChunks<Self>where Self: Sized,
An adaptor for chunking up ready items of the stream inside a vector. Read more
§fn forward<S>(self, sink: S) -> Forward<Self, S>where
    S: Sink<Self::Ok, Error = Self::Error>,
    Self: TryStream + Sized,
 
fn forward<S>(self, sink: S) -> Forward<Self, S>where S: Sink<Self::Ok, Error = Self::Error>, Self: TryStream + Sized,
A future that completes after the given stream has been fully processed
into the sink and the sink has been flushed and closed. Read more
§fn inspect<F>(self, f: F) -> Inspect<Self, F>where
    F: FnMut(&Self::Item),
    Self: Sized,
 
fn inspect<F>(self, f: F) -> Inspect<Self, F>where F: FnMut(&Self::Item), Self: Sized,
Do something with each item of this stream, afterwards passing it on. Read more
§fn left_stream<B>(self) -> Either<Self, B>where
    B: Stream<Item = Self::Item>,
    Self: Sized,
 
fn left_stream<B>(self) -> Either<Self, B>where B: Stream<Item = Self::Item>, Self: Sized,
§fn right_stream<B>(self) -> Either<B, Self>where
    B: Stream<Item = Self::Item>,
    Self: Sized,
 
fn right_stream<B>(self) -> Either<B, Self>where B: Stream<Item = Self::Item>, Self: Sized,
§fn poll_next_unpin(&mut self, cx: &mut Context<'_>) -> Poll<Option<Self::Item>>where
    Self: Unpin,
 
fn poll_next_unpin(&mut self, cx: &mut Context<'_>) -> Poll<Option<Self::Item>>where Self: Unpin,
A convenience method for calling [
Stream::poll_next] on Unpin
stream types.§fn select_next_some(&mut self) -> SelectNextSome<'_, Self>where
    Self: Unpin + FusedStream,
 
fn select_next_some(&mut self) -> SelectNextSome<'_, Self>where Self: Unpin + FusedStream,
source§impl<S, T> UncheckedInto<T> for Swhere
    T: UncheckedFrom<S>,
 
impl<S, T> UncheckedInto<T> for Swhere T: UncheckedFrom<S>,
source§fn unchecked_into(self) -> T
 
fn unchecked_into(self) -> T
The counterpart to 
unchecked_from.§impl<T, S> UniqueSaturatedInto<T> for Swhere
    T: Bounded,
    S: TryInto<T>,
 
impl<T, S> UniqueSaturatedInto<T> for Swhere T: Bounded, S: TryInto<T>,
§fn unique_saturated_into(self) -> T
 
fn unique_saturated_into(self) -> T
Consume self to return an equivalent value of 
T.