Trait futures_signals::signal_vec::SignalVec

#[must_use = "SignalVecs do nothing unless polled"]
pub trait SignalVec {
    type Item;
    fn poll_vec_change(
        self: Pin<&mut Self>, 
        cx: &mut Context<'_>
    ) -> Poll<Option<VecDiff<Self::Item>>>;
}

Associated Types

type Item

Required methods

fn poll_vec_change(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>
) -> Poll<Option<VecDiff<Self::Item>>>

Implementations on Foreign Types

impl<'a, A: ?Sized> SignalVec for &'a mut A where
    A: SignalVec + Unpin, 

type Item = A::Item

fn poll_vec_change(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>
) -> Poll<Option<VecDiff<Self::Item>>>

impl<A: ?Sized> SignalVec for Box<A> where
    A: SignalVec + Unpin, 

type Item = A::Item

fn poll_vec_change(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>
) -> Poll<Option<VecDiff<Self::Item>>>

impl<A> SignalVec for Pin<A> where
    A: Unpin + DerefMut,
    A::Target: SignalVec, 

type Item = <<A as Deref>::Target as SignalVec>::Item

fn poll_vec_change(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>
) -> Poll<Option<VecDiff<Self::Item>>>

Implementors

impl<A> SignalVec for Always<A>

type Item = A

fn poll_vec_change(
    self: Pin<&mut Self>,
    _cx: &mut Context<'_>
) -> Poll<Option<VecDiff<Self::Item>>>

impl<A> SignalVec for Enumerate<A> where
    A: SignalVec, 

type Item = (ReadOnlyMutable<Option<usize>>, A::Item)

fn poll_vec_change(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>
) -> Poll<Option<VecDiff<Self::Item>>>

impl<A> SignalVec for MutableSignalVec<A>

type Item = A

fn poll_vec_change(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>
) -> Poll<Option<VecDiff<Self::Item>>>

impl<A, B> SignalVec for SignalSignalVec<A> where
    A: Signal<Item = Vec<B>>, 

type Item = B

fn poll_vec_change(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>
) -> Poll<Option<VecDiff<Self::Item>>>

impl<A, B, C> SignalVec for SwitchSignalVec<A, B, C> where
    A: Signal,
    B: SignalVec,
    C: FnMut(A::Item) -> B, 

type Item = B::Item

fn poll_vec_change(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>
) -> Poll<Option<VecDiff<Self::Item>>>

impl<A, B, F> SignalVec for FilterSignalCloned<A, B, F> where
    A: SignalVec,
    A::Item: Clone,
    B: Signal<Item = bool>,
    F: FnMut(&A::Item) -> B, 

type Item = A::Item

fn poll_vec_change(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>
) -> Poll<Option<VecDiff<Self::Item>>>

impl<A, B, F> SignalVec for Map<A, F> where
    A: SignalVec,
    F: FnMut(A::Item) -> B, 

type Item = B

fn poll_vec_change(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>
) -> Poll<Option<VecDiff<Self::Item>>>

impl<A, B, F> SignalVec for MapSignal<A, B, F> where
    A: SignalVec,
    B: Signal,
    F: FnMut(A::Item) -> B, 

type Item = B::Item

fn poll_vec_change(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>
) -> Poll<Option<VecDiff<Self::Item>>>

impl<A, F> SignalVec for Filter<A, F> where
    A: SignalVec,
    F: FnMut(&A::Item) -> bool, 

type Item = A::Item

fn poll_vec_change(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>
) -> Poll<Option<VecDiff<Self::Item>>>

impl<A, F> SignalVec for SortByCloned<A, F> where
    A: SignalVec,
    F: FnMut(&A::Item, &A::Item) -> Ordering,
    A::Item: Clone, 

type Item = A::Item

fn poll_vec_change(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>
) -> Poll<Option<VecDiff<Self::Item>>>

impl<K, V> SignalVec for MutableBTreeMapEntries<K, V> where
    K: Ord + Clone, 

type Item = (K, V)

fn poll_vec_change(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>
) -> Poll<Option<VecDiff<Self::Item>>>

impl<K, V> SignalVec for MutableBTreeMapKeys<K, V> where
    K: Ord + Clone, 

type Item = K

fn poll_vec_change(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>
) -> Poll<Option<VecDiff<Self::Item>>>

impl<S, A, F> SignalVec for DelayRemove<S, A, F> where
    S: SignalVec,
    A: Future<Output = ()>,
    F: FnMut(&S::Item) -> A, 

type Item = S::Item

fn poll_vec_change(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>
) -> Poll<Option<VecDiff<Self::Item>>>

impl<S, A, F> SignalVec for FilterMap<S, F> where
    S: SignalVec,
    F: FnMut(S::Item) -> Option<A>, 

type Item = A

fn poll_vec_change(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>
) -> Poll<Option<VecDiff<Self::Item>>>