protected void buildAffectationsObject(ref List <string> missing, ActivityNode node)
{
string pname = node.name;
// MascaretApplication.Instance.logfile.WriteLine("TRY TO AFFECT OBJECT : " + pname); MascaretApplication.Instance.logfile.Flush();
RessourceAssignement ra = organisation.findRessourceAssignement(pname);
if (ra != null && ra.Entity != null)
{
affectations.Add(pname, ra.Entity);
// MascaretApplication.Instance.logfile.WriteLine("SUCCESS TO AFFECT OBJECT : " + pname); MascaretApplication.Instance.logfile.Flush();
}
else
{
//Parameters::iterator it = _activityParams.find(pname);
if (activityParams.ContainsKey(pname))
{
affectations.Add(pname, ((InstanceValue)(activityParams[pname])).SpecValue);
}
else
{
// MascaretApplication.Instance.logfile.WriteLine("FAIL TO AFFECT OBJECT : " + pname); MascaretApplication.Instance.logfile.Flush();
missing.Add(pname);
}
}
}
protected void buildAffectationsAction(ref List <string> missing, ActivityNode node)
{
Action action = ((ActionNode)(node)).Action;
if (action != null)
{
if (action.Kind == "SendSignal")
{
SendSignalAction sendAct = (SendSignalAction)(action);
string pname = sendAct.Target.targetName;
if (pname != "")
{
RessourceAssignement ra = organisation.findRessourceAssignement(pname);
if (ra != null && ra.Entity != null)
{
affectations.Add(pname, ra.Entity);
sendAct.Target.target = ra.Entity;
}
else
{
missing.Add(pname);
}
}
}
else if (action.Kind == "CallOperation")
{
CallOperationAction callAct = (CallOperationAction)(action);
InstanceSpecification host = (InstanceSpecification)(agent);
Dictionary <string, Operation> opers = host.Classifier.Operations;
if (opers.ContainsKey(callAct.Operation.name))
{
callAct.Operation = opers[callAct.Operation.name];
}
}
else if (action.Kind == "CallBehavior")
{
/*
* shared_ptr<CallBehaviorAction> callBeh = shared_dynamic_cast<CallBehaviorAction>(action);
* map<string, shared_ptr<Operation> > opers = getHost()->getClassifier()->getOperations();
* map<string, shared_ptr<Operation> >::iterator it = opers.find(callBeh->getOperation()->getName());
* if (it != opers.end())
* {
* callBeh->setBehavior(it->second);
* }
*/
}
else
{
}
}
}
public void fire(ActivityNode activityNode)
{
//nothing to do
}
protected void buildAffectationsObject(ref List<string> missing, ActivityNode node)
{
string pname = node.name;
// MascaretApplication.Instance.logfile.WriteLine("TRY TO AFFECT OBJECT : " + pname); MascaretApplication.Instance.logfile.Flush();
RessourceAssignement ra = organisation.findRessourceAssignement(pname);
if (ra != null && ra.Entity != null)
{
affectations.Add(pname, ra.Entity);
// MascaretApplication.Instance.logfile.WriteLine("SUCCESS TO AFFECT OBJECT : " + pname); MascaretApplication.Instance.logfile.Flush();
}
else
{
//Parameters::iterator it = _activityParams.find(pname);
if (activityParams.ContainsKey(pname))
{
affectations.Add(pname, ((InstanceValue)(activityParams[pname])).SpecValue);
}
else
{
// MascaretApplication.Instance.logfile.WriteLine("FAIL TO AFFECT OBJECT : " + pname); MascaretApplication.Instance.logfile.Flush();
missing.Add(pname);
}
}
}
protected void buildAffectationsAction(ref List<string> missing, ActivityNode node)
{
Action action = ((ActionNode)(node)).Action;
if (action != null)
{
if (action.Kind == "SendSignal")
{
SendSignalAction sendAct = (SendSignalAction)(action);
string pname = sendAct.Target.targetName;
if (pname != "")
{
RessourceAssignement ra = organisation.findRessourceAssignement(pname);
if (ra != null && ra.Entity != null)
{
affectations.Add(pname, ra.Entity);
sendAct.Target.target = ra.Entity;
}
else
{
missing.Add(pname);
}
}
}
else if (action.Kind == "CallOperation")
{
CallOperationAction callAct = (CallOperationAction)(action);
InstanceSpecification host = (InstanceSpecification)(agent);
Dictionary<string, Operation> opers = host.Classifier.Operations;
if (opers.ContainsKey(callAct.Operation.name))
{
callAct.Operation = opers[callAct.Operation.name];
}
}
else if (action.Kind == "CallBehavior")
{
/*
shared_ptr<CallBehaviorAction> callBeh = shared_dynamic_cast<CallBehaviorAction>(action);
map<string, shared_ptr<Operation> > opers = getHost()->getClassifier()->getOperations();
map<string, shared_ptr<Operation> >::iterator it = opers.find(callBeh->getOperation()->getName());
if (it != opers.end())
{
callBeh->setBehavior(it->second);
}
*/
}
else
{
}
}
}
protected bool tryToAdvanceToken(ActivityExecutionToken token, ActionNode doneAction, bool gotTicketToUseAction)
{
//TODO : current implementation will fail if the loop node has branches which are not joined together at the end
//TODO : setup part of loop nodes not implemented
//TODO : careful if the loop node contains only an initial node :: ENDLESS LOOP
// Debug.Log(" current token : " + token.currentLocation.name);
if (token.currentLocation.Kind == "action")
{
ActionNode aNode = (ActionNode)(token.currentLocation);
if (actionIsCurrentlyRunning(aNode))
{
System.Console.WriteLine(" ACTION is RUNNING : " + aNode.Action.name);
//token busy...
return(false);
}
}
if (token.outgoingEdge == null)
{
//if (ACTIVATE_DEBUG_CONSOLE_OUTPUT_TOKENS) cerr << "dbg Part1: edge null" << endl;
//Debug.Log(" NO OUTGOING EDGES....");
//my work here is done *flies away*
return(false);
}
//evaluate guard(s). Normal behavior for fork, but I treat decision nodes here, if there are more paths going out, I will take the first one.
if (token.currentLocation.Kind == "fork")
{
//if (ACTIVATE_DEBUG_CONSOLE_OUTPUT_TOKENS) cerr << "dbg Part1: fork" << endl;
//normal behavior for fork (should not have guard, but hell... it doesn't hurt to check)
if (token.outgoingEdge.Guard != null && (!(token.outgoingEdge.Guard.eval(procedure.Activity.Context))))
{
return(false); //eval failed
}
}
else
{
//if (ACTIVATE_DEBUG_CONSOLE_OUTPUT_TOKENS) cerr << "dbg Part1: no fork" << endl;
List <ActivityEdge> outgoingNormal = token.currentLocation.getOutgoingControlFlowEdges();
bool foundWayOut = false;
for (int i = 0; i < outgoingNormal.Count; ++i)
{
//if <no guard> or <guard but evaluates ok>
if ((outgoingNormal[i].Guard == null) || (outgoingNormal[i].Guard != null && (outgoingNormal[i].Guard.eval(procedure.Activity.Context))))
{
foundWayOut = true;
token.outgoingEdge = outgoingNormal[i]; //set new direction, we take the first possible one, remember ?
}
}
if (!foundWayOut)
{
//if (ACTIVATE_DEBUG_CONSOLE_OUTPUT_TOKENS) cerr << "dbg Part1: didn't find way out" << endl;
return(false); //no way out... leave for later
}
}
ActivityNode nextLocation = token.outgoingEdge.Target;
//test allowed action
if (nextLocation.Kind == "action")
{
if ((nextLocation != doneAction) || (!gotTicketToUseAction))
{
//not allowed to advance to this action
//if (ACTIVATE_DEBUG_CONSOLE_OUTPUT_TOKENS) cerr << "dbg Part1: action not allowed" << endl;
return(false);
}
gotTicketToUseAction = false;
}
//Debug.Log("Next Location : " + nextLocation);
//if (ACTIVATE_DEBUG_CONSOLE_OUTPUT_TOKENS) cerr << "adv tok from '" << token->currentLocation->getName() << "' to '" << nextLocation->getName() << "'" << endl;
//Advance
ActivityEdge dummyActivityEdge = null;
token.currentLocation = nextLocation;
token.outgoingEdge = dummyActivityEdge;
List <ActivityEdge> outgoingAfterAdvance = token.currentLocation.getOutgoingControlFlowEdges();
List <ActivityExecutionToken> nextTokens = new List <ActivityExecutionToken>();
if (token.currentLocation.Kind == "fork")
{
//time to split token into pieces, in order to follow all fork branches
token.forkStack.Add(token.currentLocation); //push this fork to the stack
//remove this token from the active list
for (int i = 0; i < activeTokens.Count; ++i)
{
if (activeTokens[i].ToString() == token.ToString())
{
activeTokens.RemoveAt(i);
break;
}
}
for (int i = 0; i < outgoingAfterAdvance.Count; ++i)
{
ActivityExecutionToken tok = new ActivityExecutionToken();
tok.currentLocation = token.currentLocation;
tok.forkStack = token.forkStack;
tok.loopNodeStack = token.loopNodeStack;
tok.outgoingEdge = outgoingAfterAdvance[i]; //set outgoing, to know which branch to follow
//push to active list
activeTokens.Add(tok);
//save for further use
nextTokens.Add(tok);
}
}
else if (token.currentLocation.Kind == "join")
{
//we can only pass by a join, if all other branched tokens have arrived in this join
//the point is that the number of tokens which have the same last fork as this one, should be the same as the nr of incoming links to this join
//i hope i understand this next time i read it
List <ActivityEdge> incoming = token.currentLocation.Incoming; //so get the incoming
//see which is the last fork of this token
ActivityNode lastFork = null;
if (token.forkStack.Count > 0)
{
lastFork = token.forkStack[token.forkStack.Count - 1];
}
if (lastFork != null)
{
//find all tokens that have this fork and see if they all finished their branch // TODO: remember that actually, the forkStacks should be identical for paired tokens... if they're not, we've got a problem....
List <ActivityExecutionToken> finishedTokens = new List <ActivityExecutionToken>();
for (int i = 0; i < activeTokens.Count; ++i)
{
//if found a token with this last fork
if ((activeTokens[i].forkStack.Count > 0) && (activeTokens[i].forkStack[activeTokens[i].forkStack.Count - 1] == lastFork))
{
//check to see if it's finished (arrived at the same join)
if (activeTokens[i].currentLocation == token.currentLocation)
{
//add to finished tokens list
finishedTokens.Add(activeTokens[i]);
}
}
}
//now check to see if the number of found tokens equals the number of incoming links to this join
if (finishedTokens.Count == incoming.Count)
{
//then all should be great.... we can merge all tokens into a single one
for (int i = 0; i < finishedTokens.Count; ++i)
{
//skip the current token, this one will remain
if (finishedTokens[i].ToString() == token.ToString())
{
continue;
}
//seek and destroy
for (int j = 0; j < activeTokens.Count; ++j)
{
if (finishedTokens[i].ToString() == activeTokens[j].ToString())
{
//destroy
activeTokens.RemoveAt(j);
}
}
}
if (outgoingAfterAdvance.Count == 1)
{
token.outgoingEdge = outgoingAfterAdvance[0];
token.forkStack.RemoveAt(token.forkStack.Count - 1);//pop last fork
nextTokens.Add(token);
}
else if (outgoingAfterAdvance.Count > 1)
{
}
}
}
else
{
}
}
else if (token.currentLocation.Kind == "loop")
{
LoopNode loopNode = (LoopNode)(token.currentLocation);
bool skipThisLoopNode = false;
if (loopNode.TestedFirst)
{
if (loopNode.eval()) //thou shall pass
{
skipThisLoopNode = true;
}
}
ActivityNode initLoop = loopNode.Initial;
List <ActivityEdge> outgoingFromInitLoop = null;
if (initLoop != null)
{
outgoingFromInitLoop = initLoop.getOutgoingControlFlowEdges();
}
if (skipThisLoopNode || (initLoop == null) || (outgoingFromInitLoop.Count < 1))
{
//I don't care which path to take, so I will just take the first one. In the advance part (see above) if it's a decision node, it will take the first possible path, if any
if (outgoingAfterAdvance.Count >= 1)
{
token.outgoingEdge = outgoingAfterAdvance[0];
nextTokens.Add(token);
}
}
else
{
//enter the loop node, we'll get the edge which exits the loopnode's initial node
token.currentLocation = initLoop;
token.outgoingEdge = outgoingFromInitLoop[0];
token.loopNodeStack.Add(loopNode);
}
}
else
{
//I don't care which path to take, so I will just take the first one. In the advance part (see above) if it's a decision node, it will take the first possible path, if any
if (outgoingAfterAdvance.Count >= 1)
{
token.outgoingEdge = outgoingAfterAdvance[0];
nextTokens.Add(token);
}
else if (token.loopNodeStack.Count != 0) //check if we're in a loop node
{
//if (ACTIVATE_DEBUG_CONSOLE_OUTPUT_TOKENS) cerr << "dbg Part1: edge null, but in loop node" << endl;
while (((token.outgoingEdge == null)) && (token.loopNodeStack.Count != 0)) //while we are still in a loopnode and it is finished
{
LoopNode lastLoop = token.loopNodeStack[token.loopNodeStack.Count - 1];
if (lastLoop.eval()) //test exit condition
{
//exiting loop node
List <ActivityEdge> outgoingFromLoop = lastLoop.getOutgoingControlFlowEdges();
if (outgoingFromLoop.Count != 0)
{
token.currentLocation = lastLoop;
token.outgoingEdge = outgoingFromLoop[0];
}
token.loopNodeStack.RemoveAt(token.loopNodeStack.Count - 1); //remove last loop from stack (exit)
}
else
{
//restarting loop node
ActivityNode initLoop = lastLoop.Initial;
List <ActivityEdge> outgoingFromInitLoop = initLoop.getOutgoingControlFlowEdges();
token.currentLocation = initLoop;
token.outgoingEdge = outgoingFromInitLoop[0]; //it should exist, given the fact that we've entered this loop node already
}
}
if (token.outgoingEdge != null)
{
nextTokens.Add(token);
}
}
}
//continue to advance
for (int i = 0; i < nextTokens.Count; ++i)
{
tryToAdvanceToken(nextTokens[i], doneAction, gotTicketToUseAction);
}
return(true);
}
public void buildAffectations(Dictionary <String, ValueSpecification> parameters, InstanceSpecification host)
{
List <string> missing = new List <string>();
/* Affectation de self */
affectations.Add("self", host);
// MascaretApplication.Instance.logfile.WriteLine("Build Affectations"); MascaretApplication.Instance.logfile.Flush();
/* Affectation des parametres */
activityParams.Clear();
List <ActivityNode> nodes = procedure.Activity.Nodes;
for (int iNode = 0; iNode < nodes.Count; iNode++)
{
ActivityNode node = nodes[iNode];
if (node.Kind == "parameter")
{
Parameter p = ((ActivityParameterNode)(node)).Parameter;
string strVal = parameters[p.name].getStringFromValue();
activityParams.Add(p.name, p.Type.createValueFromString(strVal));
}
}
/* Affectation des ressources */
List <ActivityPartition> partitions = procedure.Activity.Partitions;
for (int i = 0; i < partitions.Count; i++)
{
if (partitions[i].name == "this")
{
affectations.Add("this", host);
}
else
{
string pname = partitions[i].name;
}
nodes = partitions[i].Node;
for (int iNode = 0; iNode < nodes.Count; iNode++)
{
ActivityNode node = nodes[iNode];
if (node.Kind == "object")
{
buildAffectationsObject(ref missing, node);
}
else
{
if (node.Kind == "action")
{
buildAffectationsAction(ref missing, node);
}
}
}
}
if (missing.Count > 0)
{
buildAffectationsPostbone(missing);
}
procedure.Activity.context = _buildOclContext(activityParams);
List <ActivityNode> actnodes = procedure.Activity.Nodes;
foreach (ActivityNode actnode in actnodes)
{
if (actnode.Kind == "action")
{
((ActionNode)actnode).Action.context = procedure.Activity.context;
}
}
}
public void addNode(ActivityNode val)
{
val.Activity = this;
nodes.Add(val);
}
public void fire(ActivityNode activityNode)
{
//nothing to do
}
public void addNode(ActivityNode val)
{
val.Activity = this;
nodes.Add(val);
}