void CreateCompleted(Task <IHasTimestamp> createTask)
{
lock (this)
{
try
{
Value = createTask.Result;
m_handleBase = Value.HandleBase;
// Check if this handleBase is already present in the indexMap, and use the next index from there (else the index becomes 1)
int lastIndex = 0;
s_indexMap.TryGetValue(m_handleBase, out lastIndex);
m_index = lastIndex + 1;
// Update the indexMap with the index we used
s_indexMap[m_handleBase] = m_index;
Value.Changed += hasTimestamp_Changed;
m_storage.Add(this);
if (m_observer != null)
{
m_observer.OnNext(HandleName);
}
}
catch (Exception exception)
{
if (m_observer != null)
{
m_observer.OnError(exception);
}
}
}
}
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)
{
_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));
}
private void OnConnectionStatusChanged(object sender, ConnectionStatusChangedEventArgs e)
{
if (_rtdClient.Connection is object)
{
_observer.OnNext(ConnectionHelper.GetConnectionId(_rtdClient.Connection.Uri));
}
else
{
_observer.OnNext(Resources.NotConnectedMessage);
}
}
private void UpdateConnectionName()
{
if (_rtdClient.Connection is object)
{
_observer.OnNext(ConnectionHelper.GetConnectionName(_rtdClient.Connection.Uri));
}
else
{
_observer.OnNext(Resources.NotConnectedMessage);
}
}
private void OnPortfolioValueSent(object sender, PortfolioValueReceivedEventArgs args)
{
if (args.PortfolioId == PortfolioId && args.Column == Column)
{
if (args.Value is null)
{
_observer.OnNext(ExcelEmpty.Value);
}
else
{
_observer.OnNext(args.Value);
}
}
}
private void OnPortfolioDateReceived(object sender, SystemValueReceivedEventArgs args)
{
if (args.Property == SystemProperty)
{
if (args.Value is null)
{
_observer.OnNext(ExcelEmpty.Value);
}
else
{
_observer.OnNext(args.Value);
}
}
}
private void OnDataReceived(object sender, PositionValueReceivedEventArgs args)
{
if (args.PositionId == PositionId && args.Column == Column)
{
if (args.Value is null)
{
_observer.OnNext(ExcelEmpty.Value);
}
else
{
_observer.OnNext(args.Value);
}
}
}
private void SendConnectionList()
{
if (_monitor.IsSearchingForEndPoints)
{
_observer.OnNext(Resources.SearchingForServersMessage);
}
else if (_monitor.AvailableEndpoints.Count == 0)
{
_observer.OnNext(Resources.NoEndPointsAvailableMessage);
}
else
{
string allConnections = string.Join(",", _monitor.AvailableEndpoints.Select(x => ConnectionHelper.GetConnectionId(x.Uri)));
_observer.OnNext(allConnections);
}
}
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);
}
// 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);
}
// 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)
{
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);
}
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)
{
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)
{
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)
{
_observer = observer;
_rtdClient.OnServiceStatusReceived += OnServiceStatusReceived;
_observer.OnNext(_rtdClient.GetServiceStatus().ToString());
return(new ActionDisposable(CleanUp));
}
// Called from the ObjectHandler
internal void Update(IHasRowVersion target)
{
Target = target;
Handle = string.Format("{0}:{1}", ObjectType, HandleIndex++);;
LastUpdate = DateTime.Now; // Might be used to decide when or how often to refresh
if (Observer != null)
{
Observer.OnNext(Handle); // Triggers the update sending the new handle to Excel
}
}
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;
_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)
{
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;
}
// OnNext is safe to call from any thread
// (I'm not sure if _observer could really be null in this example... but I put the guard in anyway)
void ReportState()
{
// Whatever we return here will be the result value in the cell
// I'm showing Caller as a quick diagnostic check
_observer?.OnNext($"Upload Item at {Caller} - Status: {Status}");
}
private void OnConnectionStatusChanged(object sender, ConnectionStatusChangedEventArgs e)
{
_observer.OnNext(_rtdClient.State.ToString());
}
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 observer)
{
m_observer = observer;
m_observer.OnNext(m_name);
return(this);
}
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 IDisposable Subscribe(IExcelObserver excelObserver)
{
var observer = new AnonymousObserver <T>(value => excelObserver.OnNext(value), excelObserver.OnError, excelObserver.OnCompleted);
return(_observable.Subscribe(observer));
}
public IDisposable Subscribe(IExcelObserver observer)
{
_observers.Add(observer);
observer.OnNext(DateTime.Now.ToString("HH:mm:ss.fff") + " (Subscribe)");
return(new ActionDisposable(() => _observers.Remove(observer)));
}
private void OnServiceStatusReceived(object sender, ServiceStatusReceivedEventArgs e)
{
_observer.OnNext(e.Status.ToString());
}
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(value => observer.OnNext(value), observer.OnError, observer.OnCompleted));
}
