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;
}
}
