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