protected internal override void LogVariableOperation(AbstractVariableScope scope)
{
ExecutionEntity execution = (ExecutionEntity)scope;
CommandContext.OperationLogManager.LogVariableOperation(LogEntryOperation, execution.Id, null,
PropertyChange.EmptyChange);
}
public void OnUpdate(ICoreVariableInstance variableInstance, AbstractVariableScope sourceScope)
{
if (HistoryLevel.IsHistoryEventProduced(HistoryEventTypes.VariableInstanceUpdate, variableInstance))
{
HistoryEventProcessor.ProcessHistoryEvents(new HistoryEventCreatorAnonymousInnerClassHelper3(this, variableInstance, sourceScope));
}
}
public virtual void executeInputParameters(AbstractVariableScope variableScope)
{
foreach (InputParameter inputParameter in InputParameters)
{
inputParameter.execute(variableScope);
}
}
public virtual void executeOutputParameters(AbstractVariableScope variableScope)
{
foreach (OutputParameter outputParameter in OutputParameters)
{
outputParameter.execute(variableScope);
}
}
protected internal override void LogVariableOperation(AbstractVariableScope scope)
{
var task = (TaskEntity)scope;
CommandContext.OperationLogManager.LogVariableOperation(LogEntryOperation, null, task.Id,
PropertyChange.EmptyChange);
}
public void OnCreate(ICoreVariableInstance variable, AbstractVariableScope sourceScope)
{
if (!variable.GetIsTransient())
{
var variableEntity = (VariableInstanceEntity)variable;
VariableInstanceEntity.Insert(variableEntity);
}
}
public virtual void ExecuteOutputParameters(AbstractVariableScope variableScope)
{
if (OutputParameters != null)
{
foreach (var outputParameter in OutputParameters)
{
outputParameter.Execute(variableScope);
}
}
}
public virtual void ExecuteInputParameters(AbstractVariableScope variableScope)
{
if (InputParameters != null)
{
foreach (var inputParameter in InputParameters)
{
inputParameter.Execute(variableScope);
}
}
}
protected internal override void Execute(AbstractVariableScope innerScope, AbstractVariableScope outerScope)
{
// get value from inner scope
var value = valueProvider.GetValue(innerScope);
Log.DebugMappingValuefromInnerScopeToOuterScope(value, innerScope, name, outerScope);
// set variable in outer scope
outerScope.SetVariable(name, value);
}
protected internal override void ExecuteOperation(AbstractVariableScope scope)
{
if (IsLocal)
{
scope.RemoveVariablesLocal(VariableNames);
}
else
{
scope.RemoveVariables(VariableNames);
}
}
//JAVA TO C# CONVERTER WARNING: MethodInfo 'throws' clauses are not available in .NET:
//ORIGINAL LINE: public static void evaluateDecision(org.camunda.bpm.engine.impl.core.Variable.scope.AbstractVariableScope execution, org.camunda.bpm.engine.impl.core.model.BaseCallableElement callableElement, String resultVariable, org.camunda.bpm.engine.impl.dmn.result.DecisionResultMapper decisionResultMapper) throws Exception
public static void EvaluateDecision(AbstractVariableScope execution, BaseCallableElement callableElement,
string resultVariable, IDecisionResultMapper decisionResultMapper)
{
var decisionDefinition = ResolveDecisionDefinition(callableElement, execution);
var invocation = CreateInvocation(decisionDefinition, execution);
Invoke(invocation);
var result = (IDmnDecisionResult)invocation.InvocationResult;
if (result != null)
{
execution.SetVariableLocalTransient(DecisionResultVariable, result);
if (!ReferenceEquals(resultVariable, null) && (decisionResultMapper != null))
{
var mappedDecisionResult = decisionResultMapper.MapDecisionResult(result);
execution.SetVariable(resultVariable, mappedDecisionResult);
}
}
}
public virtual ELContext getElContext(VariableScope variableScope)
{
ELContext elContext = null;
if (variableScope is AbstractVariableScope)
{
AbstractVariableScope variableScopeImpl = (AbstractVariableScope)variableScope;
elContext = variableScopeImpl.CachedElContext;
}
if (elContext == null)
{
elContext = createElContext(variableScope);
if (variableScope is AbstractVariableScope)
{
((AbstractVariableScope)variableScope).CachedElContext = elContext;
}
}
return(elContext);
}
public virtual Void execute(CommandContext commandContext)
{
this.commandContext = commandContext;
AbstractVariableScope scope = Entity;
executeOperation(scope);
ExecutionEntity contextExecution = ContextExecution;
if (contextExecution != null)
{
contextExecution.dispatchDelayedEventsAndPerformOperation((Callback <PvmExecutionImpl, Void>)null);
}
if (!preventLogUserOperation)
{
logVariableOperation(scope);
}
return(null);
};
protected internal static DecisionInvocation CreateInvocation(IDecisionDefinition decisionDefinition,
AbstractVariableScope variableScope)
{
return(CreateInvocation(decisionDefinition, VariableScopeContext.Wrap(variableScope)));
}
public virtual void DebugMappingValuefromInnerScopeToOuterScope(object value, AbstractVariableScope innerScope,
string name, AbstractVariableScope outerScope)
{
LogDebug("002", "Mapping value '{0}' from inner scope '{1}' to variable '{2}' in outer scope '{3}'.", value,
innerScope, name, outerScope);
}
public ConnectorVariableScope(AbstractVariableScope parent)
{
this.parent = parent;
this.variableStore = new VariableStore <SimpleVariableInstance>();
}
protected internal abstract void ExecuteOperation(AbstractVariableScope scope);
protected internal static IDecisionDefinition ResolveDecisionDefinition(BaseCallableElement callableElement,
AbstractVariableScope execution)
{
//throw new NotImplementedException();
return(CallableElementUtil.GetDecisionDefinitionToCall(execution, callableElement));
}
public void OnDelete(ICoreVariableInstance variable, AbstractVariableScope sourceScope)
{
variable.Delete();
}
protected internal override void logVariableOperation(AbstractVariableScope scope)
{
TaskEntity task = (TaskEntity)scope;
commandContext.OperationLogManager.logVariableOperation(LogEntryOperation, null, task.Id, PropertyChange.EMPTY_CHANGE);
}
/// <param name="innerScope"> </param> /// <param name="outerScope"> </param> protected internal abstract void Execute(AbstractVariableScope innerScope, AbstractVariableScope outerScope);
/// <summary>
/// Execute the parameter in a given variable scope.
/// </summary>
public virtual void Execute(AbstractVariableScope scope)
{
Execute(scope, scope.ParentVariableScope);
}
public void OnCreate(ICoreVariableInstance variableInstance, AbstractVariableScope sourceScope)
{
}
public HistoryEventCreatorAnonymousInnerClassHelper3(VariableInstanceHistoryListener outerInstance, ICoreVariableInstance variableInstance, AbstractVariableScope sourceScope)
{
this._outerInstance = outerInstance;
this._variableInstance = (VariableInstanceEntity)variableInstance;
this._sourceScope = sourceScope;
}
public void OnUpdate(ICoreVariableInstance variableInstance, AbstractVariableScope sourceScope)
{
variableInstance.IncrementSequenceCounter();
}
public VariableEvent(ICoreVariableInstance variableInstance, string eventName, AbstractVariableScope sourceScope)
{
this.variableInstance = variableInstance;
this.eventName = eventName;
this.sourceScope = sourceScope;
}
public void OnCreate(ICoreVariableInstance variableInstance, AbstractVariableScope sourceScope)
{
variableInstance.IsConcurrentLocal = !Execution.IsScope || Execution.ExecutingScopeLeafActivity;
}
