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)