Struct Sort

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

A VectorDiff stream adapter that presents a sorted view of the underlying ObservableVector items.

use eyeball_im::{ObservableVector, VectorDiff};
use eyeball_im_util::vector::VectorObserverExt;
use imbl::vector;
use stream_assert::{assert_closed, assert_next_eq, assert_pending};

// Our vector.
let mut ob = ObservableVector::<char>::new();
let (values, mut sub) = ob.subscribe().sort();

assert!(values.is_empty());
assert_pending!(sub);

// Append multiple unsorted values.
ob.append(vector!['d', 'b', 'e']);
// We get a `VectorDiff::Append` with sorted values!
assert_next_eq!(sub, VectorDiff::Append { values: vector!['b', 'd', 'e'] });

// Let's recap what we have. `ob` is our `ObservableVector`,
// `sub` is the “sorted view” / “sorted stream” of `ob`:
// | `ob`  | d b e |
// | `sub` | b d e |

// Append multiple other values.
ob.append(vector!['f', 'g', 'a', 'c']);
// We get three `VectorDiff`s!
assert_next_eq!(sub, VectorDiff::PushFront { value: 'a' });
assert_next_eq!(sub, VectorDiff::Insert { index: 2, value: 'c' });
assert_next_eq!(sub, VectorDiff::Append { values: vector!['f', 'g'] });

// Let's recap what we have:
// | `ob`  | d b e f g a c |
// | `sub` | a b c d e f g |
//           ^   ^     ^^^
//           |   |     |
//           |   |     with `VectorDiff::Append { .. }`
//           |   with `VectorDiff::Insert { index: 2, .. }`
//           with `VectorDiff::PushFront { .. }`

// Technically, `Sort` emits `VectorDiff`s that mimic a sorted `Vector`.

drop(ob);
assert_closed!(sub);

Implementations

impl<S> Sort<S>

where S: Stream, S::Item: VectorDiffContainer, VectorDiffContainerStreamElement<S>: Ord,

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

Create a new Sort with the given (unsorted) initial values and stream of VectorDiff updates for those values.

Trait Implementations

impl<S> Stream for Sort<S>

where S: Stream, S::Item: VectorDiffContainer, VectorDiffContainerStreamElement<S>: Ord,

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> Unpin for Sort<S>

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