class O(Observer): def __init__(self, parent, sourceObserver): self.parent = parent self.sourceObserver = sourceObserver self.subscription = SingleAssignmentDisposable() def setdisposable(self, value): self.subscription.disposable = value disposable = property(None, setdisposable) def onNext(self, value): with self.parent.gate: self.parent.observer.onCompleted() self.parent.dispose() def onError(self, exception): with self.parent.gate: self.parent.observer.onError(exception) self.parent.dispose() def onCompleted(self): with self.parent.gate: self.sourceObserver.open = True self.subscription.dispose()
def on_next(inner_source: Union[Observable, Future]): nonlocal source d = SingleAssignmentDisposable() with source.lock: latest[0] += 1 _id = latest[0] has_latest[0] = True inner_subscription.disposable = d # Check if Future or Observable if is_future(inner_source): obs = from_future(cast(Future, inner_source)) else: obs = cast(Observable, inner_source) def on_next(x: Any) -> None: if latest[0] == _id: observer.on_next(x) def on_error(e: Exception) -> None: if latest[0] == _id: observer.on_error(e) def on_completed() -> None: if latest[0] == _id: has_latest[0] = False if is_stopped[0]: observer.on_completed() d.disposable = obs.subscribe_(on_next, on_error, on_completed, scheduler=scheduler)
class AutoDetachObserver(typing.Observer): def __init__(self, on_next: Optional[typing.OnNext] = None, on_error: Optional[typing.OnError] = None, on_completed: Optional[typing.OnCompleted] = None ) -> Any: self._on_next = on_next or noop self._on_error = on_error or default_error self._on_completed = on_completed or noop self._subscription = SingleAssignmentDisposable() self.is_stopped = False def on_next(self, value: Any) -> None: if self.is_stopped: return try: self._on_next(value) except Exception: self.dispose() raise def on_error(self, error) -> None: if self.is_stopped: return self.is_stopped = True try: self._on_error(error) finally: self.dispose() def on_completed(self) -> None: if self.is_stopped: return self.is_stopped = True try: self._on_completed() finally: self.dispose() def set_disposable(self, value: typing.Disposable): self._subscription.disposable = value subscription = property(fset=set_disposable) def dispose(self) -> None: self.is_stopped = True self._subscription.dispose() def fail(self, exn: Exception) -> bool: if self.is_stopped: return False self.is_stopped = True self._on_error(exn) return True
class ScheduledItem(Generic[typing.TState]): # pylint: disable=unsubscriptable-object def __init__(self, scheduler: SchedulerBase, state: Optional[typing.TState], action: typing.ScheduledAction, duetime: typing.AbsoluteTime): self.scheduler = scheduler self.state = state self.action = action self.duetime = duetime self.disposable = SingleAssignmentDisposable() def invoke(self) -> None: ret = self.scheduler.invoke_action(self.action, self.state) self.disposable.disposable = ret def cancel(self) -> None: """Cancels the work item by disposing the resource returned by invoke_core as soon as possible.""" self.disposable.dispose() def is_cancelled(self) -> bool: 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
def run(self): self.scheduler = self.parent.scheduler self.cancelTimer = SerialDisposable() self.gate = RLock() self.active = False # as soon as a value arrived self.running = False # on relative: True, on absolute: True after absolute time self.queue = deque() self.hasCompleted = False self.completeAt = 0 self.hasFailed = False self.exception = None self.delay = 0 self.startTime = self.scheduler.now() if self.parent.isAbsolute: self.ready = False self.cancelTimer.disposable = self.scheduler.scheduleWithAbsolute( self.parent.dueTime, self.start) else: self.ready = True self.delay = Scheduler.normalize(self.parent.dueTime) self.sourceSubscription = SingleAssignmentDisposable() self.sourceSubscription.disposable = self.parent.source.subscribeSafe( self) return CompositeDisposable(self.sourceSubscription, self.cancelTimer)
def on_next_right(value): nonlocal right_id duration = None current_id = right_id right_id += 1 md = SingleAssignmentDisposable() right_map[current_id] = value group.add(md) def expire(): if current_id in right_map: del right_map[current_id] if not len(right_map) and right_done: observer.on_completed() return group.remove(md) try: duration = right_duration_mapper(value) except Exception as exception: observer.on_error(exception) return md.disposable = duration.pipe(take(1)).subscribe_( noop, observer.on_error, lambda: expire(), scheduler) for val in left_map.values(): result = (val, value) observer.on_next(result)
def __init__(self, observer, disposable = None): super(AutoDetachObserver, self).__init__() self.observer = observer self.m = SingleAssignmentDisposable() if disposable != None: self.m.disposable = disposable
def subscribe(observer, scheduler=None): is_open = [False] def on_next(left): if is_open[0]: observer.on_next(left) def on_completed(): if is_open[0]: observer.on_completed() subs = source.subscribe_(on_next, observer.on_error, on_completed, scheduler) subscriptions = CompositeDisposable(subs) right_subscription = SingleAssignmentDisposable() subscriptions.add(right_subscription) def on_next2(x): is_open[0] = True right_subscription.dispose() def on_completed2(): right_subscription.dispose() right_subscription.disposable = other.subscribe_( on_next2, observer.on_error, on_completed2, scheduler) return subscriptions
def subscribe(observer, scheduler=None): d1 = SingleAssignmentDisposable() subscription = SerialDisposable() subscription.disposable = d1 def on_error(exception): try: result = handler(exception, source) except Exception as ex: # By design. pylint: disable=W0703 observer.on_error(ex) return result = rx.from_future(result) if is_future(result) else result d = SingleAssignmentDisposable() subscription.disposable = d d.disposable = result.subscribe(observer, scheduler=scheduler) d1.disposable = source.subscribe_( observer.on_next, on_error, observer.on_completed, scheduler ) return subscription
def schedulePeriodicWithState(self, state, period, action): failed = False failureLock = RLock d = SingleAssignmentDisposable() def scheduled(_state): with failureLock: nonlocal failed if failed: return None try: return action(_state) except Exception as e: failed = True if not self.handler(e): raise e d.dispose() return None d.disposable = self._scheduler.schedulePeriodicWithState( state, period, scheduled) return d
def subscribe(observer, scheduler=None): group = CompositeDisposable() is_stopped = [False] m = SingleAssignmentDisposable() group.add(m) def on_next(inner_source): inner_subscription = SingleAssignmentDisposable() group.add(inner_subscription) inner_source = from_future(inner_source) if is_future( inner_source) else inner_source @synchronized(source.lock) def on_completed(): group.remove(inner_subscription) if is_stopped[0] and len(group) == 1: observer.on_completed() on_next = synchronized(source.lock)(observer.on_next) on_error = synchronized(source.lock)(observer.on_error) subscription = inner_source.subscribe_(on_next, on_error, on_completed, scheduler) inner_subscription.disposable = subscription def on_completed(): is_stopped[0] = True if len(group) == 1: observer.on_completed() m.disposable = source.subscribe_(on_next, observer.on_error, on_completed, scheduler) return group
def on_next(inner_source: Observable): nonlocal source d = SingleAssignmentDisposable() with source.lock: latest[0] += 1 _id = latest[0] has_latest[0] = True inner_subscription.disposable = d # Check if Future or Observable inner_source = from_future(inner_source) if is_future(inner_source) else inner_source def on_next(x: Any) -> None: if latest[0] == _id: observer.on_next(x) def on_error(e: Exception) -> None: if latest[0] == _id: observer.on_error(e) def on_completed() -> None: if latest[0] == _id: has_latest[0] = False if is_stopped[0]: observer.on_completed() d.disposable = inner_source.subscribe_(on_next, on_error, on_completed, scheduler=scheduler)
def on_next_right(value): duration = None current_id = right_id[0] right_id[0] += 1 md = SingleAssignmentDisposable() right_map[current_id] = value group.add(md) def expire(): if current_id in right_map: del right_map[current_id] if not len(right_map) and right_done[0]: observer.on_completed() return group.remove(md) try: duration = right_duration_mapper(value) except Exception as exception: observer.on_error(exception) return md.disposable = duration.pipe(take(1)).subscribe_(noop, observer.on_error, lambda: expire(), scheduler) for val in left_map.values(): result = (val, value) observer.on_next(result)
def schedulePeriodicWithState(self, state, period, action): failed = False failureLock = RLock d = SingleAssignmentDisposable() def scheduled(_state): with failureLock: nonlocal failed if failed: return None try: return action(_state) except Exception as e: failed = True if not self.handler(e): raise e d.dispose() return None d.disposable = self._scheduler.schedulePeriodicWithState( state, period, scheduled ) return d
def onNext(self, value): resourceId = 0 with self.parent.gate: self.parent.rightID += 1 resourceId = self.parent.rightID self.parent.rightMap[resourceId] = value # AddRef was originally WindowObservable but this is just an alias for AddRef md = SingleAssignmentDisposable() self.parent.group.add(md) try: duration = self.parent.parent.rightDurationSelector(value) except Exception as e: self.parent.observer.onError(e) self.parent.dispose() return else: md.disposable = duration.subscribeSafe(self.Delta(self, resourceId, md)) with self.parent.gate: for leftValue in self.parent.leftMap.values(): try: result = self.parent.parent.resultSelector(leftValue, value) except Exception as e: self.parent.observer.onError(e) self.parent.dispose() return else: self.parent.observer.onNext(result)
def run(self): srcs = list(self.parent.sources) N = len(srcs) self.queues = [None] * N self.isDone = [False] * N self.subscriptions = [None] * N self.gate = RLock() for i in range(0, N): self.queues[i] = deque() # Loop twice because subscribing could already yield # a value before all queues are initialized for i in range(0, N): d = SingleAssignmentDisposable() self.subscriptions[i] = d o = self.O(self, i) d.disposable = srcs[i].subscribeSafe(o) c = CompositeDisposable(self.subscriptions) def dispose(): for q in self.queues: q.clear() c.add(Disposable.create(dispose)) return c
def subscribe(observer, scheduler=None): is_open = [False] def on_next(left): if is_open[0]: observer.on_next(left) def on_completed(): if is_open[0]: observer.on_completed() subs = source.subscribe_(on_next, observer.on_error, on_completed, scheduler) subscriptions = CompositeDisposable(subs) right_subscription = SingleAssignmentDisposable() subscriptions.add(right_subscription) def on_next2(x): is_open[0] = True right_subscription.dispose() def on_completed2(): right_subscription.dispose() right_subscription.disposable = other.subscribe_(on_next2, observer.on_error, on_completed2, scheduler) return subscriptions
def subscribe_all(parent, *children): values = [NO_VALUE for _ in children] def subscribe_child(i, child): subscription = SingleAssignmentDisposable() def on_next(value): with parent.lock: values[i] = value subscription.disposable = child.subscribe_(on_next, observer.on_error, scheduler=scheduler) return subscription parent_subscription = SingleAssignmentDisposable() def on_next(value): with parent.lock: if NO_VALUE not in values: result = (value,) + tuple(values) observer.on_next(result) disp = parent.subscribe_(on_next, observer.on_error, observer.on_completed, scheduler) parent_subscription.disposable = disp children_subscription = [subscribe_child(i, child) for i, child in enumerate(children)] return [parent_subscription] + children_subscription
def run(self): self.scheduler = self.parent.scheduler self.cancelTimer = SerialDisposable() self.gate = RLock() self.evt = Semaphore(0) self.stopped = False self.stop = Event() self.queue = deque() self.hasCompleted = False self.completeAt = 0 self.hasFailed = False self.exception = None self.delay = 0 self.startTime = self.scheduler.now() if self.parent.isAbsolute: self.cancelTimer.disposable = self.scheduler.scheduleAbsolute( self.parent.dueTime, self.start) else: self.delay = Scheduler.normalize(self.parent.dueTime) self.scheduleDrain() self.sourceSubscription = SingleAssignmentDisposable() self.sourceSubscription.disposable = self.parent.source.subscribeSafe( self) return CompositeDisposable(self.sourceSubscription, self.cancelTimer)
def send_right(value): with left.lock: _id = right_id[0] right_id[0] += 1 right_map[_id] = value md = SingleAssignmentDisposable() group.add(md) def expire(): del right_map[_id] group.remove(md) try: duration = right_duration_mapper(value) except Exception as e: for left_value in left_map.values(): left_value.on_error(e) observer.on_error(e) return def on_error(error): with left.lock: for left_value in left_map.values(): left_value.on_error(error) observer.on_error(error) md.disposable = duration.pipe(ops.take(1)).subscribe_( nothing, on_error, expire, scheduler) with left.lock: for left_value in left_map.values(): left_value.on_next(value)
class Sink(rx.linq.sink.Sink): def __init__(self, parent, observer, cancel): super(SampleWithObservable.Sink, self).__init__(observer, cancel) self.parent = parent def run(self): self.gate = RLock() self.atEnd = False self.hasValue = False self.value = None self.sourceSubscription = SingleAssignmentDisposable() self.sourceSubscription.disposable = self.parent.source.subscribeSafe(self) samplerSubscription = self.parent.sampler.subscribeSafe(self.SamplerObserver(self)) return CompositeDisposable(self.sourceSubscription, samplerSubscription) def onNext(self, value): with self.gate: self.hasValue = True self.value = value def onError(self, exception): with self.gate: self.observer.onError(exception) self.dispose() def onCompleted(self): with self.gate: self.atEnd = True self.sourceSubscription.dispose() class SamplerObserver(Observer): def __init__(self, parent): self.parent = parent def onNext(self, value): with self.parent.gate: if self.parent.hasValue: self.parent.hasValue = False self.parent.observer.onNext(self.parent.value) if self.parent.atEnd: self.parent.observer.onCompleted() self.parent.dispose() def onError(self, exception): with self.parent.gate: self.parent.observer.onError(exception) self.parent.dispose() def onCompleted(self): with self.parent.gate: if self.parent.hasValue: self.parent.hasValue = False self.parent.observer.onNext(self.parent.value) if self.parent.atEnd: self.parent.observer.onCompleted() self.parent.dispose()
class ScheduledItem(Generic[typing.TState]): # pylint: disable=unsubscriptable-object def __init__(self, scheduler: SchedulerBase, state: Optional[typing.TState], action: typing.ScheduledAction, duetime: typing.AbsoluteTime): self.scheduler = scheduler self.state = state self.action = action self.duetime = duetime self.disposable = SingleAssignmentDisposable() def invoke(self) -> None: ret = self.scheduler.invoke_action(self.action, self.state) self.disposable.disposable = ret def cancel(self) -> None: """Cancels the work item by disposing the resource returned by invoke_core as soon as possible.""" self.disposable.dispose() def is_cancelled(self) -> bool: 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
def send_right(value): with left.lock: _id = right_id[0] right_id[0] += 1 right_map[_id] = value md = SingleAssignmentDisposable() group.add(md) def expire(): del right_map[_id] group.remove(md) try: duration = right_duration_mapper(value) except Exception as e: for left_value in left_map.values(): left_value.on_error(e) observer.on_error(e) return def on_error(error): with left.lock: for left_value in left_map.values(): left_value.on_error(error) observer.on_error(error) md.disposable = duration.pipe(ops.take(1)).subscribe_(nothing, on_error, expire, scheduler) with left.lock: for left_value in left_map.values(): left_value.on_next(value)
def set_timer(timeout: Observable) -> None: my_id = _id[0] def timer_wins(): return _id[0] == my_id d = SingleAssignmentDisposable() timer.disposable = d def on_next(x): if timer_wins(): subscription.disposable = other.subscribe( observer, scheduler=scheduler) d.dispose() def on_error(e): if timer_wins(): observer.on_error(e) def on_completed(): if timer_wins(): subscription.disposable = other.subscribe(observer) d.disposable = timeout.subscribe_(on_next, on_error, on_completed, scheduler)
def __init__(self, on_next=None, on_error=None, on_completed=None): self._on_next = on_next or noop self._on_error = on_error or default_error self._on_completed = on_completed or noop self._subscription = SingleAssignmentDisposable() self.is_stopped = False
def subscribe(observer, scheduler=None): group = CompositeDisposable() is_stopped = [False] m = SingleAssignmentDisposable() group.add(m) def on_next(inner_source): inner_subscription = SingleAssignmentDisposable() group.add(inner_subscription) inner_source = from_future(inner_source) if is_future(inner_source) else inner_source @synchronized(source.lock) def on_completed(): group.remove(inner_subscription) if is_stopped[0] and len(group) == 1: observer.on_completed() on_next = synchronized(source.lock)(observer.on_next) on_error = synchronized(source.lock)(observer.on_error) subscription = inner_source.subscribe_(on_next, on_error, on_completed, scheduler) inner_subscription.disposable = subscription def on_completed(): is_stopped[0] = True if len(group) == 1: observer.on_completed() m.disposable = source.subscribe_(on_next, observer.on_error, on_completed, scheduler) return group
def onNext(self, value): s = Subject() resourceId = 0 with self.parent.gate: self.parent.leftID += 1 resourceId = self.parent.leftID self.parent.leftMap[resourceId] = s # AddRef was originally WindowObservable but this is just an alias for AddRef window = AddRef(s, self.parent.refCount) md = SingleAssignmentDisposable() self.parent.group.add(md) try: duration = self.parent.parent.leftDurationSelector(value) except Exception as e: self.onError(e) return else: md.disposable = duration.subscribeSafe(self.Delta(self, resourceId, s, md)) try: result = self.parent.parent.resultSelector(value, window) except Exception as e: self.onError(e) return else: with self.parent.gate: self.parent.observer.onNext(result) for rightValue in self.parent.rightMap.values(): s.onNext(rightValue)
def onNext(self, value): resourceId = 0 with self.parent.gate: self.parent.leftID += 1 resourceId = self.parent.leftID self.parent.leftMap[resourceId] = value # AddRef was originally WindowObservable but this is just an alias for AddRef md = SingleAssignmentDisposable() self.parent.group.add(md) try: duration = self.parent.parent.leftDurationSelector(value) except Exception as e: self.parent.observer.onError(e) self.parent.dispose() return else: md.disposable = duration.subscribeSafe( self.Delta(self, resourceId, md)) with self.parent.gate: for rightValue in self.parent.rightMap.values(): try: result = self.parent.parent.resultSelector( value, rightValue) except Exception as e: self.parent.observer.onError(e) self.parent.dispose() return else: self.parent.observer.onNext(result)
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)
def __init__(self): self.queue = Queue() self.gate = Semaphore(0) self.subscription = SingleAssignmentDisposable() self.error = None self.done = False self.disposed = False
def schedule_periodic(self, period: typing.RelativeTime, action: typing.ScheduledPeriodicAction, state: Optional[typing.TState] = None ) -> typing.Disposable: """Schedules a periodic piece of work. Args: period: Period in seconds or timedelta for running the work periodically. action: Action to be executed. state: [Optional] Initial state passed to the action upon the first iteration. Returns: The disposable object used to cancel the scheduled recurring action (best effort). """ d = SingleAssignmentDisposable() failed = False def periodic_action(periodic_state) -> Optional[typing.TState]: nonlocal failed if not failed: try: return action(periodic_state) except Exception as ex: failed = True if not self._handler(ex): raise d.dispose() return None d.disposable = self._scheduler.schedule_periodic(period, periodic_action, state=state) return d
def createTimer(self): m = SingleAssignmentDisposable() self.timerDisposable.disposable = m isSpan = False isShift = False if self.nextSpan == self.nextShift: isSpan = True isShift = True elif self.nextShift < self.nextShift: isSpan = True else: isShift = True newTotalTime = self.nextSpan if isSpan else self.nextShift ts = newTotalTime - self.totalTime self.totalTime = newTotalTime if isSpan: self.nextSpan += self.parent.timeShift if isShift: self.nextShift += self.parent.timeShift m.disposable = self.parent.scheduler.scheduleWithRelativeAndState( Struct(isSpan=isSpan, isShift=isShift), ts, self.tick )
def run(self): srcs = list(self.parent.sources) N = len(srcs) self.queues = [None] * N self.isDone = [False] * N self.subscriptions = [None] * N self.gate = RLock() for i in range(0, N): self.queues[i] = deque() # Loop twice because subscribing could already yield # a value before all queues are initialized for i in range(0, N): d = SingleAssignmentDisposable() self.subscriptions[i] = d o = self.O(self, i) d.disposable = srcs[i].subscribeSafe(o) c = CompositeDisposable(self.subscriptions) def dispose(): for q in self.queues: q.clear() c.add(Disposable.create(dispose)) return c
def on_next(x): throttle = None try: throttle = throttle_duration_mapper(x) except Exception as e: # pylint: disable=broad-except observer.on_error(e) return has_value[0] = True value[0] = x _id[0] += 1 current_id = _id[0] d = SingleAssignmentDisposable() cancelable.disposable = d def on_next(x: Any) -> None: if has_value[0] and _id[0] == current_id: observer.on_next(value[0]) has_value[0] = False d.dispose() def on_completed() -> None: if has_value[0] and _id[0] == current_id: observer.on_next(value[0]) has_value[0] = False d.dispose() d.disposable = throttle.subscribe_(on_next, observer.on_error, on_completed, scheduler=scheduler)
def createTimer(self): m = SingleAssignmentDisposable() self.timerDisposable.disposable = m isSpan = False isShift = False if self.nextSpan == self.nextShift: isSpan = True isShift = True elif self.nextShift < self.nextShift: isSpan = True else: isShift = True newTotalTime = self.nextSpan if isSpan else self.nextShift ts = newTotalTime - self.totalTime self.totalTime = newTotalTime if isSpan: self.nextSpan += self.parent.timeShift if isShift: self.nextShift += self.parent.timeShift m.disposable = self.parent.scheduler.scheduleWithRelativeAndState( Struct(isSpan=isSpan, isShift=isShift), ts, self.tick)
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)
def onNext(self, value): key = None try: key = self.parent.keySelector(value) except Exception as e: self.onError(e) return fireNewMapEntry = False writer = None try: if key == None: with self.nullGate: if self.null == None: self.null = Subject() fireNewMapEntry = True writer = self.null else: if key in self.map: writer = self.map[key] else: writer = Subject() self.map[key] = writer fireNewMapEntry = True except Exception as e: self.onError(e) return if fireNewMapEntry: group = GroupObservable(key, writer, self.parent.refCountDisposable) duration = None durationGroup = GroupObservable(key, writer) try: duration = self.parent.durationSelector(durationGroup) except Exception as e: self.onError(e) return with self.observerGate: self.observer.onNext(group) md = SingleAssignmentDisposable() self.parent.groupDisposable.add(md) md.disposable = duration.subscribeSafe(self.Delta(self, key, writer, md)) element = None try: element = self.parent.elementSelector(value) except Exception as e: self.onError(e) else: with self.writerGate: writer.onNext(element)
def run(self): self.subscription = SerialDisposable() d = SingleAssignmentDisposable() self.subscription.disposable = d d.disposable = self.parent.source.subscribeSafe(self) return self.subscription
def run(self): self.subscription = SingleAssignmentDisposable() self.loopDisposable = SingleAssignmentDisposable() self.subscription.disposable = self.parent.source.subscribeSafe( self) return CompositeDisposable(self.subscription, self.loopDisposable)
def __init__(self, scheduler: SchedulerBase, state: Optional[typing.TState], action: typing.ScheduledAction, duetime: typing.AbsoluteTime): self.scheduler = scheduler self.state = state self.action = action self.duetime = duetime self.disposable = SingleAssignmentDisposable()
def run(self): self.subscription = SerialDisposable() d = SingleAssignmentDisposable() self.subscription.disposable = d d.disposable = self.parent.source.subscribeSafe(self) return self.subscription
def subscribe_child(i, child): subscription = SingleAssignmentDisposable() def on_next(value): with parent.lock: values[i] = value subscription.disposable = child.subscribe_(on_next, observer.on_error, scheduler=scheduler) return subscription
def run(self): self.subscription = SingleAssignmentDisposable() self.loop = SingleAssignmentDisposable() self.startTime = self.parent.scheduler.now() self.subscription.disposable = self.parent.source.subscribeSafe( self) return CompositeDisposable(self.subscription, self.loop)
def createTimer(self, wId): m = SingleAssignmentDisposable() self.timerDisposable.disposable = m m.disposable = self.parent.scheduler.scheduleWithRelativeAndState( wId, self.parent.timeSpan, self.tick )
class AutoDetachObserver(Observer): def __init__(self, on_next=None, on_error=None, on_completed=None): self._on_next = on_next or noop self._on_error = on_error or default_error self._on_completed = on_completed or noop self._subscription = SingleAssignmentDisposable() self.is_stopped = False def on_next(self, value: Any) -> None: if self.is_stopped: return try: self._on_next(value) except Exception: self.dispose() raise def on_error(self, error) -> None: if self.is_stopped: return self.is_stopped = True try: self._on_error(error) finally: self.dispose() def on_completed(self) -> None: if self.is_stopped: return self.is_stopped = True try: self._on_completed() finally: self.dispose() def set_disposable(self, value): self._subscription.disposable = value subscription = property(fset=set_disposable) def dispose(self) -> None: self.is_stopped = True self._subscription.dispose() def fail(self, exn: Exception) -> bool: if self.is_stopped: return False self.is_stopped = True self._on_error(exn) return True
def __init__(self, on_next: Optional[typing.OnNext] = None, on_error: Optional[typing.OnError] = None, on_completed: Optional[typing.OnCompleted] = None) -> None: self._on_next = on_next or noop self._on_error = on_error or default_error self._on_completed = on_completed or noop self._subscription = SingleAssignmentDisposable() self.is_stopped = False
def run(self): self.gate = RLock() self.isStopped = False self.group = CompositeDisposable() self.sourceSubscription = SingleAssignmentDisposable() self.group.add(self.sourceSubscription) self.sourceSubscription.disposable = self.parent.sources.subscribeSafe(self) return self.group
def subscribe(observer, _=None): m = SingleAssignmentDisposable() d = SerialDisposable() d.disposable = m def action(scheduler, state): d.disposable = ScheduledDisposable(scheduler, source.subscribe(observer)) m.disposable = scheduler.schedule(action) return d
def onNext(self, value): observerId = 0 with self.gate: self.latest += 1 observerId = self.latest self.hasLatest = True d = SingleAssignmentDisposable() self.innerSubscription.disposable = d d.disposable = value.subscribeSafe(self.IdObserver(self, observerId, d))
def func(i): source = sources[i] sad = SingleAssignmentDisposable() source = from_future(source) if is_future(source) else source def on_next(x): queues[i].append(x) next(i) sad.disposable = source.subscribe_(on_next, observer.on_error, lambda: done(i), scheduler) subscriptions[i] = sad
def onNext(self, value): try: delay = self.parent.delaySelector(value) except Exception as e: with self.gate: self.observer.onError(e) self.dispose() else: d = SingleAssignmentDisposable() self.delays.add(d) d.disposable = delay.subscribeSafe(self.Delta(self, value, d))
def on_error(exception): try: result = handler(exception, source) except Exception as ex: # By design. pylint: disable=W0703 observer.on_error(ex) return result = rx.from_future(result) if is_future(result) else result d = SingleAssignmentDisposable() subscription.disposable = d d.disposable = result.subscribe(observer, scheduler=scheduler)
def subscribe(observer): m = SingleAssignmentDisposable() d = SerialDisposable() d.disposable = m def action(): d.disposable = SchedulerDisposable(scheduler, self.subscribeSafe(observer)) m.disposable = scheduler.schedule(action) return d
def func(i): subscriptions[i] = SingleAssignmentDisposable() def on_next(x): with parent.lock: values[i] = x _next(i) def on_completed(): with parent.lock: done(i) subscriptions[i].disposable = sources[i].subscribe_(on_next, observer.on_error, on_completed, scheduler)
def on_next(x: Any) -> None: has_value[0] = True value[0] = x _id[0] += 1 current_id = _id[0] d = SingleAssignmentDisposable() cancelable.disposable = d def action(scheduler, state=None) -> None: if has_value[0] and _id[0] == current_id: observer.on_next(value[0]) has_value[0] = False d.disposable = _scheduler.schedule_relative(duetime, action)