def invokeRec(self, scheduler, state):
time = 0
if self.hasResult:
self.observer.onNext(self.result)
try:
if self.first:
self.first = False
else:
state = self.parent.iterate(state)
self.hasResult = self.parent.condition(state)
if self.hasResult:
self.result = self.parent.resultSelector(state)
time = self.parent.timeSelector(state)
except Exception as e:
self.observer.onError(e)
self.dispose()
return Disposable.empty()
if not self.hasResult:
self.observer.onCompleted()
self.dispose()
return Disposable.empty()
return self.parent.scheduler.scheduleWithRelativeAndState(
state,
time,
self.invokeRec
)
def invokeRec(self, scheduler, state):
time = 0
if self.hasResult:
self.observer.onNext(self.result)
try:
if self.first:
self.first = False
else:
state = self.parent.iterate(state)
self.hasResult = self.parent.condition(state)
if self.hasResult:
self.result = self.parent.resultSelector(state)
time = self.parent.timeSelector(state)
except Exception as e:
self.observer.onError(e)
self.dispose()
return Disposable.empty()
if not self.hasResult:
self.observer.onCompleted()
self.dispose()
return Disposable.empty()
return self.parent.scheduler.scheduleWithRelativeAndState(
state, time, self.invokeRec)
def subscribeCore(self, observer):
old = None
new = None
while True:
old = self.observer.value
if old is DisposedObserver.instance:
raise Exception("Object has been disposed")
if old is DoneObserver.completed:
observer.onCompleted()
return Disposable.empty()
if isinstance(old, DoneObserver):
observer.onError(old.exception)
return Disposable.empty()
if old is NoopObserver.instance:
new = observer
else:
if isinstance(old, ListObserver):
new = old.add(observer)
else:
new = ListObserver((old, observer))
current = self.observer.compareExchange(new, old)
if old is current:
break
return self.Subscription(self, observer)
def subscribeCore(self, observer):
old = None
new = None
while True:
old = self.observer.value
if old is DisposedObserver.instance:
raise Exception("Object has been disposed")
if old is DoneObserver.completed:
observer.onCompleted()
return Disposable.empty()
if isinstance(old, DoneObserver):
observer.onError(old.exception)
return Disposable.empty()
if old is NoopObserver.instance:
new = observer
else:
if isinstance(old, ListObserver):
new = old.add(observer)
else:
new = ListObserver((old, observer))
current = self.observer.compareExchange(new, old)
if old is current:
break
return self.Subscription(self, observer)
def subscribeCore(self, observer):
ex = None
v = None
hv = False
with self.gate:
errorIfDisposed(self)
if not self.isStopped:
self.observers.append(observer)
return Subject.Subscription(self, observer)
ex = self.exception
hv = self.hasValue
v = self.value
if ex != None:
observer.onError(ex)
elif hv:
observer.onNext(v)
observer.onCompleted()
else:
observer.onCompleted()
return Disposable.empty()
def propagate(self, scheduler, currentId):
with self.gate:
if self.hasValue and self.resourceId == currentId:
self.observer.onNext(self.value)
self.hasValue = False
return Disposable.empty()
def connect(self, observer):
#
# We connect the given observer to the subject first, before performing any kind
# of initialization which will register an event handler. This is done to ensure
# we don't have a time gap between adding the handler and connecting the user's
# subject, e.g. when the ImmediateScheduler is used.
#
# [OK] Use of unsafe Subscribe: called on a known subject implementation.
#
connection = self.subject.subscribe(observer)
self.count += 1
if self.count == 1:
try:
self.initialize()
except Exception as e:
self.count -= 1
connection.dispose()
observer.onError(e)
return Disposable.empty()
def dispose():
connection.dispose()
with self.parent.gate:
self.count -=1
if self.count == 0:
self.parent.scheduler.schedule(self.removeHandler.dispose)
self.parent.session = None
return Disposable.create(dispose)
def scheduled(_, message):
# time = message[0]
notification = message[1]
notification.accept(observer)
return Disposable.empty()
def subscribeCore(self, observer):
ex = None
v = None
hv = False
with self.gate:
errorIfDisposed(self)
if not self.isStopped:
self.observers.append(observer)
return Subject.Subscription(self, observer)
ex = self.exception
hv = self.hasValue
v = self.value
if ex != None:
observer.onError(ex)
elif hv:
observer.onNext(v)
observer.onCompleted()
else:
observer.onCompleted()
return Disposable.empty()
def subscribeCore(self, observer):
d = self._subscribe(observer)
if d == None:
return Disposable.empty()
else:
return d
def scheduled(_, message):
# time = message[0]
notification = message[1]
notification.accept(observer)
return Disposable.empty()
def scheduled(_, message):
# time = message[0]
notification = message[1]
for o in list(self.observers):
notification.accept(o)
return Disposable.empty()
def scheduled():
try:
subject.onNext(action())
subject.onCompleted()
except Exception as e:
subject.onError(e)
return Disposable.empty()
def scheduledSubscribe(self, scheduler, autoDetachObserver):
try:
autoDetachObserver.disposable = self.subscribeCore(autoDetachObserver)
except Exception as e:
if not autoDetachObserver.fail(e):
raise e
return Disposable.empty()
def scheduled(_, message):
# time = message[0]
notification = message[1]
for o in list(self.observers):
notification.accept(o)
return Disposable.empty()
def scheduled():
try:
subject.onNext(action())
subject.onCompleted()
except Exception as e:
subject.onError(e)
return Disposable.empty()
def wrapper(observer):
a = subscribe(observer)
if isinstance(a, Disposable):
return a
elif callable(a):
return Disposable.create(a)
else:
return Disposable.empty()
def run(self):
try:
result = self.parent.eval()
except Exception as e:
self.observer.onError(e)
self.dispose()
return Disposable.empty()
else:
return result.subscribeSafe(self)
def wrapper(observer):
a = subscribe(observer)
if isinstance(a, Disposable):
return a
elif callable(a):
return Disposable.create(a)
else:
return Disposable.empty()
def run(self):
try:
result = self.parent.eval()
except Exception as e:
self.observer.onError(e)
self.dispose()
return Disposable.empty()
else:
return result.subscribeSafe(self)
def schedulerCallback(self, scheduler, state):
with self.lock:
if self.isAdded:
self.group.remove(self.cancel)
else:
self.isDone = True
self.run(state)
return Disposable.empty()
def schedulerCallback(self, scheduler, state):
with self.lock:
if self.isAdded:
self.group.remove(self.cancel)
else:
self.isDone = True
self.run(state)
return Disposable.empty()
def timeout(self, scheduler, currentId):
timerWins = False
with self.gate:
self.switched = self.currentId == currentId
timerWins = self.switched
if timerWins:
self.subscription.disposable = self.parent.other.subscribeSafe(self.getForewarder())
return Disposable.empty()
def tick(self, scheduler, state):
with self.gate:
if state.isSpan:
s = self.queue.popleft()
s.onCompleted()
if state.isShift:
self.createWindow()
self.createTimer()
return Disposable.empty()
def timeout(self, scheduler, currentId):
timerWins = False
with self.gate:
self.switched = self.currentId == currentId
timerWins = self.switched
if timerWins:
self.subscription.disposable = self.parent.other.subscribeSafe(
self.getForewarder())
return Disposable.empty()
def tick(self, scheduler, state):
with self.gate:
if state.isSpan:
s = self.queue.popleft()
self.observer.onNext(s)
if state.isShift:
self.createWindow()
self.createTimer()
return Disposable.empty()
def subscribeSafe(self, observer):
if isinstance(self, ObservableBase):
return self.subscribeCore(observer)
elif isinstance(self, Producer):
return self.subscribeRaw(observer, False)
d = Disposable.empty()
try:
d = self.subscribeCore(observer)
except Exception as e:
observer.onError(e)
return d
def run(self):
source = None
disposable = Disposable.empty()
try:
resource = self.parent.resourceFactory()
if resource != None:
disposable = resource
source = self.parent.observableFactory(resource)
except Exception as e:
return CompositeDisposable(Observable.throw(e).subscribeSafe(self), disposable)
return CompositeDisposable(source.subscribeSafe(self), disposable)
def run(self):
source = None
disposable = Disposable.empty()
try:
resource = self.parent.resourceFactory()
if resource != None:
disposable = resource
source = self.parent.observableFactory(resource)
except Exception as e:
return CompositeDisposable(
Observable.throw(e).subscribeSafe(self), disposable)
return CompositeDisposable(source.subscribeSafe(self), disposable)
def run(self):
observable = None
connectable = None
try:
subject = self.parent.subjectSelector()
connectable = ConnectableObservable(self.parent.source, subject)
observable = self.parent.selector(connectable)
except Exception as e:
self.observer.onError(e)
self.dispose()
return Disposable.empty()
else:
subscription = observable.subscribeSafe(self)
connection = connectable.connect()
return CompositeDisposable(subscription, connection)
def run(self):
it = None
try:
it = iter(self.parent.source)
except Exception as e:
self.observer.onError(e)
self.dispose()
return Disposable.empty()
scheduler = self.parent.scheduler
if scheduler.isLongRunning:
return scheduler.scheduleLongRunningWithState(it, self.loop)
else:
flag = BooleanDisposable()
scheduler.scheduleRecursiveWithState(Struct(flag=flag, it=it), self.loopRec)
return flag
def addHandler(self, scheduler, onNext):
try:
removeHandler = self.parent.addHandler(onNext)
except Exception as e:
self.subject.onError(e)
else:
self.removeHandler.disposable = removeHandler
#
# We don't propagate the exception to the OnError channel upon Dispose. This is
# not possible at this stage, because we've already auto-detached in the base
# class Producer implementation. Even if we would switch the OnError and auto-
# detach calls, it wouldn't work because the remove handler logic is scheduled
# on the given scheduler, causing asynchrony. We can't block waiting for the
# remove handler to run on the scheduler.
#
return Disposable.empty()
def run(self):
observable = None
connectable = None
try:
subject = self.parent.subjectSelector()
connectable = ConnectableObservable(self.parent.source,
subject)
observable = self.parent.selector(connectable)
except Exception as e:
self.observer.onError(e)
self.dispose()
return Disposable.empty()
else:
subscription = observable.subscribeSafe(self)
connection = connectable.connect()
return CompositeDisposable(subscription, connection)
def run(self):
it = None
try:
it = iter(self.parent.source)
except Exception as e:
self.observer.onError(e)
self.dispose()
return Disposable.empty()
scheduler = self.parent.scheduler
if scheduler.isLongRunning:
return scheduler.scheduleLongRunningWithState(it, self.loop)
else:
flag = BooleanDisposable()
scheduler.scheduleRecursiveWithState(Struct(flag=flag, it=it),
self.loopRec)
return flag
def tick(self, scheduler, wId):
d = Disposable.empty()
newId = 0
with self.gate:
if wId != self.windowId:
return d
self.n = 0
self.windowId += 1
newId = self.windowId
res = self.list
self.list = []
self.observer.onNext(res)
self.createTimer(newId)
return d
def tick(self, scheduler, wId):
d = Disposable.empty()
newId = 0
with self.gate:
if wId != self.windowId:
return d
self.n = 0
self.windowId += 1
newId = self.windowId
self.s.onCompleted()
self.s = Subject()
self.observer.onNext(AddRef(self.s, self.refCountDisposable))
self.createTimer(newId)
return d
def tick(self, scheduler, wId):
d = Disposable.empty()
newId = 0
with self.gate:
if wId != self.windowId:
return d
self.n = 0
self.windowId += 1
newId = self.windowId
res = self.list
self.list = []
self.observer.onNext(res)
self.createTimer(newId)
return d
def tick(self, scheduler, wId):
d = Disposable.empty()
newId = 0
with self.gate:
if wId != self.windowId:
return d
self.n = 0
self.windowId += 1
newId = self.windowId
self.s.onCompleted()
self.s = Subject()
self.observer.onNext(AddRef(self.s, self.refCountDisposable))
self.createTimer(newId)
return d
def _replace(disposable): cancel.disposable = disposable return Disposable.empty()
def subscribeCore(self, observer): return Disposable.empty()
def scheduledCreate():
state.source = factory()
return Disposable.empty()
def scheduledSubscribe():
state.subscription = state.source.subscribe(state.observer)
return Disposable.empty()
def invokeAction(scheduler, action):
action()
return Disposable.empty()
def scheduledCreate(): state.source = factory() return Disposable.empty()
def scheduledDispose(): state.subscription.dispose() return Disposable.empty()
def invokeAction(scheduler, action): action() return Disposable.empty()
def subscribeCore(self, observer):
return Disposable.empty()
def scheduled(): subscription.disposable = self.run(observer, subscription, assignSink) return Disposable.empty()
def __call__(self, _self, _state):
try:
return self.action(self.parent._getRecursiveWrapper(_self), _state)
except Exception as e:
if not self.parent._handler(e): raise e
return Disposable.empty()
def scheduledSubscribe(): state.subscription = state.source.subscribe(state.observer) return Disposable.empty()
def __call__(self, _self, _state):
try:
return self.action(self.parent._getRecursiveWrapper(_self), _state)
except Exception as e:
if not self.parent._handler(e): raise e
return Disposable.empty()
def _replace(disposable):
cancel.disposable = disposable
return Disposable.empty()
def scheduledDispose():
state.subscription.dispose()
return Disposable.empty()
