private void Invoke(IRdWireable 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, IRdWireable reactive)
{
Assertion.Require(!reactive.RdId.IsNil, "!id.IsNil: {0}", reactive);
//todo commented because of WiredRdTask
// 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);
}
}
});
}
}
private bool ShouldProcess(IRdWireable reactive)
{
if (!reactive.IsBound)
{
return(false);
}
lock (myLock)
{
return(mySubscriptions.ContainsKey(reactive.RdId));
}
}
private static unsafe void Execute(IRdWireable 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);
}
}
private unsafe void Execute(IRdWireable 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);
if (BackwardsCompatibleWireFormat)
{
reactive.OnWireReceived(reader);
}
else
{
using (reactive.Proto.Contexts.ReadContextsIntoCookie(reader))
reactive.OnWireReceived(reader);
}
}
}
private void Invoke(IRdWireable reactive, byte[] msg, bool sync = false)
{
if (sync)
{
Execute(reactive, msg);
return;
}
reactive.WireScheduler.Queue(() =>
{
if (ShouldProcess(reactive))
{
Execute(reactive, msg);
}
else
{
myLogger.Trace("Handler for entity {0} dissapeared", reactive);
}
});
}
public void Advise(Lifetime lifetime, IRdWireable entity)
{
RealWire.Advise(lifetime, entity);
}
public void Advise(Lifetime lifetime, IRdWireable reactive)
{
MessageBroker.Advise(lifetime, reactive);
}
