Trait pinwheel::signal_vec::SignalVec

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

type Item = <A as SignalVec>::Item

pub fn poll_vec_change(
    self: Pin<&mut &'a mut A>,
    cx: &mut Context<'_>
) -> Poll<Option<VecDiff<<&'a mut A as SignalVec>::Item>>>

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

type Item = (K, V)

pub fn poll_vec_change(
    self: Pin<&mut MutableBTreeMapEntries<K, V>>,
    cx: &mut Context<'_>
) -> Poll<Option<VecDiff<<MutableBTreeMapEntries<K, V> as SignalVec>::Item>>>

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

type Item = K

pub fn poll_vec_change(
    self: Pin<&mut MutableBTreeMapKeys<K, V>>,
    cx: &mut Context<'_>
) -> Poll<Option<VecDiff<<MutableBTreeMapKeys<K, V> as SignalVec>::Item>>>

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

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

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

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

type Item = <A as SignalVec>::Item

pub fn poll_vec_change(
    self: Pin<&mut Box<A, Global>>,
    cx: &mut Context<'_>
) -> Poll<Option<VecDiff<<Box<A, Global> as SignalVec>::Item>>>

Implementors

impl<A> SignalVec for Always<A>

type Item = A

pub fn poll_vec_change(
    self: Pin<&mut Always<A>>,
    _cx: &mut Context<'_>
) -> Poll<Option<VecDiff<<Always<A> as SignalVec>::Item>>>

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

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

pub fn poll_vec_change(
    self: Pin<&mut Enumerate<A>>,
    cx: &mut Context<'_>
) -> Poll<Option<VecDiff<<Enumerate<A> as SignalVec>::Item>>>

impl<A> SignalVec for MutableSignalVec<A>

type Item = A

pub fn poll_vec_change(
    self: Pin<&mut MutableSignalVec<A>>,
    cx: &mut Context<'_>
) -> Poll<Option<VecDiff<<MutableSignalVec<A> as SignalVec>::Item>>>

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

type Item = B

pub fn poll_vec_change(
    self: Pin<&mut SignalSignalVec<A>>,
    cx: &mut Context<'_>
) -> Poll<Option<VecDiff<<SignalSignalVec<A> as SignalVec>::Item>>>

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

type Item = <B as SignalVec>::Item

pub fn poll_vec_change(
    self: Pin<&mut SwitchSignalVec<A, B, C>>,
    cx: &mut Context<'_>
) -> Poll<Option<VecDiff<<SwitchSignalVec<A, B, C> as SignalVec>::Item>>>

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

type Item = <A as SignalVec>::Item

pub fn poll_vec_change(
    self: Pin<&mut FilterSignalCloned<A, B, F>>,
    cx: &mut Context<'_>
) -> Poll<Option<VecDiff<<FilterSignalCloned<A, B, F> as SignalVec>::Item>>>

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

type Item = B

pub fn poll_vec_change(
    self: Pin<&mut Map<A, F>>,
    cx: &mut Context<'_>
) -> Poll<Option<VecDiff<<Map<A, F> as SignalVec>::Item>>>

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

type Item = <B as Signal>::Item

pub fn poll_vec_change(
    self: Pin<&mut MapSignal<A, B, F>>,
    cx: &mut Context<'_>
) -> Poll<Option<VecDiff<<MapSignal<A, B, F> as SignalVec>::Item>>>

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

type Item = <A as SignalVec>::Item

pub fn poll_vec_change(
    self: Pin<&mut Filter<A, F>>,
    cx: &mut Context<'_>
) -> Poll<Option<VecDiff<<Filter<A, F> as SignalVec>::Item>>>

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

type Item = <A as SignalVec>::Item

pub fn poll_vec_change(
    self: Pin<&mut SortByCloned<A, F>>,
    cx: &mut Context<'_>
) -> Poll<Option<VecDiff<<SortByCloned<A, F> as SignalVec>::Item>>>

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

type Item = <S as SignalVec>::Item

pub fn poll_vec_change(
    self: Pin<&mut DelayRemove<S, A, F>>,
    cx: &mut Context<'_>
) -> Poll<Option<VecDiff<<DelayRemove<S, A, F> as SignalVec>::Item>>>

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

type Item = A

pub fn poll_vec_change(
    self: Pin<&mut FilterMap<S, F>>,
    cx: &mut Context<'_>
) -> Poll<Option<VecDiff<<FilterMap<S, F> as SignalVec>::Item>>>