Trait futures_signals::signal_vec::SignalVec

pub trait SignalVec {
    type Item;

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

Required 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> SignalVec for &'a mut A where
    A: ?Sized + SignalVec + Unpin, 

type Item = <A as SignalVec>::Item

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

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

type Item = <A as SignalVec>::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

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

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

impl<A> SignalVec for MutableSignalVec<A>

type Item = A

impl<A> SignalVec for SignalVecDebug<A> where
    A: SignalVec,
    A::Item: Debug, 

type Item = <A as SignalVec>::Item

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

type Item = B

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

type Item = <B as SignalVec>::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 as SignalVec>::Item

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

type Item = B

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

type Item = <B as Signal>::Item

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

type Item = <A as SignalVec>::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 as SignalVec>::Item

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

type Item = (K, V)

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

type Item = K

impl<S> SignalVec for StreamSignalVec<S> where
    S: Stream, 

type Item = <S as Stream>::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 as SignalVec>::Item

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

type Item = A