def test_refcountdisposable_singlereference(): d = BooleanDisposable() r = RefCountDisposable(d) assert not d.is_disposed r.dispose() assert d.is_disposed r.dispose() assert d.is_disposed
def test_refcountdisposable_primarydisposesfirst(): d = BooleanDisposable() r = RefCountDisposable(d) assert not d.is_disposed; d1 = r.disposable d2 = r.disposable assert not d.is_disposed d1.dispose() assert not d.is_disposed r.dispose() assert not d.is_disposed d2.dispose() assert d.is_disposed
def test_refcountdisposable_primarydisposesfirst(): d = BooleanDisposable() r = RefCountDisposable(d) assert not d.is_disposed d1 = r.disposable d2 = r.disposable assert not d.is_disposed d1.dispose() assert not d.is_disposed r.dispose() assert not d.is_disposed d2.dispose() assert d.is_disposed
def test_refcountdisposable_refcounting(): d = BooleanDisposable() r = RefCountDisposable(d) assert not d.is_disposed d1 = r.disposable d2 = r.disposable assert not d.is_disposed d1.dispose() assert not d.is_disposed d2.dispose() assert not d.is_disposed r.dispose() assert d.is_disposed d3 = r.disposable d3.dispose()
def subscribe(observer, scheduler=None): window = [Subject()] d = CompositeDisposable() r = RefCountDisposable(d) observer.on_next(add_ref(window[0], r)) def on_next_window(x): window[0].on_next(x) def on_error(err): window[0].on_error(err) observer.on_error(err) def on_completed(): window[0].on_completed() observer.on_completed() d.add(source.subscribe_(on_next_window, on_error, on_completed, scheduler)) def on_next_observer(w): window[0].on_completed() window[0] = Subject() observer.on_next(add_ref(window[0], r)) d.add(window_boundaries.subscribe_(on_next_observer, on_error, on_completed, scheduler)) return r
def subscribe(observer): n = [0] s = [None] timer_d = SerialDisposable() window_id = [0] group_disposable = CompositeDisposable(timer_d) ref_count_disposable = RefCountDisposable(group_disposable) def create_timer(_id): m = SingleAssignmentDisposable() timer_d.disposable = m def action(scheduler, state): if _id != window_id[0]: return n[0] = 0 window_id[0] += 1 new_id = window_id[0] s[0].on_completed() s[0] = Subject() observer.on_next(add_ref(s[0], ref_count_disposable)) create_timer(new_id) m.disposable = scheduler.schedule_relative(timespan, action) s[0] = Subject() observer.on_next(add_ref(s[0], ref_count_disposable)) create_timer(0) def on_next(x): new_window = False new_id = 0 s[0].on_next(x) n[0] += 1 if n[0] == count: new_window = True n[0] = 0 window_id[0] += 1 new_id = window_id[0] s[0].on_completed() s[0] = Subject() observer.on_next(add_ref(s[0], ref_count_disposable)) if new_window: create_timer(new_id) def on_error(e): s[0].on_error(e) observer.on_error(e) def on_completed(): s[0].on_completed() observer.on_completed() group_disposable.add( source.subscribe(on_next, on_error, on_completed)) return ref_count_disposable
def subscribe(observer): m = SerialDisposable() d = CompositeDisposable(m) r = RefCountDisposable(d) window = [Subject()] observer.on_next(add_ref(window[0], r)) def on_next(x): window[0].on_next(x) def on_error(ex): window[0].on_error(ex) observer.on_error(ex) def on_completed(): window[0].on_completed() observer.on_completed() d.add(source.subscribe(on_next, on_error, on_completed)) def create_window_close(): try: window_close = window_closing_selector() except Exception as exception: log.error("*** Exception: %s" % exception) observer.on_error(exception) return def on_completed(): window[0].on_completed() window[0] = Subject() observer.on_next(add_ref(window[0], r)) create_window_close() m1 = SingleAssignmentDisposable() m.disposable = m1 m1.disposable = window_close.take(1).subscribe( noop, on_error, on_completed) create_window_close() return r
def subscribe(observer, scheduler=None): m = SingleAssignmentDisposable() refCountDisposable = RefCountDisposable(m) n = [0] q = [] def create_window(): s = Subject() q.append(s) observer.on_next(add_ref(s, refCountDisposable)) create_window() def on_next(x): for item in q: item.on_next(x) c = n[0] - count + 1 if c >= 0 and c % skip == 0: s = q.pop(0) s.on_completed() n[0] += 1 if (n[0] % skip) == 0: create_window() def on_error(exception): while len(q): q.pop(0).on_error(exception) observer.on_error(exception) def on_completed(): while len(q): q.pop(0).on_completed() observer.on_completed() m.disposable = source.subscribe_(on_next, on_error, on_completed, scheduler) return refCountDisposable
def subscribe(observer): timerD = SerialDisposable() next_shift = timeshift next_span = timespan total_time = 0 q = [] group_disposable = CompositeDisposable(timerD) ref_count_disposable = RefCountDisposable(group_disposable) def create_timer(): nonlocal q, total_time, next_span, next_shift m = SingleAssignmentDisposable() timerD.disposable = m is_span = False is_shift = False if next_span == next_shift: is_span = True is_shift = True elif next_span < next_shift: is_span = True else: is_shift = True new_total_time = next_span if is_span else next_shift ts = new_total_time - total_time total_time = new_total_time if is_span: next_span += timeshift if is_shift: next_shift += timeshift def action(scheduler, state=None): s = None if is_shift: s = Subject() q.append(s) observer.on_next(add_ref(s, ref_count_disposable)) if is_span: s = q.pop(0) s.on_completed() create_timer() m.disposable = scheduler.schedule_relative(ts, action) q.append(Subject()) observer.on_next(add_ref(q[0], ref_count_disposable)) create_timer() def on_next(x): for s in q: s.on_next(x) def on_error(e): for s in q: s.on_error(e) observer.on_error(e) def on_completed(): for s in q: s.on_completed() observer.on_completed() group_disposable.add( source.subscribe(on_next, on_error, on_completed)) return ref_count_disposable
def subscribe(observer): n = 0 s = None timerD = SerialDisposable() window_id = 0 group_disposable = CompositeDisposable(timerD) ref_count_disposable = RefCountDisposable(group_disposable) def create_timer(_id): m = SingleAssignmentDisposable() timerD.disposable = m def action(scheduler, state): nonlocal n, s, window_id if _id != window_id: return n = 0 window_id += 1 new_id = window_id s.on_completed() s = Subject() observer.on_next(add_ref(s, ref_count_disposable)) create_timer(new_id) m.disposable = scheduler.schedule_relative(timespan, action) s = Subject() observer.on_next(add_ref(s, ref_count_disposable)) create_timer(0) def on_next(x): nonlocal s, n, window_id new_window = False new_id = 0 s.on_next(x) n += 1 if n == count: new_window = True n = 0 window_id += 1 new_id = window_id s.on_completed() s = Subject() observer.on_next(add_ref(s, ref_count_disposable)) if new_window: create_timer(new_id) def on_error(e): s.on_error(e) observer.on_error(e) def on_completed(): s.on_completed() observer.on_completed() group_disposable.add( source.subscribe(on_next, on_error, on_completed)) return ref_count_disposable
def subscribe(observer): timer_d = SerialDisposable() next_shift = [timeshift] next_span = [timespan] total_time = [timedelta(0)] q = [] group_disposable = CompositeDisposable(timer_d) ref_count_disposable = RefCountDisposable(group_disposable) def create_timer(): m = SingleAssignmentDisposable() timer_d.disposable = m is_span = False is_shift = False if next_span[0] == next_shift[0]: is_span = True is_shift = True elif next_span[0] < next_shift[0]: is_span = True else: is_shift = True new_total_time = next_span[0] if is_span else next_shift[0] ts = new_total_time - total_time[0] total_time[0] = new_total_time if is_span: next_span[0] += timeshift if is_shift: next_shift[0] += timeshift def action(scheduler, state=None): s = None if is_shift: s = Subject() q.append(s) observer.on_next(add_ref(s, ref_count_disposable)) if is_span: s = q.pop(0) s.on_completed() create_timer() m.disposable = scheduler.schedule_relative(ts, action) q.append(Subject()) observer.on_next(add_ref(q[0], ref_count_disposable)) create_timer() def on_next(x): for s in q: s.on_next(x) def on_error(e): for s in q: s.on_error(e) observer.on_error(e) def on_completed(): for s in q: s.on_completed() observer.on_completed() group_disposable.add( source.subscribe(on_next, on_error, on_completed)) return ref_count_disposable
def subscribe(observer, scheduler=None): writers = OrderedDict() group_disposable = CompositeDisposable() ref_count_disposable = RefCountDisposable(group_disposable) def on_next(x): writer = None key = None try: key = key_mapper(x) except Exception as e: for wrt in writers.values(): wrt.on_error(e) observer.on_error(e) return fire_new_map_entry = False writer = writers.get(key) if not writer: writer = Subject() writers[key] = writer fire_new_map_entry = True if fire_new_map_entry: group = GroupedObservable(key, writer, ref_count_disposable) duration_group = GroupedObservable(key, writer) try: duration = duration_mapper(duration_group) except Exception as e: for wrt in writers.values(): wrt.on_error(e) observer.on_error(e) return observer.on_next(group) sad = SingleAssignmentDisposable() group_disposable.add(sad) def expire(): if writers[key]: del writers[key] writer.on_completed() group_disposable.remove(sad) def on_next(value): pass def on_error(exn): for wrt in writers.values(): wrt.on_error(exn) observer.on_error(exn) def on_completed(): expire() sad.disposable = duration.take(1).subscribe_( on_next, on_error, on_completed, scheduler) try: element = element_mapper(x) except Exception as error: for wrt in writers.values(): wrt.on_error(error) observer.on_error(error) return writer.on_next(element) def on_error(ex): for wrt in writers.values(): wrt.on_error(ex) observer.on_error(ex) def on_completed(): for wrt in writers.values(): wrt.on_completed() observer.on_completed() group_disposable.add( source.subscribe_(on_next, on_error, on_completed, scheduler)) return ref_count_disposable
def subscribe(observer): mapping = OrderedDict() group_disposable = CompositeDisposable() ref_count_disposable = RefCountDisposable(group_disposable) def on_next(x): writer = None key = None try: key = key_selector(x) except Exception as e: for w in mapping.values(): w.on_error(e) observer.on_error(e) return fire_new_map_entry = False writer = mapping.get(key) if not writer: writer = Subject() mapping[key] = writer fire_new_map_entry = True if fire_new_map_entry: group = GroupedObservable(key, writer, ref_count_disposable) duration_group = GroupedObservable(key, writer) try: duration = duration_selector(duration_group) except Exception as e: for w in mapping.values(): w.on_error(e) observer.on_error(e) return observer.on_next(group) md = SingleAssignmentDisposable() group_disposable.add(md) def expire(): if mapping[key]: del mapping[key] writer.on_completed() group_disposable.remove(md) def on_next(value): pass def on_error(exn): for wr in mapping.values(): wr.on_error(exn) observer.on_error(exn) def on_completed(): expire() md.disposable = duration.take(1).subscribe(on_next, on_error, on_completed) try: element = element_selector(x) except Exception as e: for w in mapping.values(): w.on_error(e) observer.on_error(e) return writer.on_next(element) def on_error(ex): for w in mapping.values(): w.on_error(ex) observer.on_error(ex) def on_completed(): for w in mapping.values(): w.on_completed() observer.on_completed() group_disposable.add(source.subscribe(on_next, on_error, on_completed)) return ref_count_disposable
def subscribe(observer): nothing = lambda _: None group = CompositeDisposable() r = RefCountDisposable(group) left_map = OrderedDict() right_map = OrderedDict() left_id = [0] right_id = [0] def on_next_left(value): s = Subject() with self.lock: _id = left_id[0] left_id[0] += 1 left_map[_id] = s try: result = result_selector(value, add_ref(s, r)) except Exception as e: log.error("*** Exception: %s" % e) for left_value in left_map.values(): left_value.on_error(e) observer.on_error(e) return observer.on_next(result) for right_value in right_map.values(): s.on_next(right_value) md = SingleAssignmentDisposable() group.add(md) def expire(): if _id in left_map: del left_map[_id] s.on_completed() group.remove(md) try: duration = left_duration_selector(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(e): for left_value in left_map.values(): left_value.on_error(e) observer.on_error(e) md.disposable = duration.take(1).subscribe(nothing, on_error, expire) def on_error_left(e): for left_value in left_map.values(): left_value.on_error(e) observer.on_error(e) group.add( left.subscribe(on_next_left, on_error_left, observer.on_completed)) def on_next_right(value): with self.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_selector(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(e): with self.lock: for left_value in left_map.values(): left_value.on_error(e) observer.on_error(e) md.disposable = duration.take(1).subscribe(nothing, on_error, expire) with self.lock: for left_value in left_map.values(): left_value.on_next(value) def on_error_right(e): for left_value in left_map.values(): left_value.on_error(e) observer.on_error(e) group.add(right.subscribe(on_next_right, on_error_right)) return r
def subscribe(observer): m = SingleAssignmentDisposable() ref_count_disposable = RefCountDisposable(m) parser = HttpParser(observer, ref_count_disposable) m.disposable = source.subscribe(parser) return ref_count_disposable