Struct Limit

pub struct Limit<S, L>
where
    S: Stream,
    S::Item: VectorDiffContainer,
{ /* private fields */ }

A VectorDiff stream adapter that presents a limited view of the underlying ObservableVectors items.

For example, let S be a Stream<Item = VectorDiff>. The Vector represented by S can have any length, but one may want to virtually limit this Vector to a certain size. Then this Limit adapter is appropriate.

An internal buffered vector is kept so that the adapter knows which values can be added when the limit is increased, or when values are removed and new values must be inserted. This fact is important if the items of the Vector have a non-negligible size.

It’s okay to have a limit larger than the length of the observed Vector.

Implementations

impl<S> Limit<S, EmptyLimitStream>

where S: Stream, S::Item: VectorDiffContainer,

pub fn new( initial_values: Vector<VectorDiffContainerStreamElement<S>>, inner_stream: S, limit: usize, ) -> (Vector<VectorDiffContainerStreamElement<S>>, Self)

Create a new Limit with the given (unlimited) initial values, stream of VectorDiff updates for those values, and a fixed limit.

Returns the truncated initial values as well as a stream of updates that ensure that the resulting vector never exceeds the given limit.

impl<S, L> Limit<S, L>

where S: Stream, S::Item: VectorDiffContainer, L: Stream<Item = usize>,

pub fn dynamic( initial_values: Vector<VectorDiffContainerStreamElement<S>>, inner_stream: S, limit_stream: L, ) -> Self

Create a new Limit with the given (unlimited) initial values, stream of VectorDiff updates for those values, and a stream of limits.

This is equivalent to dynamic_with_initial_limit where the initial_limit is 0, except that it doesn’t return the limited vector as it would be empty anyways.

Note that the returned Limit won’t produce anything until the first limit is produced by the limit stream.

pub fn dynamic_with_initial_limit( initial_values: Vector<VectorDiffContainerStreamElement<S>>, inner_stream: S, initial_limit: usize, limit_stream: L, ) -> (Vector<VectorDiffContainerStreamElement<S>>, Self)

Create a new Limit with the given (unlimited) initial values, stream of VectorDiff updates for those values, and an initial limit as well as a stream of new limits.

Trait Implementations

impl<S, L> Stream for Limit<S, L>

where S: Stream, S::Item: VectorDiffContainer, L: Stream<Item = usize>,

type Item = <S as Stream>::Item

Values yielded by the stream.

fn poll_next( self: Pin<&mut Self>, cx: &mut Context<'_>, ) -> Poll<Option<Self::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.

impl<'__pin, S, L> Unpin for Limit<S, L>

where PinnedFieldsOf<__Origin<'__pin, S, L>>: Unpin, S: Stream, S::Item: VectorDiffContainer,

impl<S, L> VectorObserver<<<S as Stream>::Item as VectorDiffContainer>::Element> for Limit<S, L>

where S: Stream, S::Item: VectorDiffContainer, L: Stream<Item = usize>,