Type Definition rxrust::subject::LocalSubject

type LocalSubject<'a, Item, Err> = Subject<Rc<RefCell<Vec<Box<dyn Publisher<Item = Item, Err = Err> + 'a>>>>, LocalSubscription>;

Trait Implementations

impl<'a, Item, Err> LocalObservable<'a> for LocalSubject<'a, Item, Err>

type Unsub = LocalSubscription

pub fn actual_subscribe<O: Observer<Item = Self::Item, Err = Self::Err> + 'a>(
    self,
    subscriber: Subscriber<O, LocalSubscription>
) -> LocalSubscription

impl<'a, Item, Err> Observable for LocalSubject<'a, Item, Err>

type Item = Item

type Err = Err

pub fn first(self) -> TakeOp<Self> where
    Self: Sized, 

emit only the first item emitted by an Observable

pub fn first_or(
    self,
    default: Self::Item
) -> FirstOrOp<TakeOp<Self>, Self::Item> where
    Self: Sized, 

emit only the first item emitted by an Observable

pub fn last_or(self, default: Self::Item) -> LastOrOp<Self, Self::Item> where
    Self: Sized, 

Emit only the last final item emitted by a source observable or a default item given.

pub fn last(self) -> LastOrOp<Self, Self::Item> where
    Self: Sized, 

Emits only last final item emitted by a source observable.

pub fn finalize<F>(self, f: F) -> FinalizeOp<Self, F> where
    Self: Sized,
    F: FnMut(), 

Call a function when observable completes, errors or is unsubscribed from.

pub fn map<B, F>(self, f: F) -> MapOp<Self, F> where
    Self: Sized,
    F: Fn(Self::Item) -> B, 

Creates a new stream which calls a closure on each element and uses its return as the value.

pub fn map_to<B>(self, value: B) -> MapToOp<Self, B> where
    Self: Sized, 

Maps emissions to a constant value.

pub fn merge<S>(self, o: S) -> MergeOp<Self, S> where
    Self: Sized,
    S: Observable<Item = Self::Item, Err = Self::Err>, 

combine two Observables into one by merging their emissions

pub fn filter<F>(self, filter: F) -> FilterOp<Self, F> where
    Self: Sized,
    F: Fn(&Self::Item) -> bool, 

Emit only those items from an Observable that pass a predicate test

pub fn filter_map<F, SourceItem, Item>(self, f: F) -> FilterMapOp<Self, F> where
    Self: Sized,
    F: FnMut(SourceItem) -> Option<Item>, 

The closure must return an Option. filter_map creates an iterator which calls this closure on each element. If the closure returns Some(element), then that element is returned. If the closure returns None, it will try again, and call the closure on the next element, seeing if it will return Some.

pub fn box_it<O: IntoBox<Self>>(self) -> BoxOp<O> where
    Self: Sized,
    BoxOp<O>: Observable<Item = Self::Item, Err = Self::Err>, 

box an observable to a safety object and convert it to a simple type BoxOp, which only care Item and Err Observable emitted.

pub fn skip(self, count: u32) -> SkipOp<Self> where
    Self: Sized, 

Ignore the first count values emitted by the source Observable.

pub fn skip_last(self, count: usize) -> SkipLastOp<Self> where
    Self: Sized, 

Ignore the last count values emitted by the source Observable.

pub fn take(self, count: u32) -> TakeOp<Self> where
    Self: Sized, 

Emits only the first count values emitted by the source Observable.

pub fn take_until<T>(self, notifier: T) -> TakeUntilOp<Self, T> where
    Self: Sized, 

Emits the values emitted by the source Observable until a notifier Observable emits a value.

pub fn take_while<F>(self, callback: F) -> TakeWhileOp<Self, F> where
    Self: Sized,
    F: FnMut(&Self::Item) -> bool, 

Emits values while result of an callback is true.

pub fn take_last(self, count: usize) -> TakeLastOp<Self> where
    Self: Sized, 

Emits only the last count values emitted by the source Observable.

pub fn sample<O>(self, sampling: O) -> SampleOp<Self, O> where
    Self: Sized,
    O: Observable, 

Emits item it has most recently emitted since the previous sampling

pub fn scan_initial<OutputItem, BinaryOp>(
    self,
    initial_value: OutputItem,
    binary_op: BinaryOp
) -> ScanOp<Self, BinaryOp, OutputItem> where
    Self: Sized,
    BinaryOp: Fn(OutputItem, Self::Item) -> OutputItem,
    OutputItem: Clone, 

The Scan operator applies a function to the first item emitted by the source observable and then emits the result of that function as its own first emission. It also feeds the result of the function back into the function along with the second item emitted by the source observable in order to generate its second emission. It continues to feed back its own subsequent emissions along with the subsequent emissions from the source Observable in order to create the rest of its sequence.

pub fn scan<OutputItem, BinaryOp>(
    self,
    binary_op: BinaryOp
) -> ScanOp<Self, BinaryOp, OutputItem> where
    Self: Sized,
    BinaryOp: Fn(OutputItem, Self::Item) -> OutputItem,
    OutputItem: Default + Clone, 

Works like scan_initial but starts with a value defined by a Default trait for the first argument binary_op operator operates on.

pub fn reduce_initial<OutputItem, BinaryOp>(
    self,
    initial: OutputItem,
    binary_op: BinaryOp
) -> ReduceOp<Self, BinaryOp, OutputItem> where
    Self: Sized,
    BinaryOp: Fn(OutputItem, Self::Item) -> OutputItem,
    OutputItem: Clone, 

Apply a function to each item emitted by an observable, sequentially, and emit the final value, after source observable completes.

pub fn reduce<OutputItem, BinaryOp>(
    self,
    binary_op: BinaryOp
) -> LastOrOp<ScanOp<Self, BinaryOp, OutputItem>, OutputItem> where
    Self: Sized,
    BinaryOp: Fn(OutputItem, Self::Item) -> OutputItem,
    OutputItem: Default + Clone, 

Works like reduce_initial but starts with a value defined by a Default trait for the first argument f operator operates on.

pub fn max(self) -> MinMaxOp<Self, Self::Item> where
    Self: Sized,
    Self::Item: Clone + Send + PartialOrd<Self::Item>, 

Emits the item from the source observable that had the maximum value.

pub fn min(self) -> MinMaxOp<Self, Self::Item> where
    Self: Sized,
    Self::Item: Clone + Send + PartialOrd<Self::Item>, 

Emits the item from the source observable that had the minimum value.

pub fn sum(self) -> SumOp<Self, Self::Item> where
    Self: Sized,
    Self::Item: Clone + Default + Add<Self::Item, Output = Self::Item>, 

Calculates the sum of numbers emitted by an source observable and emits this sum when source completes.

pub fn count(self) -> CountOp<Self, Self::Item> where
    Self: Sized, 

Emits the number of items emitted by a source observable when this source completes.

pub fn average(self) -> AverageOp<Self, Self::Item> where
    Self: Sized,
    Self::Item: Clone + Send + Default + Add<Self::Item, Output = Self::Item> + Mul<f64, Output = Self::Item>, 

Calculates the sum of numbers emitted by an source observable and emits this sum when source completes.

pub fn publish<Subject: Default>(self) -> ConnectableObservable<Self, Subject> where
    Self: Sized, 

Returns a ConnectableObservable. A ConnectableObservable Observable resembles an ordinary Observable, except that it does not begin emitting items when it is subscribed to, but only when the Connect operator is applied to it. In this way you can wait for all intended observers to subscribe to the Observable before the Observable begins emitting items.

pub fn share<Subject, Inner>(
    self
) -> RefCount<Inner, ConnectableObservable<Self, Subject>> where
    Inner: RefCountCreator<Connectable = ConnectableObservable<Self, Subject>>,
    Subject: Default,
    Self: Sized + Clone, 

Returns a new Observable that multicast (shares) the original Observable. As long as there is at least one Subscriber this Observable will be subscribed and emitting data. When all subscribers have unsubscribed it will unsubscribe from the source Observable. Because the Observable is multicasting it makes the stream hot. This is an alias for publish().ref_count()

pub fn delay<SD>(self, dur: Duration, scheduler: SD) -> DelayOp<Self, SD> where
    Self: Sized, 

Delays the emission of items from the source Observable by a given timeout or until a given Instant.

pub fn delay_at<SD>(self, at: Instant, scheduler: SD) -> DelayOp<Self, SD> where
    Self: Sized, 

pub fn subscribe_on<SD>(self, scheduler: SD) -> SubscribeOnOP<Self, SD> where
    Self: Sized, 

Specify the Scheduler on which an Observable will operate

pub fn observe_on<SD>(self, scheduler: SD) -> ObserveOnOp<Self, SD> where
    Self: Sized, 

Re-emits all notifications from source Observable with specified scheduler.

pub fn debounce<SD>(
    self,
    duration: Duration,
    scheduler: SD
) -> DebounceOp<Self, SD> where
    Self: Sized, 

Emits a value from the source Observable only after a particular time span has passed without another source emission.

pub fn throttle_time<SD>(
    self,
    duration: Duration,
    edge: ThrottleEdge,
    scheduler: SD
) -> ThrottleTimeOp<Self, SD> where
    Self: Sized, 

Emits a value from the source Observable, then ignores subsequent source values for duration milliseconds, then repeats this process.

pub fn distinct(self) -> DistinctOp<Self> where
    Self: Sized, 

Returns an Observable that emits all items emitted by the source Observable that are distinct by comparison from previous items.

pub fn zip<U>(self, other: U) -> ZipOp<Self, U> where
    Self: Sized,
    U: Observable, 

'Zips up' two observable into a single observable of pairs.

pub fn default_if_empty(
    self,
    default_value: Self::Item
) -> DefaultIfEmptyOp<Self> where
    Self: Sized, 

Emits default value if Observable completed with empty result