// This call is made (once) from Excel to subscribe to the topic.
public IDisposable Subscribe(IExcelObserver observer)
{
// We know this will only be called once, so we take some adventurous shortcuts (like returning 'this')
Observer = observer;
Observer.OnNext(Handle);
return(this);
}
public IDisposable Subscribe(IExcelObserver observer)
{
lock (_observerLock)
{
if (_observer != null)
{
throw new InvalidOperationException("Only single Subscription allowed.");
}
_observer = observer;
if (_hasResult)
{
if (_exception != null)
{
_observer.OnError(_exception);
}
else
{
_observer.OnNext(_result);
_observer.OnCompleted();
}
}
}
return(DummyDisposable.Instance);
}
public IDisposable Subscribe(IExcelObserver observer)
{
if (_subscribed)
{
throw new InvalidOperationException("Only single Subscription allowed.");
}
_subscribed = true;
ThreadPool.QueueUserWorkItem(delegate
{
try
{
object result = _func();
observer.OnNext(result);
observer.OnCompleted();
}
catch (Exception ex)
{
// TODO: Log somehow?
observer.OnError(ex);
}
});
return(DummyDisposable.Instance);
}
IDisposable IExcelObservable.Subscribe(IExcelObserver observer)
{
Debug.Assert(_observer == null);
_observer = observer;
ReportState(); // Reporting immediately in the Subscribe means we never return #N/A from into the cell
return(this);
}
// This call is made (once) from Excel to subscribe to the topic.
public IDisposable Subscribe(IExcelObserver observer)
{
// We know this will only be called once, so we take some adventurous shortcuts (like returning 'this')
Observer = observer;
Observer.OnNext(Handle);
return this;
}
public void PreDispose()
{
this.__ExcelObserver = null;
this.ConfigMatter = null;
if (this.PMMLMatter != null)
{
this.PMMLMatter.Dispose();
}
this.PMMLMatter = null;
if (this.InputMatter != null)
{
this.InputMatter.Dispose();
}
this.InputMatter = null;
if (this.OutputMatter != null)
{
this.OutputMatter.Dispose();
}
this.OutputMatter = null;
//C#
GC.Collect();
//C#
GC.WaitForPendingFinalizers();
//C#
GC.Collect();
//C#
GC.WaitForPendingFinalizers();
}
public IDisposable Subscribe(IExcelObserver observer)
{
#if DEBUG
return(new DebuggingDisposable(_observable.Subscribe(value => observer.OnNext(value), observer.OnError, observer.OnCompleted)));
#else
return(_observable.Subscribe(value => observer.OnNext(value), observer.OnError, observer.OnCompleted));
#endif
}
public IDisposable Subscribe(IExcelObserver observer)
{
var timer = new System.Timers.Timer();
timer.Interval = 1000;
timer.Elapsed += (s, e) => observer.OnNext(DateTime.Now.ToString());
timer.Start();
return(new TickerDisposable(timer));
}
public IDisposable Subscribe(IExcelObserver observer)
{
_observer = observer;
_rtdClient.OnServiceStatusReceived += OnServiceStatusReceived;
_observer.OnNext(_rtdClient.GetServiceStatus().ToString());
return(new ActionDisposable(CleanUp));
}
public IDisposable Subscribe(IExcelObserver observer)
{
_observer = observer;
_rtdClient.OnConnectionStatusChanged += OnConnectionStatusChanged;
_observer.OnNext(_rtdClient.State.ToString());
return(new ActionDisposable(CleanUp));
}
public IDisposable Subscribe(IExcelObserver observer)
{
_observer = observer;
_monitor.AvailableEndpointsChanged += OnAvailableEndpointsChanged;
SendConnectionList();
return(new ActionDisposable(CleanUp));
}
public IDisposable Subscribe(IExcelObserver observer)
{
_socket.On(_feed, (data) =>
{
ValueSentEventArgs value = data.Json.GetFirstArgAs <ValueSentEventArgs>();
observer.OnNext(value.Calculation);
});
return(_observable.Subscribe(value => observer.OnNext(value), observer.OnError, observer.OnCompleted));
}
public IDisposable Subscribe(IExcelObserver observer)
{
_observer = observer;
_rtdClient.SubscribeToSystemValue(SystemProperty);
_rtdClient.OnSystemValueReceived += OnPortfolioDateReceived;
_observer.OnNext(ExcelEmpty.Value);
return(new ActionDisposable(CleanUp));
}
public IDisposable Subscribe(IExcelObserver observer)
{
_observer = observer;
_rtdClient.SubscribeToPositionValue(PositionId, Column);
_rtdClient.OnPositionValueReceived += OnDataReceived;
_observer.OnNext(ExcelEmpty.Value);
return(new ActionDisposable(CleanUp));
}
public IDisposable Subscribe(IExcelObserver observer)
{
lock (this)
{
m_observer = observer;
// Might be a problem if we want to support valid null values.
if (Value != null)
{
m_observer.OnNext(HandleName);
}
return(this);
}
}
public IDisposable Subscribe(IExcelObserver observer)
{
switch (_task.Status)
{
case TaskStatus.RanToCompletion:
observer.OnNext(_task.Result);
observer.OnCompleted();
break;
case TaskStatus.Faulted:
observer.OnError(_task.Exception.InnerException);
break;
case TaskStatus.Canceled:
observer.OnError(new TaskCanceledException(_task));
break;
default:
_task.ContinueWith(t =>
{
switch (t.Status)
{
case TaskStatus.RanToCompletion:
observer.OnNext(t.Result);
observer.OnCompleted();
break;
case TaskStatus.Faulted:
observer.OnError(t.Exception.InnerException);
break;
case TaskStatus.Canceled:
observer.OnError(new TaskCanceledException(t));
break;
}
});
break;
}
// Check for cancellation support
if (_cts != null)
{
return(new CancellationDisposable(_cts));
}
// No cancellation
return(DefaultDisposable.Instance);
}
public IDisposable Subscribe(IExcelObserver observer)
{
_observer = observer;
_rtdClient.OnConnectionStatusChanged += OnConnectionStatusChanged;
if (_rtdClient.Connection is object)
{
_observer.OnNext(ConnectionHelper.GetConnectionId(_rtdClient.Connection.Uri));
}
else
{
_observer.OnNext(Resources.NotConnectedMessage);
}
return(new ActionDisposable(CleanUp));
}
public IDisposable Subscribe(IExcelObserver observer)
{
switch (_task.Status)
{
case TaskStatus.RanToCompletion:
observer.OnNext(_task.Result);
observer.OnCompleted();
break;
case TaskStatus.Faulted:
observer.OnError(_task.Exception.InnerException);
break;
case TaskStatus.Canceled:
observer.OnError(new TaskCanceledException(_task));
break;
default:
var task = _task;
// OK - the Task has not completed synchronously
// And handle the Task completion
task.ContinueWith(t =>
{
switch (t.Status)
{
case TaskStatus.RanToCompletion:
observer.OnNext(t.Result);
observer.OnCompleted();
break;
case TaskStatus.Faulted:
observer.OnError(t.Exception.InnerException);
break;
case TaskStatus.Canceled:
observer.OnError(new TaskCanceledException(t));
break;
}
});
break;
}
return(DefaultDisposable.Instance);
}
public IDisposable Subscribe(IExcelObserver observer)
{
return(observable_.Subscribe(new ExcelObserverImpl(observer)));
}
public IDisposable Subscribe(IExcelObserver arg)
{
this.__ExcelObserver = arg;
this.__ExcelObserver.OnNext(this.HandleMajorMinor);
return(this);
}
public ExcelObserverImpl(IExcelObserver excelObserver)
{
excelObserver_ = excelObserver;
}
public IDisposable Subscribe(IExcelObserver observer)
{
// Start with a disposable that does nothing
// Possibly set to a CancellationDisposable later
IDisposable disp = DefaultDisposable.Instance;
switch (_task.Status)
{
case TaskStatus.RanToCompletion:
observer.OnNext(_task.Result);
observer.OnCompleted();
break;
case TaskStatus.Faulted:
observer.OnError(_task.Exception.InnerException);
break;
case TaskStatus.Canceled:
observer.OnError(new TaskCanceledException(_task));
break;
default:
var task = _task;
// OK - the Task has not completed synchronously
// First set up a continuation that will suppress Cancel after the Task completes
if (_cts != null)
{
var cancelDisp = new CancellationDisposable(_cts);
task = _task.ContinueWith(t =>
{
cancelDisp.SuppressCancel();
return(t);
}).Unwrap();
// Then this will be the IDisposable we return from Subscribe
disp = cancelDisp;
}
// And handle the Task completion
task.ContinueWith(t =>
{
switch (t.Status)
{
case TaskStatus.RanToCompletion:
observer.OnNext(t.Result);
observer.OnCompleted();
break;
case TaskStatus.Faulted:
observer.OnError(t.Exception.InnerException);
break;
case TaskStatus.Canceled:
observer.OnError(new TaskCanceledException(t));
break;
}
});
break;
}
return(disp);
}
public IDisposable Subscribe(IExcelObserver excelObserver)
{
var observer = new AnonymousObserver <T>(value => excelObserver.OnNext(value), excelObserver.OnError, excelObserver.OnCompleted);
return(_observable.Subscribe(observer));
}
public void removeExcelObserver(IExcelObserver e)
{
mExcelObservers.Remove(e);
}
public IDisposable Subscribe(IExcelObserver observer)
{
m_observer = observer;
m_observer.OnNext(m_name);
return(this);
}
public IDisposable Subscribe(IExcelObserver observer)
{
_observers.Add(observer);
observer.OnNext(DateTime.Now.ToString("HH:mm:ss.fff") + " (Subscribe)");
return(new ActionDisposable(() => _observers.Remove(observer)));
}
public IDisposable Subscribe(IExcelObserver excelObserver)
{
_observer = excelObserver;
OnSubscribe();
return(this);
}
protected virtual void OnDispose() => _observer = null;
public IDisposable Subscribe(IExcelObserver observer)
{
return(_observable.Subscribe(value => observer.OnNext(value), observer.OnError, observer.OnCompleted));
}
public IDisposable Subscribe(IExcelObserver observer)
{
lock (_observerLock)
{
if (_observer != null) throw new InvalidOperationException("Only single Subscription allowed.");
_observer = observer;
if (_hasResult)
{
if (_exception != null)
{
_observer.OnError(_exception);
}
else
{
_observer.OnNext(_result);
_observer.OnCompleted();
}
}
}
return DummyDisposable.Instance;
}
public IDisposable Subscribe(IExcelObserver observer)
{
if (_subscribed) throw new InvalidOperationException("Only single Subscription allowed.");
_subscribed = true;
ThreadPool.QueueUserWorkItem(delegate
{
try
{
object result = _func();
observer.OnNext(result);
observer.OnCompleted();
}
catch (Exception ex)
{
// TODO: Log somehow
observer.OnError(ex);
}
});
return new DummyDisposable();
}
public void registerExcelObserver(IExcelObserver e)
{
mExcelObservers.Add(e);
}
public IDisposable Subscribe(IExcelObserver observer)
{
switch (_task.Status)
{
case TaskStatus.RanToCompletion:
observer.OnNext(_task.Result);
observer.OnCompleted();
break;
case TaskStatus.Faulted:
observer.OnError(_task.Exception.InnerException);
break;
case TaskStatus.Canceled:
observer.OnError(new TaskCanceledException(_task));
break;
default:
var task = _task;
// OK - the Task has not completed synchronously
// And handle the Task completion
task.ContinueWith(t =>
{
switch (t.Status)
{
case TaskStatus.RanToCompletion:
observer.OnNext(t.Result);
observer.OnCompleted();
break;
case TaskStatus.Faulted:
observer.OnError(t.Exception.InnerException);
break;
case TaskStatus.Canceled:
observer.OnError(new TaskCanceledException(t));
break;
}
});
break;
}
return DefaultDisposable.Instance;
}
