Trait rxrust::shared::SharedObservable

pub trait SharedObservable: Observable {
    type Unsub: SubscriptionLike + Sync + Send + 'static;
    fn actual_subscribe<O>(self, observer: O) -> Self::Unsub
    where
        O: Observer<Item = Self::Item, Err = Self::Err> + Sync + Send + 'static;

    fn into_shared(self) -> Shared<Self>
    where
        Self: Sized,
    { ... }
}

Associated Types

type Unsub: SubscriptionLike + Sync + Send + 'static

Required methods

fn actual_subscribe<O>(self, observer: O) -> Self::Unsub where
    O: Observer<Item = Self::Item, Err = Self::Err> + Sync + Send + 'static, 

Provided methods

fn into_shared(self) -> Shared<Self> where
    Self: Sized, 

Convert to a thread-safe mode.

Implementors

impl SharedObservable for NeverObservable

type Unsub = SingleSubscription

impl<'a, Source, Discr, Key> SharedObservable for GroupByOp<Source, Discr> where
    Source: SharedObservable + Clone + Send + Sync + 'static,
    Source::Item: Send + Sync + 'static,
    Discr: FnMut(&Source::Item) -> Key + Clone + Send + Sync + 'static,
    Key: 'a + Hash + Clone + Eq + Send + Sync + 'static, 

type Unsub = Source::Unsub

impl<A, B> SharedObservable for WithLatestFromOp<A, B> where
    A: SharedObservable,
    B: SharedObservable<Err = A::Err>,
    A::Unsub: 'static,
    B::Unsub: 'static,
    A::Item: 'static,
    B::Item: Clone + Send + Sync + 'static, 

type Unsub = RcMultiSubscription

impl<A, B> SharedObservable for ZipOp<A, B> where
    A: SharedObservable,
    B: SharedObservable<Err = A::Err>,
    A::Item: Send + Sync + 'static,
    B::Item: Send + Sync + 'static,
    A::Unsub: 'static + Send + Sync,
    B::Unsub: 'static + Send + Sync, 

type Unsub = RcMultiSubscription

impl<A, B, BinaryOp, OutputItem> SharedObservable for CombineLatestOp<A, B, BinaryOp> where
    A: SharedObservable,
    B: SharedObservable<Err = A::Err>,
    BinaryOp: FnMut(A::Item, B::Item) -> OutputItem + Send + Sync + 'static,
    A::Item: Clone + Send + Sync + 'static,
    B::Item: Clone + Send + Sync + 'static,
    A::Unsub: 'static,
    B::Unsub: 'static, 

type Unsub = RcMultiSubscription

impl<B, S> SharedObservable for MapToOp<S, B> where
    S: SharedObservable,
    B: Clone + Send + Sync + 'static,
    S::Item: 'static, 

type Unsub = S::Unsub

impl<Err> SharedObservable for ThrowObservable<Err>

type Unsub = SingleSubscription

impl<F, Item, Err> SharedObservable for ObservableFn<F, Item, Err> where
    F: FnOnce(&mut dyn Observer<Item = Item, Err = Err>), 

type Unsub = SingleSubscription

impl<F, U> SharedObservable for ObservableDeref<F> where
    F: FnOnce() -> U,
    U: SharedObservable, 

type Unsub = U::Unsub

impl<Item> SharedObservable for OfObservable<Item>

type Unsub = SingleSubscription

impl<Item> SharedObservable for OptionObservable<Item>

type Unsub = SingleSubscription

impl<Item> SharedObservable for StartObservable<Item>

type Unsub = SingleSubscription

impl<Item> SharedObservable for EmptyObservable<Item>

type Unsub = SingleSubscription

impl<Item, Err> SharedObservable for ResultObservable<Item, Err>

type Unsub = SingleSubscription

impl<Item, Err> SharedObservable for SharedBoxOp<Item, Err>

type Unsub = Box<dyn SubscriptionLike + Send + Sync>

impl<Item, Err> SharedObservable for SharedCloneBoxOp<Item, Err>

type Unsub = Box<dyn SubscriptionLike + Send + Sync>

impl<Item, Err> SharedObservable for SharedBehaviorSubject<Item, Err> where
    Item: Clone,
    Err: Clone, 

type Unsub = MutArc<SingleSubscription>

impl<Item, Err> SharedObservable for SharedSubject<Item, Err>

type Unsub = MutArc<SingleSubscription>

impl<Item, F> SharedObservable for CallableObservable<F> where
    F: FnOnce() -> Item, 

type Unsub = SingleSubscription

impl<Item, S> SharedObservable for TimerObservable<Item, S> where
    S: Scheduler + 'static,
    Item: Send + 'static, 

type Unsub = SpawnHandle

impl<Item, S> SharedObservable for ContainsOp<S, Item> where
    S: SharedObservable<Item = Item>,
    Item: Send + Sync + 'static + Clone + Eq, 

type Unsub = S::Unsub

impl<Item, S> SharedObservable for LastOp<S, Item> where
    S: SharedObservable<Item = Item>,
    Item: Send + Sync + 'static + Clone, 

type Unsub = S::Unsub

impl<Item, S, F> SharedObservable for FilterMapOp<S, F> where
    S: SharedObservable,
    F: FnMut(S::Item) -> Option<Item> + Send + Sync + 'static,
    S::Item: 'static, 

type Unsub = S::Unsub

impl<Item, S, M> SharedObservable for MapOp<S, M> where
    S: SharedObservable,
    S::Item: 'static,
    M: FnMut(S::Item) -> Item + Send + Sync + 'static, 

type Unsub = S::Unsub

impl<Outer, Inner> SharedObservable for FlattenOp<Outer, Inner> where
    Inner: SharedObservable + Send + Sync + 'static,
    Outer: SharedObservable<Item = Inner, Err = Inner::Err>,
    Inner::Unsub: 'static,
    Outer::Unsub: 'static, 

type Unsub = RcMultiSubscription

impl<OutputItem, Source, BinaryOp> SharedObservable for ScanOp<Source, BinaryOp, OutputItem> where
    Source: SharedObservable,
    OutputItem: Clone + Send + Sync + 'static,
    Source::Item: 'static,
    BinaryOp: FnMut(OutputItem, Source::Item) -> OutputItem + Send + Sync + 'static, 

type Unsub = Source::Unsub

impl<S1, S2> SharedObservable for MergeOp<S1, S2> where
    S1: SharedObservable,
    S2: SharedObservable<Item = S1::Item, Err = S1::Err>,
    S1::Unsub: 'static,
    S2::Unsub: 'static, 

type Unsub = RcMultiSubscription

impl<S> SharedObservable for IntervalObservable<S> where
    S: Scheduler + 'static, 

type Unsub = SpawnHandle

impl<S> SharedObservable for BufferWithCountOp<S> where
    S: SharedObservable,
    S::Item: Send + Sync + 'static, 

type Unsub = S::Unsub

impl<S> SharedObservable for DefaultIfEmptyOp<S> where
    S: SharedObservable,
    S::Item: Clone + Send + Sync + 'static, 

type Unsub = S::Unsub

impl<S> SharedObservable for DistinctOp<S> where
    S: SharedObservable,
    S::Item: Eq + Hash + Clone + Send + Sync + 'static, 

type Unsub = S::Unsub

impl<S> SharedObservable for DistinctUntilChangedOp<S> where
    S: SharedObservable,
    S::Item: Eq + Clone + Send + Sync + 'static, 

type Unsub = S::Unsub

impl<S> SharedObservable for MergeAllOp<S> where
    S: SharedObservable,
    S::Err: Send + Sync + 'static,
    S::Item: SharedObservable<Err = S::Err> + Send + Sync + 'static,
    <S::Item as SharedObservable>::Unsub: Send + Sync + 'static,
    Self::Item: Send + Sync + 'static, 

type Unsub = S::Unsub

impl<S> SharedObservable for PairwiseOp<S> where
    S: SharedObservable,
    S::Item: Clone + Send + Sync + 'static, 

type Unsub = S::Unsub

impl<S> SharedObservable for SkipOp<S> where
    S: SharedObservable, 

type Unsub = Rc<ProxySubscription<S::Unsub>>

impl<S> SharedObservable for SkipLastOp<S> where
    S::Item: Send + Sync + 'static,
    S: SharedObservable, 

type Unsub = S::Unsub

impl<S> SharedObservable for TakeOp<S> where
    S: SharedObservable, 

type Unsub = Rc<ProxySubscription<S::Unsub>>

impl<S> SharedObservable for TakeLastOp<S> where
    S::Item: Send + Sync + 'static,
    S: SharedObservable, 

type Unsub = S::Unsub

impl<S> SharedObservable for Shared<S> where
    S: SharedObservable, 

type Unsub = S::Unsub

impl<S, B> SharedObservable for StartWithOp<S, B> where
    S: SharedObservable<Item = B>,
    B: Clone + Into<S::Item> + Send + Sync + 'static,
    S::Item: 'static, 

type Unsub = S::Unsub

impl<S, F> SharedObservable for FilterOp<S, F> where
    S: SharedObservable,
    F: FnMut(&S::Item) -> bool + Send + Sync + 'static, 

type Unsub = S::Unsub

impl<S, F> SharedObservable for FinalizeOp<S, F> where
    S: SharedObservable,
    F: FnMut() + Send + Sync + 'static,
    S::Unsub: Send + Sync, 

type Unsub = FinalizerSubscription<S::Unsub, Arc<Mutex<Option<F>>>>

impl<S, F> SharedObservable for SkipUntilOp<S, F> where
    S: SharedObservable,
    F: FnMut(&S::Item) -> bool + Send + Sync + 'static, 

type Unsub = S::Unsub

impl<S, F> SharedObservable for SkipWhileOp<S, F> where
    S: SharedObservable,
    F: FnMut(&S::Item) -> bool + Send + Sync + 'static, 

type Unsub = S::Unsub

impl<S, F> SharedObservable for TakeWhileOp<S, F> where
    S: SharedObservable,
    F: FnMut(&S::Item) -> bool + Send + Sync + 'static, 

type Unsub = Rc<ProxySubscription<S::Unsub>>

impl<S, F, K> SharedObservable for DistinctKeyOp<S, F> where
    S: SharedObservable,
    F: Fn(&S::Item) -> K + Send + Sync + 'static,
    K: Eq + Hash + Clone + Send + Sync + 'static, 

type Unsub = S::Unsub

impl<S, F, K> SharedObservable for DistinctUntilKeyChangedOp<S, F> where
    F: Fn(&S::Item) -> K + Send + Sync + 'static,
    S: SharedObservable,
    K: Eq,
    S::Item: Clone + Send + Sync + 'static, 

type Unsub = S::Unsub

impl<S, M> SharedObservable for TapOp<S, M> where
    S: SharedObservable,
    S::Item: 'static,
    M: FnMut(&S::Item) + Send + Sync + 'static, 

type Unsub = S::Unsub

impl<S, N> SharedObservable for TakeUntilOp<S, N> where
    S: SharedObservable,
    N: SharedObservable<Err = S::Err>,
    S::Item: Sync + Send + 'static,
    S::Err: Sync + Send + 'static,
    N::Item: 'static,
    S::Unsub: 'static,
    N::Unsub: 'static, 

type Unsub = RcMultiSubscription

impl<S, SD> SharedObservable for DebounceOp<S, SD> where
    S: SharedObservable,
    S::Item: Clone + Send + 'static,
    SD: Scheduler + Send + 'static, 

type Unsub = S::Unsub

impl<S, SD> SharedObservable for DelayOp<S, SD> where
    S: SharedObservable + Send + 'static,
    S::Unsub: 'static,
    SD: Scheduler, 

type Unsub = RcMultiSubscription

impl<S, SD> SharedObservable for ObserveOnOp<S, SD> where
    S::Item: Send + Sync + 'static,
    S::Err: Send + Sync + 'static,
    SD: Scheduler + Send + Sync + 'static,
    S: SharedObservable, 

type Unsub = S::Unsub

impl<S, SD> SharedObservable for SubscribeOnOP<S, SD> where
    S: SharedObservable + Send + 'static,
    SD: Scheduler, 

type Unsub = RcMultiSubscription

impl<S, SD> SharedObservable for ThrottleTimeOp<S, SD> where
    S: SharedObservable,
    SD: Scheduler + Send + 'static,
    S::Item: Clone + Send + 'static, 

type Unsub = S::Unsub

impl<Source, Discr, Key> SharedObservable for GroupObservable<Source, Discr, Key> where
    Source: SharedObservable,
    Source::Item: Send + Sync + 'static,
    Discr: FnMut(&Source::Item) -> Key + Clone + Send + Sync + 'static,
    Key: Hash + Clone + Eq + Send + Sync + 'static, 

type Unsub = Source::Unsub

impl<Source, SD> SharedObservable for BufferWithCountOrTimerOp<Source, SD> where
    Source: SharedObservable,
    Source::Item: Send + Sync + 'static,
    SD: Scheduler + 'static, 

type Unsub = TimeSubscription<Rc<SpawnHandle>, Source::Unsub>

impl<Source, SD> SharedObservable for BufferWithTimeOp<Source, SD> where
    Source: SharedObservable,
    Source::Item: Send + Sync + 'static,
    SD: Scheduler + 'static, 

type Unsub = TimeSubscription<Rc<SpawnHandle>, Source::Unsub>

impl<Source, Sampling> SharedObservable for SampleOp<Source, Sampling> where
    Source::Item: Send + Sync + 'static,
    Sampling::Item: 'static,
    Source: SharedObservable,
    Sampling: SharedObservable<Err = Source::Err>,
    Source::Unsub: 'static,
    Sampling::Unsub: 'static, 

type Unsub = RcMultiSubscription

impl<Src, Sbj> SharedObservable for ConnectableObservable<Src, Sbj> where
    Sbj: SharedObservable, 

type Unsub = Sbj::Unsub

impl<Src, Sbj> SharedObservable for RefCount<Rc<InnerRefCount<Src, Sbj, Src::Unsub>>> where
    ConnectableObservable<Src, Sbj>: Connect<Unsub = Src::Unsub>,
    Src: SharedObservable + 'static,
    Src::Unsub: Clone + 'static,
    Src::Item: Clone + 'static,
    Src::Err: Clone + 'static,
    Sbj: Observer<Item = Src::Item, Err = Src::Err> + TearDownSize + Clone + SharedObservable<Item = Src::Item, Err = Src::Err> + Send + Sync + 'static, 

type Unsub = RefCountSubscription<Sbj, Sbj::Unsub, Src::Unsub>