public override void ReadProcessData(XmlElement xmlElement, ProcessDefinitionBuildContext creationContext)
{
base.ReadProcessData(xmlElement, creationContext);
// get the process definition for that name
String subProcessDefinitionName = xmlElement.GetProperty("process");
creationContext.Check(((Object)subProcessDefinitionName != null), "process is missing in the process state : " + subProcessDefinitionName);
DbSession dbSession = creationContext.DbSession;
dbSession.SaveOrUpdate(this._processDefinition);
try
{
this._subProcess = (ProcessDefinitionImpl)dbSession.FindOne(queryFindProcessDefinitionByName, subProcessDefinitionName, DbType.STRING);
}
catch (SystemException e)
{
creationContext.AddError("process '" + subProcessDefinitionName + "' was not deployed while it is referenced in a process-state. Exception: " + e.Message);
}
// parse the processInvokerDelegation
creationContext.DelegatingObject = this;
this._processInvokerDelegation = new DelegationImpl();
XmlElement invocationElement = xmlElement.GetChildElement("process-invocation");
creationContext.Check((invocationElement != null), "process-invocation is missing in the process-state : " + xmlElement);
this._processInvokerDelegation.ReadProcessData(invocationElement, creationContext);
creationContext.DelegatingObject = null;
// parse the actorExpression
this._actorExpression = xmlElement.GetProperty("actor-expression");
creationContext.Check(((Object)_actorExpression != null), "actor-expression is missing in the process-state : " + xmlElement);
}
public virtual void ReadProcessData(XmlElement xmlElement, ProcessDefinitionBuildContext creationContext)
{
DefinitionObjectImpl definitionObject = creationContext.DefinitionObject;
// first make sure the definitionObject has got an id
DbSession dbSession = creationContext.DbSession;
dbSession.SaveOrUpdate(definitionObject);
// store the reference link to the definitionObject
this._definitionObjectId = definitionObject.Id;
log.Debug("adding action : ");
log.Debug(" definitionObjectId: " + _definitionObjectId);
log.Debug(" definitionObject: " + definitionObject);
this._eventType = EventTypeHelper.fromText(xmlElement.GetAttribute("event"));
log.Debug("action on eventType '" + _eventType + "' and definitionObject " + creationContext.DefinitionObject);
// reading the action delegation
creationContext.DelegatingObject = this;
this._actionDelegation = new DelegationImpl();
this._actionDelegation.ReadProcessData(xmlElement, creationContext);
creationContext.DelegatingObject = null;
dbSession.SaveOrUpdate(this);
}
public void ProcessActivityState(ActivityStateImpl activityState, ExecutionContextImpl executionContext, DbSession dbSession)
{
// first set the flow-state to the activity-state
FlowImpl flow = (FlowImpl)executionContext.GetFlow();
log.Debug("processing activity-state '" + activityState + "' for flow '" + executionContext.GetFlow() + "'");
// execute the actions scheduled for this assignment
delegationService.RunActionsForEvent(EventType.BEFORE_ACTIVITYSTATE_ASSIGNMENT, activityState.Id, executionContext, dbSession);
String actorId = null;
String role = activityState.ActorRoleName;
DelegationImpl assignmentDelegation = activityState.AssignmentDelegation;
if (assignmentDelegation != null)
{
// delegate the assignment of the activity-state
actorId = delegationHelper.DelegateAssignment(activityState.AssignmentDelegation, executionContext);
if ((Object)actorId == null)
{
throw new SystemException("invalid process definition : assigner of activity-state '" + activityState.Name + "' returned null instead of a valid actorId");
}
log.Debug("setting actor of flow " + flow + " to " + actorId);
}
else
{
// get the assigned actor from the specified attribute instance
if ((Object)role != null)
{
IActor actor = (IActor)executionContext.GetAttribute(role);
if (actor == null)
{
throw new SystemException("invalid process definition : activity-state must be assigned to role '" + role + "' but that attribute instance is null");
}
actorId = actor.Id;
}
else
{
throw new SystemException("invalid process definition : activity-state '" + activityState.Name + "' does not have an assigner or a role");
}
}
flow.ActorId = actorId;
// If necessary, store the actor in the role
if ((string.IsNullOrEmpty(role) == false) && (assignmentDelegation != null))
{
executionContext.StoreRole(actorId, activityState);
}
// the client of performActivity wants to be Informed of the people in charge of the process
executionContext.AssignedFlows.Add(flow);
// log the assignment
executionContext.CreateLog(actorId, EventType.AFTER_ACTIVITYSTATE_ASSIGNMENT);
executionContext.AddLogDetail(new ObjectReferenceImpl(activityState));
// execute the actions scheduled for this assignment
delegationService.RunActionsForEvent(EventType.AFTER_ACTIVITYSTATE_ASSIGNMENT, activityState.Id, executionContext, dbSession);
}
public override void ReadProcessData(XmlElement xmlElement, ProcessDefinitionBuildContext creationContext)
{
base.ReadProcessData(xmlElement, creationContext);
creationContext.DelegatingObject = this;
this._decisionDelegation = new DelegationImpl();
this._decisionDelegation.ReadProcessData(xmlElement, creationContext);
creationContext.DelegatingObject = null;
}
private void action(XmlElement actionElement, ActionImpl actionImpl)
{
actionImpl.EventType = EventTypeHelper.fromText(actionElement.GetAttribute("event"));
DelegationImpl delegation = new DelegationImpl();
delegation.ProcessDefinition = ProcessDefinition;
actionImpl.ActionDelegation = delegation;
this.delegation <ActionImpl>(actionElement, delegation);
}
private void attribute(XmlElement attributeElement, AttributeImpl attribute, ProcessBlockImpl processBlock)
{
attribute.InitialValue = attributeElement.GetProperty("initial-value");
attribute.ProcessDefinition = processBlock as IProcessDefinition;
DelegationImpl delegation = new DelegationImpl();
attribute.SerializerDelegation = delegation;
delegation.ProcessDefinition = processBlock as IProcessDefinition;
this.definitionObject(attributeElement, attribute, processBlock);
this.delegation <AttributeImpl>(attributeElement, (DelegationImpl)attribute.SerializerDelegation);
}
public override void ReadProcessData(XmlElement xmlElement, ProcessDefinitionBuildContext creationContext)
{
base.ReadProcessData(xmlElement, creationContext);
this._scope = creationContext.ProcessBlock;
this._initialValue = xmlElement.GetProperty("initial-value");
creationContext.DelegatingObject = this;
this._serializerDelegation = new DelegationImpl();
this._serializerDelegation.ReadProcessData(xmlElement, creationContext);
creationContext.DelegatingObject = null;
creationContext.AddReferencableObject(_name, (ProcessBlockImpl)this._scope, typeof(IAttribute), this);
}
public void ProcessActivityState(ActivityStateImpl activityState, FlowImpl flow, DbSession dbSession)
{
String actorId = null;
String role = activityState.ActorRoleName;
DelegationImpl assignmentDelegation = activityState.AssignmentDelegation;
if (assignmentDelegation != null)
{
var delegateParameters = activityState.AssignmentDelegation.ParseConfiguration();
actorExpressionResolverService.CurrentScope = flow;
actorExpressionResolverService.DbSession = dbSession;
actorId = actorExpressionResolverService.ResolveArgument(delegateParameters["expression"].ToString()).Id;
if ((Object)actorId == null)
{
throw new SystemException("invalid process definition : assigner of activity-state '" + activityState.Name + "' returned null instead of a valid actorId");
}
}
else
{
if ((Object)role != null)
{
IActor actor = null;
var attr = attributeRepository.FindAttributeInstanceInScope(role, flow, dbSession);
if (attr != null)
{
actor = (IActor)attr.GetValue();
}
if (actor == null)
{
throw new SystemException("invalid process definition : activity-state must be assigned to role '" + role + "' but that attribute instance is null");
}
actorId = actor.Id;
}
else
{
throw new SystemException("invalid process definition : activity-state '" + activityState.Name + "' does not have an assigner or a role");
}
}
flow.ActorId = actorId;
// If necessary, store the actor in the role
if ((string.IsNullOrEmpty(role) == false) && (assignmentDelegation != null))
{
//executionContext.StoreRole(actorId, activityState);
}
// the client of performActivity wants to be Informed of the people in charge of the process
//executionContext.AssignedFlows.Add(flow);
}
public override void ReadProcessData(XmlElement xmlElement, ProcessDefinitionBuildContext creationContext)
{
base.ReadProcessData(xmlElement, creationContext);
if ((Object)xmlElement.GetAttribute("handler") != null)
{
creationContext.DelegatingObject = this;
this._forkDelegation = new DelegationImpl();
this._forkDelegation.ReadProcessData(xmlElement, creationContext);
creationContext.DelegatingObject = null;
}
}
public Object CreateObject(DelegationImpl delegationImpl)
{
Object delegateClass = null;
try
{
log.Debug("creating delegate '" + delegationImpl.ClassName + "'");
if (delegationImpl.ClassName.IndexOf(",") != -1)
{
int index = delegationImpl.ClassName.IndexOf(",");
string className = delegationImpl.ClassName.Substring(0, index).Trim();
string assemblyName = delegationImpl.ClassName.Substring(index + 1).Trim();
DbSession dbSession = null;
AssemblyFileImpl assemblyFile = null;
try
{
dbSession = OpenSession();
Object[] args = new Object[] { delegationImpl.ProcessDefinition.Id, assemblyName };
IType[] types = new IType[] { DbType.LONG, DbType.STRING };
assemblyFile = (AssemblyFileImpl)dbSession.FindOne(queryFindAssemblyFile, args, types);
}
catch (ObjectNotFoundException) {}
finally
{
if (dbSession != null)
{
dbSession.Close();
}
}
if (assemblyFile != null)
{
Assembly loaded = Assembly.Load(assemblyFile.Bytes);
Type dbDelegationType = loaded.GetType(className);
delegateClass = Activator.CreateInstance(dbDelegationType, false);
return(delegateClass);
}
}
//load Assembly from environment
log.Debug("load Assembly from environment");
Type delegationType = Type.GetType(delegationImpl.ClassName);
delegateClass = Activator.CreateInstance(delegationType, false);
return(delegateClass);
}
catch (Exception t)
{
log.Error("can't instantiate delegate '" + delegationImpl.ClassName + "' : ", t);
throw new SystemException("can't instantiate delegate '" + delegationImpl.ClassName + "' : " + t.Message);
}
}
public JobImpl(Job job, String reference)
{
_processDefinition = job.ProcessDefinition;
_context = job.Context;
_date = job.Date;
_userId = job.UserId;
_pwd = job.Pwd;
this._reference = reference;
_actionDelegation = new DelegationImpl();
_actionDelegation.ProcessDefinition = job.ProcessDefinition;
_actionDelegation.ClassName = job.TaskClassName;
_actionDelegation.Configuration = job.Configuration;
}
public override void ReadProcessData(XmlElement xmlElement, ProcessDefinitionBuildContext creationContext)
{
base.ReadProcessData(xmlElement, creationContext);
XmlElement assignmentElement = xmlElement.GetChildElement("assignment");
if (assignmentElement != null)
{
creationContext.DelegatingObject = this;
this._assignmentDelegation = new DelegationImpl();
this._assignmentDelegation.ReadProcessData(assignmentElement, creationContext);
creationContext.DelegatingObject = null;
}
this._actorRoleName = xmlElement.GetProperty("role");
}
private void delegation <T>(XmlElement delegationElement, DelegationImpl delegation)
{
Type delegatingObjectClass = typeof(T);
if (delegatingObjectClass == typeof(AttributeImpl))
{
String type = delegationElement.GetProperty("type");
if (string.IsNullOrEmpty(type) == false)
{
delegation.ClassName = ((String)DelegationImpl.attributeTypes[type]);
string suportedTypes = "supported types: ";
foreach (Object o in DelegationImpl.attributeTypes.Keys)
{
suportedTypes += o.ToString() + " ,";
}
}
else
{
delegation.ClassName = delegationElement.GetProperty("serializer");
}
}
else if (delegatingObjectClass == typeof(FieldImpl))
{
delegation.ClassName = delegationElement.GetProperty("class");
}
else
{
delegation.ClassName = delegationElement.GetProperty("handler");
}
// parse the exception handler
String exceptionHandlerText = delegationElement.GetAttribute("on-exception");
if ((Object)exceptionHandlerText != null)
{
delegation.ExceptionHandlingType = ExceptionHandlingTypeHelper.FromText(exceptionHandlerText);
}
// create the configuration string
XmlElement configurationXml = new XmlElement("cfg");
IEnumerator iter = delegationElement.GetChildElements("parameter").GetEnumerator();
while (iter.MoveNext())
{
configurationXml.AddChild((XmlElement)iter.Current);
}
delegation.Configuration = configurationXml.ToString();
}
public override void ReadProcessData(XmlElement xmlElement, ProcessDefinitionBuildContext creationContext)
{
this._endState = new EndStateImpl();
this._startState = new StartStateImpl();
// read the process-block contents, the start- and the end-state
creationContext.ProcessBlock = this;
base.ReadProcessData(xmlElement, creationContext);
XmlElement startElement = xmlElement.GetChildElement("start-state");
creationContext.Check((startElement != null), "element start-state is missing");
XmlElement endElement = xmlElement.GetChildElement("end-state");
creationContext.Check((endElement != null), "element end-state is missing");
_startState.ReadProcessData(startElement, creationContext);
_endState.ReadProcessData(endElement, creationContext);
creationContext.ProcessBlock = null;
// add the start & end state to the nodes of this process definition
this._nodes.Add(_startState);
this._nodes.Add(_endState);
// add the end state as referencable object
creationContext.AddReferencableObject(this._endState.Name, this, typeof(INode), this._endState);
// read the optional authorization handler
XmlElement authorizationElement = xmlElement.GetChildElement("authorization");
if (authorizationElement != null)
{
creationContext.DelegatingObject = this;
this.authorizationDelegation = new DelegationImpl();
this.authorizationDelegation.ReadProcessData(authorizationElement, creationContext);
creationContext.DelegatingObject = null;
}
// read the optional responsible for this process definition
this._responsibleUserName = xmlElement.GetProperty("responsible");
// calculate the version of this process definition
//todo 這行應該移到ProcessDefinitionService
//this._version = GetVersionNr(creationContext);
// attach the class files to this process definitions
//todo 這行應該移到ProcessDefinitionService
//this._classFiles = GetAssemblyFiles(creationContext);
}
private void activityState(XmlElement activityStateElement, ActivityStateImpl activityState, ProcessBlockImpl processBlock)
{
activityState.ProcessDefinition = ProcessDefinition;
XmlElement assignmentElement = activityStateElement.GetChildElement("assignment");
if (assignmentElement != null)
{
DelegationImpl delegation = new DelegationImpl();
delegation.ProcessDefinition = processBlock as IProcessDefinition;
activityState.AssignmentDelegation = delegation;
this.delegation <ActivityStateImpl>(assignmentElement, delegation);
}
activityState.ActorRoleName = activityStateElement.GetProperty("role");
this.state(activityStateElement, activityState, processBlock);
}
public Object CreateObject(DelegationImpl delegationImpl)
{
Object delegateClass = null;
try
{
log.Debug("creating delegate '" + delegationImpl.ClassName + "'");
Type delegationType = Type.GetType(delegationImpl.ClassName);
delegateClass = Activator.CreateInstance(delegationType, false);
}
catch (Exception t)
{
log.Error("can't instantiate delegate '" + delegationImpl.ClassName + "' : ", t);
throw new SystemException("can't instantiate delegate '" + delegationImpl.ClassName + "' : " + t.Message);
}
return(delegateClass);
}
public virtual void ReadWebData(XmlElement xmlElement, ProcessDefinitionBuildContext creationContext)
{
this._name = xmlElement.GetProperty("name");
this._description = xmlElement.GetProperty("description");
this._index = creationContext.Index;
log.Debug("paring web information for field " + _name);
creationContext.DelegatingObject = this;
XmlElement formatterElement = xmlElement.GetChildElement("htmlformatter");
if (formatterElement != null)
{
this._htmlFormatterDelegation = new DelegationImpl();
this._htmlFormatterDelegation.ReadProcessData(formatterElement, creationContext);
}
creationContext.DelegatingObject = null;
}
public void ProcessFork(ForkImpl fork, FlowImpl flow, DbSession dbSession)
{
// First initialize the children of the flow to be forked
flow.Children = new ListSet();
DelegationImpl delegation = fork.ForkDelegation;
IList <ForkedFlow> forkedFlows = new List <ForkedFlow>();
if (delegation != null)
{
//delegationHelper.DelegateFork(fork.ForkDelegation, executionContext);
}
else
{
// execute the default fork behaviour
IEnumerator iter = fork.LeavingTransitions.GetEnumerator();
while (iter.MoveNext())
{
TransitionImpl transition = (TransitionImpl)iter.Current;
forkedFlows.Add(this.ForkFlow(transition, flow, null));
}
}
IEnumerator iter2 = forkedFlows.GetEnumerator();
while (iter2.MoveNext())
{
ForkedFlow forkedFlow = (ForkedFlow)iter2.Current;
}
// loop over all flows that were forked in the ForkHandler implementation
iter2 = forkedFlows.GetEnumerator();
while (iter2.MoveNext())
{
ForkedFlow forkedFlow = (ForkedFlow)iter2.Current;
ProcessTransition(forkedFlow.Transition, forkedFlow.Flow, dbSession);
}
}
//public String DelegateAssignment(DelegationImpl delegation)
//{
// String actorId = null;
// IAssignmentHandler assigner = (IAssignmentHandler)delegation.GetDelegate();
// IDictionary expression = this.ParseConfiguration(delegation);
// actorExpressionResolverService = new ActorExpressionResolverService();
// actorId = actorExpressionResolverService.ResolveArgument(expression["expression"].ToString()).Id;
// return actorId;
//}
public Object GetDelegate(DelegationImpl delegationImpl)
{
Object delegateClass = null;
IClassLoader classLoader = null;
try
{
classLoader = (IClassLoader)ServiceLocator.Instance.GetService(typeof(IClassLoader));
delegateClass = classLoader.CreateObject(delegationImpl);
}
finally
{
ServiceLocator.Instance.Release(classLoader);
}
// configure class
if (delegateClass is IConfigurable)
{
IConfigurable configurable = (IConfigurable)delegateClass;
IDictionary parameters = ParseConfiguration(delegationImpl);
configurable.SetConfiguration(parameters);
}
return(delegateClass);
}
public IDictionary ParseConfiguration(DelegationImpl delegationImpl)
{
IDictionary parameters = new Hashtable();
try
{
String configuration = delegationImpl.Configuration;
if ((Object)configuration != null)
{
XmlParser xmlParser = new XmlParser(configuration);
xmlParser.Validation = false;
XmlElement configurationXmlElement = xmlParser.Parse();
IList parameterXmlElements = configurationXmlElement.GetChildElements("parameter");
IEnumerator iter = parameterXmlElements.GetEnumerator();
while (iter.MoveNext())
{
XmlElement parameterXmlElement = (XmlElement)iter.Current;
String name = parameterXmlElement.GetProperty("name");
if ((Object)name == null)
{
throw new SystemException("invalid delegation-configuration : " + configurationXmlElement);
}
parameters[name] = GetObject(parameterXmlElement);
}
}
}
catch (Exception t)
{
log.Error("can't parse configuration : ", t);
throw new SystemException("can't parse configuration : " + t.Message);
}
return(parameters);
}
public virtual DelegationImpl CreateAssignmentDelegation()
{
_assignmentDelegation = new DelegationImpl(_processDefinition);
return(_assignmentDelegation);
}
public long ExecuteTask(DbSession dbSession, IOrganisationService organisationComponent)
{
long millisToWait = DEFAULT_INTERVAL;
DateTime now = DateTime.Now;
IEnumerator iter = dbSession.Iterate(queryFindJobsToBeExecuted, now, DbType.TIMESTAMP).GetEnumerator();
if (iter.MoveNext())
{
JobImpl job = (JobImpl)iter.Current;
try
{
log.Debug("executing activation '" + job.Id + "' scheduled for " + job.Date.ToString());
log.Debug("activation's flow-context is :" + job.Context);
String userId = job.UserId;
DelegationImpl actionDelegation = job.ActionDelegation;
ExecutionContextImpl executionContext = new ExecutionContextImpl(userId, dbSession, organisationComponent);
IFlow context = job.Context;
if (context != null)
{
executionContext.SetFlow(context);
executionContext.SetProcessInstance(context.ProcessInstance);
executionContext.SetProcessDefinition(context.ProcessInstance.ProcessDefinition);
}
else
{
executionContext.SetProcessDefinition(job.ProcessDefinition);
}
delegationHelper.DelegateScheduledAction(actionDelegation, executionContext);
}
catch (Exception t)
{
log.Error("scheduler-exception : couldn't perform task : " + t.Message, t);
}
dbSession.Delete(job);
dbSession.Flush();
if (iter.MoveNext())
{
return(0);
}
}
iter = dbSession.Iterate(queryFindJobsInTheFuture, now, DbType.TIMESTAMP).GetEnumerator();
if (iter.MoveNext())
{
JobImpl activation = (JobImpl)iter.Current;
long activationDate = activation.Date.Ticks;
millisToWait = activationDate - now.Ticks;
log.Debug("next activation is scheduled at " + activation.Date.ToString() + ", (in " + millisToWait + " millis)");
if (millisToWait < 0)
{
millisToWait = 0;
}
if (millisToWait > DEFAULT_INTERVAL)
{
millisToWait = DEFAULT_INTERVAL;
}
}
return(millisToWait);
}
public void ProcessFork(ForkImpl fork, ExecutionContextImpl executionContext, DbSession dbSession)
{
log.Debug("forking flow " + executionContext.GetFlow());
// First initialize the children of the flow to be forked
FlowImpl flow = (FlowImpl)executionContext.GetFlow();
flow.Children = new ListSet();
// Then initialise the forked flows in the execution context
executionContext.ForkedFlows = new ArrayList();
DelegationImpl delegation = fork.ForkDelegation;
if (delegation != null)
{
delegationHelper.DelegateFork(fork.ForkDelegation, executionContext);
}
else
{
// execute the default fork behaviour
IEnumerator iter = fork.LeavingTransitions.GetEnumerator();
while (iter.MoveNext())
{
TransitionImpl transition = (TransitionImpl)iter.Current;
executionContext.ForkFlow(transition, null);
}
}
// create the fork event & remember the parent flow
FlowImpl parentFlow = (FlowImpl)executionContext.GetFlow();
executionContext.CreateLog(EventType.FORK);
// log the event
executionContext.SetFlow(parentFlow);
IList forkedFlows = executionContext.ForkedFlows;
IEnumerator iter2 = forkedFlows.GetEnumerator();
while (iter2.MoveNext())
{
ForkedFlow forkedFlow = (ForkedFlow)iter2.Current;
log.Debug("adding object reference [" + forkedFlow.Flow + "] to flow [" + parentFlow + "]");
executionContext.AddLogDetail(new ObjectReferenceImpl(forkedFlow.Flow));
}
// loop over all flows that were forked in the ForkHandler implementation
iter2 = forkedFlows.GetEnumerator();
while (iter2.MoveNext())
{
ForkedFlow forkedFlow = (ForkedFlow)iter2.Current;
// trigger actions, scheduled after the creation and setting of the attributeValues
// but before the fork is being processed
delegationService.RunActionsForEvent(EventType.FORK, fork.Id, executionContext, dbSession);
// then process the forked flow transition
executionContext.SetFlow(forkedFlow.Flow);
ProcessTransition(forkedFlow.Transition, executionContext, dbSession);
}
}
public void ProcessJoin(JoinImpl join, ExecutionContextImpl executionContext, DbSession dbSession)
{
// First set the state of the flow to finished
FlowImpl joiningFlow = (FlowImpl)executionContext.GetFlow();
joiningFlow.End = DateTime.Now;
joiningFlow.ActorId = null;
joiningFlow.Node = join; // setting the node is not necessary if this method is called
// from processTransition, but it is necessary if this method is
// called from cancelFlow in the component-impl.
// if parent-reactivation of the flow is true, this means that the parent-flow
// not yet has been reactivated. In that case we have to see if it needs to be
// reactivated. In the other case (parent-reactivation is false) we don't
// need to do anything because this means that the parent-flow was already
// reactivated before.
if (!false.Equals(joiningFlow.ParentReactivation))
{
// check if the parent needs to be reactivated
bool parentReactivation = false;
IList concurrentFlows = executionContext.GetOtherActiveConcurrentFlows();
if (concurrentFlows.Count == 0)
{
// if no concurrent flows are present any more, reactivation is forced
parentReactivation = true;
}
else
{
// if other concurrent flows are present, the decision to reactivate is left
// to the join-delegation (if there is one specified)
DelegationImpl joinDelegation = join.JoinDelegation;
// if no joinDelegation was specified, parentReactivation remains false
// so the behaviour is like an and-join. (=sunchronizing merge)
if (joinDelegation != null)
{
parentReactivation = delegationHelper.DelegateJoin(join.JoinDelegation, executionContext);
}
}
if (parentReactivation)
{
// make sure the other concurrent flows will not reactivate the
// parent again
IEnumerator iter = concurrentFlows.GetEnumerator();
while (iter.MoveNext())
{
//UPGRADE_TODO: Methode "java.util.Iterator.next" wurde in 'IEnumerator.Current' konvertiert und weist ein anderes Verhalten auf. 'ms-help://MS.VSCC.2003/commoner/redir/redirect.htm?keyword="jlca1073_javautilIteratornext"'
FlowImpl concurrentFlow = (FlowImpl)iter.Current;
concurrentFlow.ParentReactivation = false;
}
// reactivate the parent by first setting the parentflow into the executionContext
FlowImpl parentFlow = (FlowImpl)joiningFlow.Parent;
executionContext.SetFlow(parentFlow);
// and then process the (single, checked at process-archive-parsing-time) leaving transition.
ISet leavingTransitions = join.LeavingTransitions;
iter = leavingTransitions.GetEnumerator();
if (iter.MoveNext())
{
TransitionImpl leavingTransition = (TransitionImpl)iter.Current;
ProcessTransition(leavingTransition, executionContext, dbSession);
}
else
{
// no transition throw exception?
}
}
}
}
public virtual DelegationImpl CreateProcessInvocationDelegation()
{
_processInvokerDelegation = new DelegationImpl(_processDefinition);
return(_processInvokerDelegation);
}
public virtual DelegationImpl CreateJoinDelegation()
{
_joinDelegation = new DelegationImpl(_processDefinition);
return(_joinDelegation);
}
public virtual DelegationImpl CreateForkDelegation()
{
_forkDelegation = new DelegationImpl(_processDefinition);
return(_forkDelegation);
}
public virtual DelegationImpl CreateDecisionDelegation()
{
_decisionDelegation = new DelegationImpl(_processDefinition);
return(_decisionDelegation);
}
public virtual DelegationImpl CreateSerializerDelegation()
{
_serializerDelegation = new DelegationImpl(_processDefinition);
return(_serializerDelegation);
}
