public static ISingle <T> OnErrorReturn <T>(this ISingle <T> source, Func <T> valueSupplier) { return(Create <T>(s => { source.Subscribe(new OnErrorReturnSingleSubscriber <T>(s, valueSupplier)); })); }
public void PrintSubDataType(int indnt, StreamWriter writer, ISingle s) { if (s != null) { indent(indnt, writer); writer.Write("<ISingle/>\n"); } }
public static ISingle <R> Map <T, R>(this ISingle <T> source, Func <T, R> mapper) { return(Create <R>(s => { source.Subscribe(new MapSingleSubscriber <T, R>(s, mapper)); })); }
public static ISingle <T> Timeout <T>(this ISingle <T> source, TimeSpan timeout, IScheduler scheduler, ISingle <T> other = null) { return(Create <T>(s => { source.Subscribe(new TimeoutSingleSubscriber <T>(s, timeout, scheduler, other)); })); }
public static ISingle <T> UnsubscribeOn <T>(this ISingle <T> source, IScheduler scheduler) { return(Create <T>(s => { source.Subscribe(new UnsubscribeOnSingleSubscriber <T>(s, scheduler)); })); }
public static ISingle <T> Delay <T>(this ISingle <T> source, TimeSpan delay, IScheduler scheduler, bool delayError = false) { return(Create <T>(s => { source.Subscribe(new DelaySingeSubscriber <T>(s, delay, scheduler, delayError)); })); }
public static ISingle <T> OnErrorResumeNext <T>(this ISingle <T> source, Func <Exception, ISingle <T> > resumeWith) { return(Create <T>(s => { source.Subscribe(new ResumeNextSingleSubscriber <T>(s, resumeWith)); })); }
public static ISingle <R> Zip <T, R>( ISingle <T> s1, ISingle <T> s2, Func <T, T, R> zipper) { return(Zip( new ISingle <T>[] { s1, s2 }, LambdaHelper.ToFuncN(zipper))); }
public static IDisposable Subscribe <T>(this ISingle <T> source) { LambdaSingleSubscriber <T> lss = new LambdaSingleSubscriber <T>(v => { }, e => { }); source.Subscribe(lss); return(lss); }
public static IDisposable Subscribe <T>(this ISingle <T> source, IObserver <T> observer) { ObserverToSingleSubscriber <T> oss = new ObserverToSingleSubscriber <T>(observer); source.Subscribe(oss); return(oss); }
public TimeoutSingleSubscriber(ISingleSubscriber <T> actual, TimeSpan timeout, IScheduler scheduler, ISingle <T> other) { this.actual = actual; this.timeout = timeout; this.scheduler = scheduler; this.other = other; }
public static T Get <T>(this ISingle <T> source) { LatchedSingleSubscriber <T> lss = new LatchedSingleSubscriber <T>(); source.Subscribe(lss); return(lss.Get()); }
public static T Get <T>(this ISingle <T> source, TimeSpan timeout) { LatchedSingleSubscriber <T> lss = new LatchedSingleSubscriber <T>(); source.Subscribe(lss); return(lss.Get(timeout)); }
public static ISingle <T> DoOnError <T>(this ISingle <T> source, Action <Exception> onErrorCall) { return(Create <T>(s => { source.Subscribe(new LifecycleSingleSubscriber <T>(s, d => { }, v => { }, onErrorCall, () => { } )); })); }
public static ICompletable ToCompletable <T>(this ISingle <T> source) { return(Completable.Create(cs => { SingleSubscriberToCompletableSubscriber <T> sscs = new SingleSubscriberToCompletableSubscriber <T>(cs); source.Subscribe(sscs); })); }
public static ISingle <T> DoOnSubscribe <T>(this ISingle <T> source, Action <IDisposable> onSubscribeCall) { return(Create <T>(s => { source.Subscribe(new LifecycleSingleSubscriber <T>(s, onSubscribeCall, v => { }, e => { }, () => { } )); })); }
public static ISingle <T> DoAfterTerminate <T>(this ISingle <T> source, Action onAfterTerminateCall) { return(Create <T>(s => { source.Subscribe(new LifecycleSingleSubscriber <T>(s, d => { }, v => { }, e => { }, onAfterTerminateCall )); })); }
public static ISingle <T> DoOnSuccess <T>(this ISingle <T> source, Action <T> onSuccessCall) { return(Create <T>(s => { source.Subscribe(new LifecycleSingleSubscriber <T>(s, d => { }, onSuccessCall, e => { }, () => { } )); })); }
public static ISingle <T> Retry <T>(this ISingle <T> source, long times) { return(Create <T>(s => { RetryFiniteSingleSubscriber <T> riss = new RetryFiniteSingleSubscriber <T>(source, s, times); riss.Resubscribe(); })); }
public static ISingle <T> Retry <T>(this ISingle <T> source, Func <Exception, bool> shouldRetry) { return(Create <T>(s => { RetryIfSingleSubscriber <T> riss = new RetryIfSingleSubscriber <T>(source, s, shouldRetry); riss.Resubscribe(); })); }
public static ISingle <T> DelaySubscription <T, U>(this ISingle <T> source, IPublisher <U> other) { return(Create <T>(s => { DelaySubscriptionByPublisherSingleSubscriber <T, U> subscriber = new DelaySubscriptionByPublisherSingleSubscriber <T, U>(source, s); s.OnSubscribe(subscriber); other.Subscribe(subscriber); })); }
public static IPublisher <T> ToPublisher <T>(this ISingle <T> source) { if (source is ScalarSource <T> ) { return((ScalarSource <T>)source); } return(Flowable.Create <T>(s => { source.Subscribe(new SubscriberToSingleSubscriber <T>(s)); })); }
public static ISingle <R> Zip <T1, T2, T3, T4, R>( ISingle <T1> s1, ISingle <T2> s2, ISingle <T3> s3, ISingle <T4> s4, Func <T1, T2, T3, T4, R> zipper) { return(Zip( new ISingle <object>[] { (ISingle <object>)s1, (ISingle <object>)s2, (ISingle <object>)s3, (ISingle <object>)s4, }, LambdaHelper.ToFuncN(zipper))); }
public static ISingle <T> DelaySubscription <T, U>(this ISingle <T> source, IObservable <U> other) { return(Create <T>(s => { DelaySubscriptionByObservableSingleSubscriber <T, U> observer = new DelaySubscriptionByObservableSingleSubscriber <T, U>(source, s); s.OnSubscribe(observer); IDisposable a = other.Subscribe(observer); observer.Set(a); })); }
/// <summary> /// функция обработки одного аргумента /// </summary> /// <param name="sender">выполнить действие</param> /// <param name="e"></param> private void ActionSingle(object sender, EventArgs e) { try { double first = Convert.ToDouble(textBox1.Text.Replace(".", ",")); ISingle calculator = FactorySingle.Create(((Button)sender).Name); double answer = calculator.Action(first); textBox3.Text = answer.ToString(); } catch (Exception ex) { MessageBox.Show("Произошла ошибка: " + ex.Message); } }
public static ISingle <bool> Equals <T>(this ISingle <T> first, ISingle <T> second) { return(Create <bool>(s => { T[] array = new T[2]; int[] counter = { 2 }; SetCompositeDisposable all = new SetCompositeDisposable(); s.OnSubscribe(all); first.Subscribe(new EqualsSingleSubscriber <T>(s, 0, array, counter, all)); second.Subscribe(new EqualsSingleSubscriber <T>(s, 1, array, counter, all)); })); }
public static ISingle <T> SubscribeOn <T>(this ISingle <T> source, IScheduler scheduler) { return(Create <T>(s => { MultipleAssignmentDisposable inner = new MultipleAssignmentDisposable(); MultipleAssignmentDisposable mad = new MultipleAssignmentDisposable(inner); inner.Set(scheduler.ScheduleDirect(() => { source.Subscribe(new SingleSubscriberWrapper <T>(s, mad)); })); })); }
public static ISingle <T> DelaySubscription <T>(this ISingle <T> source, TimeSpan delay, IScheduler scheduler) { return(Create <T>(s => { MultipleAssignmentDisposable inner = new MultipleAssignmentDisposable(); MultipleAssignmentDisposable mad = new MultipleAssignmentDisposable(inner); s.OnSubscribe(mad); inner.Set(scheduler.ScheduleDirect(() => { source.Subscribe(new SingleSubscriberWrapper <T>(s, mad)); }, delay)); })); }
public static ISingle <R> Zip <T1, T2, T3, T4, T5, T6, T7, T8, R>( ISingle <T1> s1, ISingle <T2> s2, ISingle <T3> s3, ISingle <T4> s4, ISingle <T5> s5, ISingle <T6> s6, ISingle <T7> s7, ISingle <T8> s8, Func <T1, T2, T3, T4, T5, T6, T7, T8, R> zipper) { return(Zip( new ISingle <object>[] { (ISingle <object>)s1, (ISingle <object>)s2, (ISingle <object>)s3, (ISingle <object>)s4, (ISingle <object>)s5, (ISingle <object>)s6, (ISingle <object>)s7, (ISingle <object>)s8 }, LambdaHelper.ToFuncN(zipper))); }
public static ISingle <R> Zip <T, R>(this IEnumerable <ISingle <T> > sources, Func <T[], R> zipper) { return(Create <R>(s => { int n = 0; ISingle <T>[] a = new ISingle <T> [8]; foreach (ISingle <T> source in sources) { if (n == a.Length) { ISingle <T>[] b = new ISingle <T> [n + (n >> 2)]; Array.Copy(a, 0, b, 0, n); a = b; } a[n++] = source; } if (n == 0) { EmptyDisposable.Error(s, NoSuchElementException()); return; } T[] array = new T[n]; int[] counter = { n }; SetCompositeDisposable all = new SetCompositeDisposable(); s.OnSubscribe(all); for (int i = 0; i < n; i++) { if (all.IsDisposed()) { return; } a[i].Subscribe(new ZipSingleSubscriber <T, R>(s, i, array, counter, all, zipper)); } })); }