class AutoDetachObserver(ObserverBase): def __init__(self, observer): super(AutoDetachObserver, self).__init__() self._observer = observer self._subscription = SingleAssignmentDisposable() def _on_next_core(self, value): try: self._observer.on_next(value) except Exception: self.dispose() raise def _on_error_core(self, error): try: self._observer.on_error(error) finally: self.dispose() def _on_completed_core(self): try: self._observer.on_completed() finally: self.dispose() def set_disposable(self, value): self._subscription.disposable = value subscription = property(fset=set_disposable) def dispose(self): super().dispose() self._subscription.dispose()
class AutoDetachObserver(AbstractObserver): def __init__(self, observer): super(AutoDetachObserver, self).__init__(self._next, self._error, self._completed) self.observer = observer self.m = SingleAssignmentDisposable() def _next(self, value): try: self.observer.on_next(value) except Exception: self.dispose() raise def _error(self, exn): try: self.observer.on_error(exn) finally: self.dispose() def _completed(self): try: self.observer.on_completed() finally: self.dispose() def set_disposable(self, value): self.m.disposable = value disposable = property(fset=set_disposable) def dispose(self): super(AutoDetachObserver, self).dispose() self.m.dispose()
class ScheduledItem(object): def __init__(self, scheduler, state, action, duetime, comparer=None): self.scheduler = scheduler self.state = state self.action = action self.duetime = duetime self.comparer = comparer or default_sub_comparer self.disposable = SingleAssignmentDisposable() def invoke(self): self.disposable.disposable = self.invoke_core() def compare_to(self, other): return self.comparer(self.duetime, other.duetime) def cancel(self): """Cancels the work item by disposing the resource returned by invoke_core as soon as possible.""" self.disposable.dispose() def is_cancelled(self): return self.disposable.is_disposed def invoke_core(self): return self.action(self.scheduler, self.state) def __lt__(self, other): return self.compare_to(other) < 0 def __gt__(self, other): return self.compare_to(other) > 0 def __eq__(self, other): return self.compare_to(other) == 0
class ScheduledItem(object): def __init__(self, scheduler, state, action, duetime): self.scheduler = scheduler self.state = state self.action = action self.duetime = duetime self.disposable = SingleAssignmentDisposable() def invoke(self): ret = self.scheduler.invoke_action(self.action, self.state) self.disposable.disposable = ret def cancel(self): """Cancels the work item by disposing the resource returned by invoke_core as soon as possible.""" self.disposable.dispose() def is_cancelled(self): return self.disposable.is_disposed def __lt__(self, other): return self.duetime < other.duetime def __gt__(self, other): return self.duetime > other.duetime def __eq__(self, other): return self.duetime == other.duetime
class AutoDetachObserver(AbstractObserver): def __init__(self, observer): super(AutoDetachObserver, self).__init__() self.observer = observer self.m = SingleAssignmentDisposable() def next(self, value): try: self.observer.on_next(value) except Exception as ex: traceback.print_exc(file=sys.stdout) self.dispose() def error(self, exn): try: self.observer.on_error(exn) finally: self.dispose() def completed(self): try: self.observer.on_completed() finally: self.dispose() def set_disposable(self, value): self.m.disposable = value disposable = property(fset=set_disposable) def dispose(self): super(AutoDetachObserver, self).dispose() self.m.dispose()
class AutoDetachObserver(AbstractObserver): def __init__(self, observer): super(AutoDetachObserver, self).__init__(self._next, self._error, self._completed) self.observer = observer self.m = SingleAssignmentDisposable() def _next(self, value): try: self.observer.on_next(value) except Exception as ex: self.dispose() raise ex def _error(self, exn): try: self.observer.on_error(exn) finally: self.dispose() def _completed(self): try: self.observer.on_completed() finally: self.dispose() def set_disposable(self, value): self.m.disposable = value disposable = property(fset=set_disposable) def dispose(self): super(AutoDetachObserver, self).dispose() self.m.dispose()
class SingleStream(Observer, Observable): """The SingleStream. A disposable observer that can be subscribed/chained with a single observer. It's subscription property may be assigned an upstream subscription that will be disposed together with the stream itself. """ def __init__(self) -> None: self._observer = NoopObserver() # type: Observer self._subscription = SingleAssignmentDisposable() super().__init__() def on_next(self, value: Any) -> None: self._observer.on_next(value) def on_error(self, error: Exception) -> None: try: self._observer.on_error(error) finally: self.dispose() def on_completed(self) -> None: try: self._observer.on_completed() finally: self.dispose() def subscribe(self, observer: Observer = None, scheduler: Scheduler = None) -> Disposable: self._observer = observer return Disposable.create(self.dispose) def chain(self, observer: Observer = None, scheduler: Scheduler = None) -> "SingleStream": self._observer = observer return self def set_subscription(self, value: Disposable): """Sets a subscription that will be disposed togeter with the stream.""" self._subscription.disposable = value subscription = property(fset=set_subscription, doc="Sets the subscription.") def dispose(self) -> None: self._observer = NoopObserver() self._subscription.dispose()
def test_futuredisposable_disposeafterset(): d = SingleAssignmentDisposable() disposed = [False] def action(): disposed[0] = True dd = Disposable.create(action) d.disposable = dd assert dd == d.disposable assert not disposed[0] d.dispose() assert disposed[0] d.dispose() assert disposed[0]
def test_futuredisposable_disposeafterset(): d = SingleAssignmentDisposable() disposed = False def action(): nonlocal disposed disposed = True dd = Disposable(action) d.disposable = dd assert dd == d.disposable assert not disposed d.dispose() assert disposed d.dispose() assert disposed
def test_futuredisposable_disposebeforeset(): disposed = [False] def dispose(): disposed[0] = True d = SingleAssignmentDisposable() dd = Disposable.create(dispose) assert not disposed[0] d.dispose() assert not disposed[0] d.disposable = dd assert d.disposable == None assert disposed[0] d.dispose() assert disposed[0]
class JoinObserver(ObserverBase): def __init__(self, source, on_error): super(JoinObserver, self).__init__() self.source = source self.on_error = on_error self.queue = [] self.active_plans = [] self.subscription = SingleAssignmentDisposable() self.is_disposed = False def _on_next_core(self, notification): if not self.is_disposed: if notification.kind == 'E': self.on_error(notification.exception) return self.queue.append(notification) active_plans = self.active_plans[:] for plan in active_plans: plan.match() def _on_error_core(self, error): return NotImplemented def _on_completed_core(self): return NotImplemented def add_active_plan(self, active_plan): self.active_plans.append(active_plan) def subscribe(self): self.subscription.disposable = self.source.materialize().subscribe( self) def remove_active_plan(self, active_plan): self.active_plans.remove(active_plan) if not self.active_plans: self.dispose() def dispose(self): super(JoinObserver, self).dispose() if not self.is_disposed: self.is_disposed = True self.subscription.dispose()
class JoinObserver(ObserverBase): def __init__(self, source, on_error): super(JoinObserver, self).__init__() self.source = source self.on_error = on_error self.queue = [] self.active_plans = [] self.subscription = SingleAssignmentDisposable() self.is_disposed = False def _on_next_core(self, notification): if not self.is_disposed: if notification.kind == 'E': self.on_error(notification.exception) return self.queue.append(notification) active_plans = self.active_plans[:] for plan in active_plans: plan.match() def _on_error_core(self, error): return NotImplemented def _on_completed_core(self): return NotImplemented def add_active_plan(self, active_plan): self.active_plans.append(active_plan) def subscribe(self): self.subscription.disposable = self.source.materialize().subscribe(self) def remove_active_plan(self, active_plan): self.active_plans.remove(active_plan) if not len(self.active_plans): self.dispose() def dispose(self): super(JoinObserver, self).dispose() if not self.is_disposed: self.is_disposed = True self.subscription.dispose()
def test_futuredisposable_disposebeforeset(): disposed = False def dispose(): nonlocal disposed disposed = True d = SingleAssignmentDisposable() dd = Disposable(dispose) assert not disposed d.dispose() assert not disposed d.disposable = dd assert d.disposable == None assert disposed d.dispose() assert disposed