def subscribe( observer: typing.Observer, scheduler: Optional[typing.Scheduler] = None) -> typing.Disposable: _scheduler = scheduler or ImmediateScheduler.singleton() def action(scheduler: typing.Scheduler, state: Any): observer.on_error(exception) return _scheduler.schedule(action)
def subscribe(observer, scheduler=None): scheduler = scheduler or ImmediateScheduler.singleton() queue = [] m = SerialDisposable() d = CompositeDisposable(m) active_count = [0] is_acquired = [False] def ensure_active(): is_owner = False if queue: is_owner = not is_acquired[0] is_acquired[0] = True def action(scheduler, state): if queue: work = queue.pop(0) else: is_acquired[0] = False return sad = SingleAssignmentDisposable() d.add(sad) def on_next(value): observer.on_next(value) result = None try: result = mapper(value) except Exception as ex: observer.on_error(ex) return queue.append(result) active_count[0] += 1 ensure_active() def on_complete(): d.remove(sad) active_count[0] -= 1 if active_count[0] == 0: observer.on_completed() sad.disposable = work.subscribe_(on_next, observer.on_error, on_complete, scheduler) m.disposable = scheduler.schedule(action) if is_owner: m.disposable = scheduler.schedule(action) queue.append(source) active_count[0] += 1 ensure_active() return d
def test_immediate_extend(self): class MyScheduler(ImmediateScheduler): pass scheduler = [ MyScheduler(), MyScheduler.singleton(), ImmediateScheduler.singleton(), ] assert scheduler[0] is scheduler[1] assert scheduler[0] is not scheduler[2]
def subscribe( observer: typing.Observer, scheduler_: Optional[typing.Scheduler] = None ) -> typing.Disposable: _scheduler = scheduler or scheduler_ or ImmediateScheduler.singleton() def action(_: typing.Scheduler, __: Any) -> None: observer.on_completed() return _scheduler.schedule(action)
def test_immediate_singleton(self): scheduler = [ImmediateScheduler(), ImmediateScheduler.singleton()] assert scheduler[0] is scheduler[1] gate = [threading.Semaphore(0), threading.Semaphore(0)] scheduler = [None, None] def run(idx): scheduler[idx] = ImmediateScheduler() gate[idx].release() for idx in (0, 1): threading.Thread(target=run, args=(idx, )).start() gate[idx].acquire() assert scheduler[0] is not None assert scheduler[1] is not None assert scheduler[0] is scheduler[1]
def to_observable(self, scheduler=None): """Returns an observable sequence with a single notification, using the specified scheduler, else the immediate scheduler. Args: scheduler: [Optional] Scheduler to send out the notification calls on. Returns: An observable sequence that surfaces the behavior of the notification upon subscription. """ scheduler = scheduler or ImmediateScheduler.singleton() def subscribe(observer, scheduler=None): def action(scheduler, state): self._accept_observer(observer) if self.kind == 'N': observer.on_completed() return scheduler.schedule(action) return Observable(subscribe)