def observe(self, observer_info: MultiCastObserverInfo) -> Disposable:
return self.source.observe(observer_info.copy(
observer=FilterMultiCastObserver(
source=observer_info.observer,
predicate=self.predicate,
)
))
def observe(self,
observer_info: MultiCastObserverInfo) -> rx.typing.Disposable:
self.on_observe(observer_info)
# if self.multicast_scheduler.idle:
# raise Exception(to_operator_exception(
# message='observe method call should be scheduled on multicast scheduler',
# stack=self.stack,
# ))
observer = DebugMultiCastObserver(
source=observer_info.observer,
on_next_func=self.on_next,
on_completed_func=self.on_completed,
on_error_func=self.on_error,
stack=self.stack,
# source_scheduler=self.source_scheduler,
)
# def action(_, __):
# observer.has_scheduled_next = True
# self.multicast_scheduler.schedule(action)
return CompositeDisposable(
self.source.observe(observer_info.copy(observer=observer, )),
Disposable(self.on_dispose),
)
def observe(self,
observer_info: MultiCastObserverInfo) -> rx.typing.Disposable:
return self.source.observe(
observer_info.copy(observer=DefaultIfEmptyMultiCastObserver(
source=observer_info.observer,
lazy_val=self.lazy_val,
)))
def observe(self, observer_info: MultiCastObserverInfo) -> Disposable:
return self.source.observe(
observer_info.copy(observer=ObserveOnMultiCastObserver(
next_observer=observer_info.observer,
scheduler=self.scheduler,
source_scheduler=self.source_scheduler,
)))
def observe(self, observer_info: MultiCastObserverInfo) -> Disposable:
single_assign_disposable = SingleAssignmentDisposable()
disposable = self.source.observe(observer_info.copy(
observer = FirstOrDefaultMultiCastObserver(
source=observer_info.observer,
lazy_val=self.lazy_val,
),
))
return CompositeDisposable(single_assign_disposable, disposable)
def observe(self, observer_info: MultiCastObserverInfo) -> rx.typing.Disposable:
single_assign_disposable = SingleAssignmentDisposable()
disposable = self.source.observe(observer_info.copy(
observer=FirstMultiCastObserver(
source=observer_info.observer,
disposable=single_assign_disposable,
stack=self.stack,
)
))
return CompositeDisposable(single_assign_disposable, disposable)
def observe(self, observer_info: MultiCastObserverInfo) -> Disposable:
return self.source.observe(observer_info.copy(
observer=FlatMapMultiCastObserver(
observer_info=observer_info,
func=self.func,
lock=threading.RLock(),
state=[1],
composite_disposable=CompositeDisposable(),
)
))
def observe(self, observer_info: MultiCastObserverInfo):
disposable = self.subject.observe(observer_info)
with self.lock:
self.count += 1
current_cound = self.count
if current_cound == 1:
# if self.multicast_scheduler.idle:
# raise Exception(to_operator_exception(
# message='observe method call should be scheduled on multicast scheduler',
# stack=self.stack,
# ))
def action(_, __):
self.scheduled_next = True
self.multicast_scheduler.schedule(action)
subject_subscription = observer_info.copy(observer=self.subject)
self.first_disposable = self.source.observe(subject_subscription)
# else:
# if self.scheduled_next:
# raise Exception(to_operator_exception(
# message='subsequent subscribe call has been delayed, make sure to not delay MultiCasts subscriptions',
# stack=self.stack,
# ))
def dispose():
disposable.dispose()
with self.lock:
self.count -= 1
if self.count == 0:
dispose_all = True
else:
dispose_all = False
if dispose_all:
self.first_disposable.dispose()
# for d in self.volatile_disposables:
# d.dispose()
return Disposable(dispose)
def observe(self,
observer_info: MultiCastObserverInfo) -> rx.typing.Disposable:
disposable = SingleAssignmentDisposable()
# dispose source if MultiCast sink gets disposed and all inner Flowable sinks
# are disposed
ref_count_disposable = RefCountDisposable(disposable)
disposable.disposable = self.source.observe(
observer_info.copy(observer=CollectFlowablesMultiCastObserver(
next_observer=observer_info.observer,
ref_count_disposable=ref_count_disposable,
maintain_order=self.maintain_order,
stack=self.stack,
subscriber=self.subscriber,
), ))
return ref_count_disposable
def observe(self, observer_info: MultiCastObserverInfo) -> rx.typing.Disposable:
group = CompositeDisposable()
lock = threading.RLock()
for inner_source in self.sources:
inner_subscription = SingleAssignmentDisposable()
group.add(inner_subscription)
disposable = inner_source.observe(observer_info.copy(
observer=MergeMultiCastObserver(
observer=observer_info.observer,
lock=lock,
inner_subscription=inner_subscription,
group=group
)
))
inner_subscription.disposable = disposable
return group
def observe(self, observer_info: MultiCastObserverInfo):
@dataclass
class MaterializeMultiCastObserver(MultiCastObserver):
source: MultiCastObserver
def on_next(self, item: ElementType):
if not isinstance(item, list):
item = list(item)
self.source.on_next(item)
def on_error(self, exc: Exception):
return self.source.on_error(exc)
def on_completed(self):
return self.source.on_completed()
return self.source.observe(
observer_info.copy(observer=MaterializeMultiCastObserver(
source=observer_info.observer, ), ))
def observe(self, observer_info: MultiCastObserverInfo) -> Disposable:
return self.source.observe(
observer_info.copy(observer=MapMultiCastObserver(
source=observer_info.observer,
func=self.func,
)))