public override void Consume(IPortElement item)
{
if (ShouldCommit())
{
base.TaskQueue.Enqueue(new Task(new Handler(Commit)));
}
}
protected override void Commit()
{
if (!ShouldCommit())
{
return;
}
ITask task = base.UserTask.PartialClone();
IPortElement[] array = new IPortElement[_ports.Length];
bool allTaken = true;
for (int i = 0; i < _ports.Length; i++)
{
Receiver receiver = _ports[i];
IPortElement portElement = ((IPortArbiterAccess)receiver._port).TestForElement();
if (portElement == null)
{
allTaken = false;
break;
}
array[i] = portElement;
task[(int)receiver.ArbiterContext] = portElement;
}
base.Arbitrate(task, array, allTaken);
}
internal bool Evaluate(int index, IPortElement item, ref ITask deferredTask)
{
if (base.State == ReceiverTaskState.CleanedUp)
{
return(false);
}
if (_userTask[index] != null)
{
throw new InvalidOperationException();
}
_userTask[index] = item;
int num = Interlocked.Decrement(ref _pendingItemCount);
if (num > 0)
{
return(true);
}
if (num == 0)
{
_userTask.LinkedIterator = base.LinkedIterator;
_userTask.TaskQueue = base.TaskQueue;
_userTask.ArbiterCleanupHandler = base.ArbiterCleanupHandler;
deferredTask = _userTask;
if (Arbiter != null)
{
if (!Arbiter.Evaluate(this, ref deferredTask))
{
return(false);
}
_userTask = null;
}
return(true);
}
return(false);
}
public override bool Evaluate(IPortElement messageNode, ref ITask deferredTask)
{
deferredTask = null;
if (ShouldCommit())
{
deferredTask = new Task(new Handler(Commit));
}
return(false);
}
public override void Cleanup(ITask taskToCleanup)
{
for (int i = 0; i < _ports.Length; i++)
{
IPortElement portElement = taskToCleanup[i];
if (portElement != null)
{
((IPort)_ports[i]).TryPostUnknownType(taskToCleanup[i].Item);
}
}
}
public override void Consume(IPortElement item)
{
if (_state == ReceiverTaskState.CleanedUp)
{
return;
}
ITask task = base.UserTask.PartialClone();
task[0] = item;
task.LinkedIterator = base.LinkedIterator;
task.ArbiterCleanupHandler = base.ArbiterCleanupHandler;
base.TaskQueue.Enqueue(task);
}
public IPortElement[] TestForMultipleElements(int count)
{
IPortElement[] result;
lock (Store)
{
if (Store.ElementCount < count)
{
result = null;
}
else
{
IPortElement[] array = new IPortElement[count];
for (int i = 0; i < count; i++)
{
array[i] = Store.ElementListRemoveFirst();
}
result = array;
}
}
return(result);
}
internal static void TransferCausalitiesFromTaskToCurrentThread(ITask currentTask)
{
if (!Dispatcher._causalitiesActive)
{
return;
}
CausalityThreadContext causalityThreadContext = null;
for (int i = 0; i < currentTask.PortElementCount; i++)
{
IPortElement portElement = currentTask[i];
if (portElement != null && portElement.CausalityContext != null)
{
CausalityThreadContext context = (CausalityThreadContext)portElement.CausalityContext;
if (causalityThreadContext == null)
{
causalityThreadContext = new CausalityThreadContext(null, null);
}
causalityThreadContext.MergeWith(context);
}
}
Dispatcher.SetCurrentThreadCausalities(causalityThreadContext);
}
public override bool Evaluate(IPortElement messageNode, ref ITask deferredTask)
{
if (_state == ReceiverTaskState.CleanedUp)
{
return(false);
}
if (base.UserTask != null)
{
if (_state == ReceiverTaskState.Persistent)
{
deferredTask = base.UserTask.PartialClone();
}
else
{
deferredTask = base.UserTask;
}
deferredTask[0] = messageNode;
}
else if (_keepItemInPort)
{
Cleanup();
deferredTask = new Task(delegate
{
});
}
if (_arbiter != null)
{
bool flag = _arbiter.Evaluate(this, ref deferredTask);
return(!_keepItemInPort && flag);
}
if (deferredTask != null)
{
deferredTask.LinkedIterator = base.LinkedIterator;
deferredTask.ArbiterCleanupHandler = base.ArbiterCleanupHandler;
}
return(!_keepItemInPort);
}
public override void Consume(IPortElement item)
{
throw new NotImplementedException();
}
public override bool Evaluate(IPortElement messageNode, ref ITask deferredTask)
{
throw new NotImplementedException();
}
public override void Consume(IPortElement item)
{
++consume;
}
public abstract void Consume(IPortElement item);
public override void Consume(IPortElement item)
{
throw new InvalidOperationException();
}
internal bool Process(IPortElement messageNode, int number, ref ITask deferredTask)
{
int rem = Interlocked.Decrement (ref remaining);
if (rem < 0)
return false;
lock (_lock) {
results [number].Add (messageNode.Item);
}
if (rem == 0) {
ITask task = new Task<ICollection[]> (results, handler);
task.LinkedIterator = LinkedIterator;
deferredTask = task;
var arb = Arbiter;
if (arb != null)
return arb.Evaluate (this, ref deferredTask);
Cleanup ();
}
return true;
}
public override bool Evaluate(IPortElement messageNode, ref ITask deferredTask)
{
throw new InvalidOperationException ();
}
public override void Consume(IPortElement item)
{
throw new InvalidOperationException ();
}
public override bool Evaluate(IPortElement messageNode, ref ITask deferredTask)
{
return(_parent.Evaluate((int)_arbiterContext, messageNode, ref deferredTask));
}
public override bool Evaluate(IPortElement messageNode, ref ITask deferredTask)
{
return(_parent.Evaluate(messageNode.Item, ref deferredTask));
}
public override bool Evaluate(IPortElement messageNode, ref ITask deferredTask)
{
++eval;
return eval_res;
}
public override bool Evaluate(IPortElement messageNode, ref ITask deferredTask)
{
port.UnregisterReceiver (this);
return true;
}
public override bool Evaluate(IPortElement messageNode, ref ITask deferredTask)
{
return receiver.Process (messageNode, number, ref deferredTask);
}
public abstract bool Evaluate(IPortElement messageNode, ref ITask deferredTask);
public override bool Evaluate(IPortElement messageNode, ref ITask deferredTask)
{
throw new InvalidOperationException();
}
public override void Consume(IPortElement item)
{
}
public abstract bool Evaluate(IPortElement messageNode, ref ITask deferredTask);
public void PostElement(IPortElement element)
{
PostInternal(true, (PortElement <T>)element);
}
public abstract void Consume(IPortElement item);
public override bool Evaluate(IPortElement messageNode, ref ITask deferredTask)
{
++tested;
if (task != null)
deferredTask = task;
return eval;
}
public override bool Evaluate(IPortElement messageNode, ref ITask deferredTask)
{
deferredTask = null;
return(false);
}
public override bool Evaluate(IPortElement messageNode, ref ITask deferredTask)
{
throw new NotImplementedException ();
}
public override void Consume(IPortElement item)
{
throw new NotImplementedException ();
}
internal bool Process(IPortElement messageNode, int number, ref ITask deferredTask)
{
userTask [number] = messageNode;
deferredTask = null;
if (Interlocked.Decrement (ref remaining) == 0)
deferredTask = userTask;
return true;
}
