public void Register([NotNull] ISignalReceiver receiver)
{
if (receiver == null)
{
throw new ArgumentNullException("receiver");
}
int key = receiver.Id;
if (!ReceiverLookup.ContainsKey(key))
{
ReceiverLookup[key] = new List <ISignalReceiver>();
}
List <ISignalReceiver> list = ReceiverLookup[key];
if (list.Contains(receiver))
{
return;
}
list.Add(receiver);
List <SignalPacket> packetList;
if (m_SignalsLastFrame.TryGetValue(key, out packetList))
{
foreach (SignalPacket packet in packetList)
{
receiver.Receive(packet.Sender, packet.Data);
packet.NoReceivers = false;
}
}
}
public static void Unregister([NotNull] ISignalReceiver receiver, SignalSpace direction = SignalSpace.Local)
{
if (receiver == null)
{
throw new ArgumentNullException("receiver");
}
Unregister(receiver.Component, receiver.Id, direction);
}
public static void Register([NotNull] ISignalReceiver receiver)
{
if (receiver == null)
{
throw new ArgumentNullException("receiver");
}
SignalHub hub = FindHub(receiver.Component);
if (!IsQuitting)
{
hub.Register(receiver);
}
}
/// <inheritdoc />
public void Register(ISignalReceiver listener)
{
RemovePendingRemovals();
_sources.Add(listener);
_node = _node.GetOrCreateChildNodeFor(listener.RegisteredTypeId);
if (_node.Registry.ListenerCount != _sources.Count)
{
Debug.Log("Something when wrong");
}
System.Diagnostics.Debug.Assert(_node.Registry.ListenerCount == _sources.Count);
}
public void RegisterReceiver(ISignalReceiver receiver)
{
if (receiver == null)
{
Log.Error("Tried to register a null reciever.", false);
return;
}
if (this.receivers.Contains(receiver))
{
Log.Error("Tried to register the same receiver twice: " + receiver.ToStringSafe <ISignalReceiver>(), false);
return;
}
this.receivers.Add(receiver);
}
public void RegisterReceiver(ISignalReceiver receiver)
{
if (receiver == null)
{
Log.Error("Tried to register a null reciever.");
}
else if (this.receivers.Contains(receiver))
{
Log.Error("Tried to register the same receiver twice: " + receiver.ToStringSafe());
}
else
{
this.receivers.Add(receiver);
}
}
/// <inheritdoc />
public void Deregister(ISignalReceiver listener)
{
_isPendingRemoval = true;
// null out all of the listeners
for (int i = 0; i < CachedListeners.Count; i++)
{
var existing = CachedListeners[i];
if (existing == listener)
{
CachedListeners[i] = null;
}
}
}
private void Unregister([NotNull] ISignalReceiver receiver)
{
if (receiver == null)
{
throw new ArgumentNullException("receiver");
}
int key = receiver.Id;
List <ISignalReceiver> list;
ReceiverLookup.TryGetValue(key, out list);
if ((list != null) && list.Contains(receiver))
{
list.Remove(receiver);
}
}
public void Start()
{
loggingService.Info("Start Signals service...");
this.OnSignalRulesChanged();
rulesService.RegisterRulesChangeCallback(this.OnSignalRulesChanged);
signalReceivers.Clear();
foreach (SignalDefinition definition in this.Config.Definitions)
{
ISignalReceiver receiver = Application.ResolveOptionalNamed <ISignalReceiver>(definition.Receiver,
new TypedParameter(typeof(string), definition.Name),
new TypedParameter(typeof(IConfigurationSection), definition.Configuration));
if (receiver != null)
{
if (signalReceivers.TryAdd(definition.Name, receiver))
{
receiver.Start();
}
else
{
throw new Exception($"Duplicate signal definition: {definition.Name}");
}
}
else
{
throw new Exception($"Signal receiver not found: {definition.Receiver}");
}
}
signalRulesTimedTask = tasksService.AddTask(
name: nameof(SignalRulesTimedTask),
task: new SignalRulesTimedTask(loggingService, healthCheckService, tradingService, rulesService, this),
interval: this.RulesConfig.CheckInterval * 1000 / Application.Speed,
startDelay: Constants.TaskDelays.LowDelay,
startTask: false,
runNow: false,
skipIteration: 0);
loggingService.Info("Signals service started");
}
public IEnumerable <ISignal> GetSignalsByName(string signalName)
{
IEnumerable <ISignal> signals = null;
foreach (var kvp in signalReceivers.OrderBy(r => r.Value.GetPeriod()))
{
if (signalName == null || signalName == kvp.Key)
{
ISignalReceiver receiver = kvp.Value;
if (signals == null)
{
signals = receiver.GetSignals();
}
else
{
signals = signals.Concat(receiver.GetSignals());
}
}
}
return(signals);
}
public double?GetGlobalRating()
{
try
{
double ratingSum = 0;
double ratingCount = 0;
foreach (var kvp in signalReceivers)
{
string signalName = kvp.Key;
if (Config.GlobalRatingSignals.Contains(signalName))
{
ISignalReceiver receiver = kvp.Value;
double? averageRating = receiver.GetAverageRating();
if (averageRating != null)
{
ratingSum += averageRating.Value;
ratingCount++;
}
}
}
if (ratingCount > 0)
{
return(Math.Round(ratingSum / ratingCount, 8));
}
else
{
return(null);
}
}
catch (Exception ex)
{
loggingService.Error("Unable to get global rating", ex);
return(null);
}
}
public void removeObserver(ISignalReceiver generic)
{
_genericReceivers.Remove(generic);
}
public void addObserver(ISignalReceiver generic)
{
_genericReceivers.Add(generic);
}
public void RemoveObserver(ISignalReceiver generic)
{
_eventHub.RemoveObserver(generic);
}
/// <summary>
/// Register the reciever to receive the Signal
/// </summary>
/// <param name="receiver">Instance of <see cref="ISignalReceiver"/>.</param>
public void RegisterSignalReceiver(ISignalReceiver receiver)
{
_Receivers.Add(receiver);
}
/// <summary>
/// UnRegister the reciever from receiving the Signal
/// </summary>
/// <param name="receiver">Instance of <see cref="ISignalReceiver"/>.</param>
public void UnregisterSignalReceiver(ISignalReceiver receiver)
{
_Receivers.Remove(receiver);
}
public static IObservable <TSignal> Receive <TSignal, TParameter>(this ISignalReceiver <TSignal> signalReceiver, TParameter parameter)
where TSignal : ISignal <TParameter>
{
return(signalReceiver.Receive().Where(signal => Equals(signal.Parameter, parameter)));
}
public static IObservable <TSignal> Receive <TSignal, TParameter>(this ISignalReceiver <TSignal> signalReceiver, TParameter parameter)
where TSignal : SignalHandler.ISignal <TParameter>
{
return(((SignalHandler.ISignalReceiver <TSignal>)signalReceiver).Receive(parameter));
}
public void AddObserver(ISignalReceiver generic)
{
_eventHub.AddObserver(generic);
}
public void DeregisterReceiver(ISignalReceiver receiver)
{
this.receivers.Remove(receiver);
}
void ISignalBroadcaster.Deregister(ISignalReceiver listener)
{
throw new NotImplementedException();
}
