private void Invoke(IRdReactive reactive, byte[] msg, bool sync = false)
{
if (sync)
{
Execute(reactive, msg);
return;
}
reactive.WireScheduler.Queue(() =>
{
bool shouldProcess;
lock (myLock)
{
shouldProcess = mySubscriptions.ContainsKey(reactive.RdId);
}
if (shouldProcess)
{
Execute(reactive, msg);
}
else
{
myLogger.Trace("Handler for entity {0} dissapeared", reactive);
}
});
}
public void Advise(Lifetime lifetime, IRdReactive reactive)
{
Assertion.Require(!reactive.RdId.IsNil, "!id.IsNil: {0}", reactive);
myScheduler.AssertThread(reactive);
// ReSharper disable once InconsistentlySynchronizedField
mySubscriptions.BlockingAddUnique(lifetime, myLock, reactive.RdId, reactive);
if (reactive.WireScheduler.OutOfOrderExecution)
{
lifetime.TryExecute(() =>
{
lock (myLock) {
if (myBroker.TryGetValue(reactive.RdId, out var mq))
{
myBroker.Remove(reactive.RdId);
foreach (var msg in mq.DefaultSchedulerMessages)
{
Invoke(reactive, msg);
}
mq.DefaultSchedulerMessages.Clear(); // clear it here because it is captured by default scheduler queueing
Assertion.Assert(mq.CustomSchedulerMessages.Count == 0, "Custom scheduler messages for an entity with outOfOrder scheduler {0}", reactive);
}
}
});
}
}
public WiredLifetime(LifetimeDefinition definition, RdId rdId, IRdReactive parent, IWire wire)
{
myDefinition = definition;
myParent = parent;
RdId = rdId;
WireScheduler = parent.WireScheduler; //maybe cancellation better to do synchronous
wire.Advise(definition.Lifetime, this);
}
private static unsafe void Execute(IRdReactive reactive, byte[] msg)
{
fixed(byte *p = msg)
{
var reader = UnsafeReader.CreateReader(p, msg.Length);
var rdid0 = RdId.Read(reader);
Assertion.Assert(reactive.RdId.Equals(rdid0), "Not equals: {0}, {1}", reactive.RdId, rdid0);
reactive.OnWireReceived(reader);
}
}
public void Advise(Lifetime lifetime, IRdReactive reactive)
{
MessageBroker.Advise(lifetime, reactive);
}
public void Advise(Lifetime lifetime, IRdReactive entity)
{
RealWire.Advise(lifetime, entity);
}
