public void Subscribe(ISingleSubscriber <T> s)
{
SingleDisposable sd = new SingleDisposable(this, s);
s.OnSubscribe(sd);
if (Add(sd))
{
if (sd.IsDisposed())
{
Remove(sd);
}
if (Volatile.Read(ref once) == 0)
{
if (Interlocked.CompareExchange(ref once, 1, 0) == 0)
{
source.Subscribe(this);
}
}
}
else
{
ValueOrError r = Volatile.Read(ref result);
if (r.IsError())
{
s.OnError(r.error);
}
else
{
s.OnSuccess(r.value);
}
}
}
public DelaySingeSubscriber(ISingleSubscriber <T> actual, TimeSpan delay, IScheduler scheduler, bool delayError)
{
this.actual = actual;
this.delay = delay;
this.scheduler = scheduler;
this.delayError = delayError;
}
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 EqualsSingleSubscriber(ISingleSubscriber <bool> actual,
int index, T[] array, int[] counter, ICompositeDisposable all)
{
this.actual = actual;
this.index = index;
this.array = array;
this.counter = counter;
this.all = all;
}
public void Subscribe(ISingleSubscriber <T> s)
{
try
{
action(s);
}
catch (Exception ex)
{
RxAdvancedFlowPlugins.OnError(ex);
}
}
public ZipSingleSubscriber(ISingleSubscriber <R> actual,
int index, T[] array, int[] counter, ICompositeDisposable all,
Func <T[], R> zipper)
{
this.actual = actual;
this.index = index;
this.array = array;
this.counter = counter;
this.all = all;
this.zipper = zipper;
}
public LifecycleSingleSubscriber(ISingleSubscriber <T> actual,
Action <IDisposable> onSubscribeCall,
Action <T> onSuccessCall,
Action <Exception> onErrorCall,
Action onAfterTerminateCall
)
{
this.actual = actual;
this.onSubscribeCall = onSubscribeCall;
this.onSuccessCall = onSuccessCall;
this.onErrorCall = onErrorCall;
this.onAfterTerminateCall = onAfterTerminateCall;
}
public void Subscribe(ISingleSubscriber <R> s)
{
ISingleSubscriber <T> sr;
try
{
sr = onLift(s);
}
catch (Exception ex)
{
EmptyDisposable.Error(s, ex);
return;
}
source.Subscribe(sr);
}
public MapSingleSubscriber(ISingleSubscriber <R> actual, Func <T, R> mapper)
{
this.actual = actual;
this.mapper = mapper;
}
public RetryIfSingleSubscriber(ISingle <T> source, ISingleSubscriber <T> actual, Func <Exception, bool> retryIf)
{
this.source = source;
this.actual = actual;
this.retryIf = retryIf;
}
public void Subscribe(ISingleSubscriber <T> s)
{
throw new NotImplementedException();
}
public UnsubscribeOnSingleSubscriber(ISingleSubscriber <T> actual, IScheduler scheduler)
{
this.actual = actual;
this.scheduler = scheduler;
}
public ResumeNextSingleSubscriber(ISingleSubscriber <T> actual, Func <Exception, ISingle <T> > resumeWith)
{
this.actual = actual;
this.resumeWith = resumeWith;
}
public AmbSingleSubscriber(ISingleSubscriber <T> actual)
{
this.actual = actual;
all = new SetCompositeDisposable();
}
public ToSingleCompletableSubscriber(ISingleSubscriber <T> actual, Func <T> valueSupplier)
{
this.actual = actual;
this.valueSupplier = valueSupplier;
}
public void Subscribe(ISingleSubscriber <T> s)
{
source.Subscribe(new SinglePublisherSubscriber(s));
}
public DelaySubscriptionByPublisherSingleSubscriber(ISingle <T> source, ISingleSubscriber <T> actual)
{
this.source = source;
this.actual = actual;
}
public RetryFiniteSingleSubscriber(ISingle <T> source, ISingleSubscriber <T> actual, long times)
{
this.source = source;
this.actual = actual;
this.remaining = times;
}
public OnErrorReturnSingleSubscriber(ISingleSubscriber <T> actual, Func <T> valueSupplier)
{
this.actual = actual;
this.valueSupplier = valueSupplier;
}
public DelaySubscriptionByObservableSingleSubscriber(ISingle <T> source, ISingleSubscriber <T> actual)
{
this.source = source;
this.actual = actual;
}
public SingleDisposable(SingleCache <T> parent, ISingleSubscriber <T> actual)
{
this.parent = parent;
this.actual = actual;
}
public void Subscribe(ISingleSubscriber <T> s)
{
first.Subscribe(new FirstSubscriber(s, second));
}
public FirstSubscriber(ISingleSubscriber <T> actual, ISingle <T> second)
{
this.actual = actual;
this.second = second;
}
public void Subscribe(ISingleSubscriber <T> s)
{
s.OnSubscribe(EmptyDisposable.Instance);
s.OnSuccess(value);
}
public SingleSubscriberWrapper(ISingleSubscriber <T> actual, ISoloDisposable disposable)
{
this.actual = actual;
this.disposable = disposable;
}
internal SinglePublisherSubscriber(ISingleSubscriber <T> actual)
{
this.actual = actual;
}
public static void Error <T>(ISingleSubscriber <T> cs, Exception e)
{
cs.OnSubscribe(Instance);
cs.OnError(e);
}
public UsingSingleSubscriber(ISingleSubscriber <T> actual, Action onTerminated, bool eager)
{
this.actual = actual;
this.onTerminated = onTerminated;
this.eager = eager;
}
public RetryInfiniteSingleSubscriber(ISingle <T> source, ISingleSubscriber <T> actual)
{
this.source = source;
this.actual = actual;
}
