public IDisposable Run() { isFirstSubscribe = true; isDisposed = false; isStopped = false; e = parent.sources.GetEnumerator(); subscription = new SerialDisposable(); schedule = new SingleAssignmentDisposable(); UniRx.IObservable <Unit> trigger = parent.trigger; Action <Unit> onNext = delegate { lock (gate) { isStopped = true; e.Dispose(); subscription.Dispose(); schedule.Dispose(); base.observer.OnCompleted(); } }; UniRx.IObserver <T> observer = base.observer; stopper = trigger.Subscribe(onNext, observer.OnError); schedule.Disposable = Scheduler.CurrentThread.Schedule(RecursiveRun); return(new CompositeDisposable(schedule, subscription, stopper, Disposable.Create(delegate { lock (gate) { isDisposed = true; e.Dispose(); } }))); }
public DelayObservable(UniRx.IObservable <T> source, TimeSpan dueTime, IScheduler scheduler) : base(scheduler == Scheduler.CurrentThread || source.IsRequiredSubscribeOnCurrentThread()) { this.source = source; this.dueTime = dueTime; this.scheduler = scheduler; }
public ZipLatestObservable(UniRx.IObservable <TLeft> left, UniRx.IObservable <TRight> right, Func <TLeft, TRight, TResult> selector) : base(left.IsRequiredSubscribeOnCurrentThread() || right.IsRequiredSubscribeOnCurrentThread()) { this.left = left; this.right = right; this.selector = selector; }
public BatchFrameObservable(UniRx.IObservable <T> source, int frameCount, FrameCountType frameCountType) : base(source.IsRequiredSubscribeOnCurrentThread()) { this.source = source; this.frameCount = frameCount; this.frameCountType = frameCountType; }
public IDisposable Run() { length = sources.Length; if (length == 0) { OnNext(new T[0]); try { base.observer.OnCompleted(); } finally { Dispose(); } return(Disposable.Empty); } completedCount = 0; values = new T[length]; IDisposable[] array = new IDisposable[length]; for (int i = 0; i < length; i++) { UniRx.IObservable <T> observable = sources[i]; WhenAllCollectionObserver observer = new WhenAllCollectionObserver(this, i); array[i] = observable.Subscribe(observer); } return(StableCompositeDisposable.CreateUnsafe(array)); }
public TakeLastObservable(UniRx.IObservable <T> source, TimeSpan duration, IScheduler scheduler) : base(scheduler == Scheduler.CurrentThread || source.IsRequiredSubscribeOnCurrentThread()) { this.source = source; this.duration = duration; this.scheduler = scheduler; }
public FirstObservable(UniRx.IObservable <T> source, Func <T, bool> predicate, bool useDefault) : base(source.IsRequiredSubscribeOnCurrentThread()) { this.source = source; this.predicate = predicate; this.useDefault = useDefault; }
public SampleObservable(UniRx.IObservable <T> source, TimeSpan interval, IScheduler scheduler) : base(source.IsRequiredSubscribeOnCurrentThread() || scheduler == Scheduler.CurrentThread) { this.source = source; this.interval = interval; this.scheduler = scheduler; }
public TimeoutObservable(UniRx.IObservable <T> source, DateTimeOffset dueTime, IScheduler scheduler) : base(scheduler == Scheduler.CurrentThread || source.IsRequiredSubscribeOnCurrentThread()) { this.source = source; dueTimeDT = dueTime; this.scheduler = scheduler; }
public static IDisposable SubscribeToInteractable(this UniRx.IObservable <bool> source, Selectable selectable) { return(source.SubscribeWithState(selectable, delegate(bool x, Selectable s) { s.interactable = x; })); }
public static IDisposable SubscribeToText(this UniRx.IObservable <string> source, Text text) { return(source.SubscribeWithState(text, delegate(string x, Text t) { t.text = x; })); }
public static IDisposable SubscribeToText <T>(this UniRx.IObservable <T> source, Text text) { return(source.SubscribeWithState(text, delegate(T x, Text t) { t.text = x.ToString(); })); }
public static IDisposable SubscribeToText <T>(this UniRx.IObservable <T> source, Text text, Func <T, string> selector) { return(source.SubscribeWithState2(text, selector, delegate(T x, Text t, Func <T, string> s) { t.text = s(x); })); }
public ReadOnlyReactiveProperty(UniRx.IObservable <T> source, T initialValue, bool distinctUntilChanged) { this.distinctUntilChanged = distinctUntilChanged; value = initialValue; canPublishValueOnSubscribe = true; sourceConnection = source.Subscribe(new ReadOnlyReactivePropertyObserver(this)); }
public WhereSelectObservable(UniRx.IObservable <T> source, Func <T, bool> predicate, Func <T, TR> selector) : base(source.IsRequiredSubscribeOnCurrentThread()) { this.source = source; this.predicate = predicate; this.selector = selector; }
public override void OnCompleted() { parent.collectionDisposable.Remove(cancel); lock (parent.gate) { if (parent.q.Count > 0) { UniRx.IObservable <T> innerSource = parent.q.Dequeue(); parent.Subscribe(innerSource); } else { parent.activeCount--; if (parent.isStopped && parent.activeCount == 0) { try { observer.OnCompleted(); } finally { Dispose(); } } } } }
public BufferObservable(UniRx.IObservable <T> source, int count, int skip) : base(source.IsRequiredSubscribeOnCurrentThread()) { this.source = source; this.count = count; this.skip = skip; }
public RepeatUntilObservable(IEnumerable <UniRx.IObservable <T> > sources, UniRx.IObservable <Unit> trigger, GameObject lifeTimeChecker) : base(isRequiredSubscribeOnCurrentThread: true) { this.sources = sources; this.trigger = trigger; this.lifeTimeChecker = lifeTimeChecker; }
private void RecursiveRun(Action self) { lock (gate) { nextSelf = self; if (!isDisposed && !isStopped) { UniRx.IObservable <T> observable = null; bool flag = false; Exception ex = null; try { flag = e.MoveNext(); if (flag) { observable = e.Current; if (observable == null) { throw new InvalidOperationException("sequence is null."); } } else { e.Dispose(); } } catch (Exception ex2) { ex = ex2; e.Dispose(); } if (ex != null) { stopper.Dispose(); observer.OnError(ex); } else if (!flag) { stopper.Dispose(); observer.OnCompleted(); } else { UniRx.IObservable <T> current = e.Current; SingleAssignmentDisposable singleAssignmentDisposable = new SingleAssignmentDisposable(); subscription.Disposable = singleAssignmentDisposable; if (isFirstSubscribe) { isFirstSubscribe = false; singleAssignmentDisposable.Disposable = current.Subscribe(this); } else { MainThreadDispatcher.SendStartCoroutine(SubscribeAfterEndOfFrame(singleAssignmentDisposable, current, this, parent.lifeTimeChecker)); } } } } }
public DoObservable(UniRx.IObservable <T> source, Action <T> onNext, Action <Exception> onError, Action onCompleted) : base(source.IsRequiredSubscribeOnCurrentThread()) { this.source = source; this.onNext = onNext; this.onError = onError; this.onCompleted = onCompleted; }
public static bool IsRequiredSubscribeOnCurrentThread <T>(this UniRx.IObservable <T> source, IScheduler scheduler) { if (scheduler == Scheduler.CurrentThread) { return(true); } return(source.IsRequiredSubscribeOnCurrentThread()); }
public BufferObservable(UniRx.IObservable <T> source, TimeSpan timeSpan, int count, IScheduler scheduler) : base(scheduler == Scheduler.CurrentThread || source.IsRequiredSubscribeOnCurrentThread()) { this.source = source; this.timeSpan = timeSpan; this.count = count; this.scheduler = scheduler; }
public override void OnNext(UniRx.IObservable <T> value) { SingleAssignmentDisposable singleAssignmentDisposable = new SingleAssignmentDisposable(); collectionDisposable.Add(singleAssignmentDisposable); Merge observer = new Merge(this, singleAssignmentDisposable); singleAssignmentDisposable.Disposable = value.Subscribe(observer); }
private void Subscribe(UniRx.IObservable <T> innerSource) { SingleAssignmentDisposable singleAssignmentDisposable = new SingleAssignmentDisposable(); collectionDisposable.Add(singleAssignmentDisposable); Merge observer = new Merge(this, singleAssignmentDisposable); singleAssignmentDisposable.Disposable = innerSource.Subscribe(observer); }
public GroupByObservable(UniRx.IObservable <TSource> source, Func <TSource, TKey> keySelector, Func <TSource, TElement> elementSelector, int?capacity, IEqualityComparer <TKey> comparer) : base(source.IsRequiredSubscribeOnCurrentThread()) { this.source = source; this.keySelector = keySelector; this.elementSelector = elementSelector; this.capacity = capacity; this.comparer = comparer; }
public void Color(UniRx.IObservable <UnityEngine.Color> color) { var g = gObject; var sub = color.Subscribe((c) => { g.titleColor = c; }); uiBase.AddDisposable(sub); }
public override void OnNext(UniRx.IObservable <T> value) { ulong id = 0uL; lock (gate) { id = ++latest; hasLatest = true; } SingleAssignmentDisposable singleAssignmentDisposable = new SingleAssignmentDisposable(); innerSubscription.Disposable = singleAssignmentDisposable; singleAssignmentDisposable.Disposable = value.Subscribe(new Switch(this, id)); }
public override void OnNext(UniRx.IObservable <T> value) { lock (gate) { if (activeCount < parent.maxConcurrent) { activeCount++; Subscribe(value); } else { q.Enqueue(value); } } }
public ObservableYieldInstruction(UniRx.IObservable <T> source, bool reThrowOnError, CancellationToken cancel) { moveNext = true; this.reThrowOnError = reThrowOnError; this.cancel = cancel; try { subscription = source.Subscribe(new ToYieldInstruction(this)); } catch { moveNext = false; throw; } }
internal YieldInstruction(UniRx.IObservable <T> source, bool rethrowOnError) { this.rethrowOnError = rethrowOnError; try { var observer = new ObserverYieldInstruction(this); subscription = source.Subscribe(observer); } catch { moveNext = false; throw; } }