/// <summary> /// Deals with the next operation, if it is an <see cref="AtomicOperation"/> it is executed, /// if it is a <see cref="CompositeOperation"/> its single operations are pushed on the execution stack. /// </summary> /// <remarks>If an error occurs during the execution the operation is aborted and the operation /// is pushed on the stack again.<br/> /// If the execution was successful <see cref="EngineBase.OnOperationExecuted"/> is called.</remarks> protected virtual void ProcessNextOperation(bool logOperations, CancellationToken cancellationToken) { IAtomicOperation atomicOperation = CurrentOperation as IAtomicOperation; OperationCollection operations = CurrentOperation as OperationCollection; if (atomicOperation != null && operations != null) throw new InvalidOperationException("Current operation is both atomic and an operation collection"); if (atomicOperation != null) { if (logOperations) Log.LogMessage(string.Format("Performing atomic operation {0}", Utils.Name(atomicOperation))); PerformAtomicOperation(atomicOperation, cancellationToken); } else if (operations != null) { if (logOperations) Log.LogMessage("Expanding operation collection"); ExecutionStack.AddRange(operations.Reverse()); CurrentOperation = null; } else if (ExecutionStack.Count > 0) { if (logOperations) Log.LogMessage("Popping execution stack"); CurrentOperation = ExecutionStack.Last(); ExecutionStack.RemoveAt(ExecutionStack.Count - 1); } else { if (logOperations) Log.LogMessage("Nothing to do"); } OperatorTrace.Regenerate(CurrentAtomicOperation); }
public override IOperation InstrumentedApply() { IOperation next = base.InstrumentedApply(); IVRPEncoding solution = VRPToursParameter.ActualValue; generator.PermutationParameter.ActualName = VRPToursParameter.ActualName; IAtomicOperation op = this.ExecutionContext.CreateChildOperation(generator); op.Operator.Execute((IExecutionContext)op, CancellationToken); foreach (IScope scope in this.ExecutionContext.Scope.SubScopes) { IVariable moveVariable = scope.Variables[ TranslocationMoveParameter.ActualName]; if (moveVariable.Value is TranslocationMove && !(moveVariable.Value is AlbaTranslocationMove)) { TranslocationMove move = moveVariable.Value as TranslocationMove; moveVariable.Value = new AlbaTranslocationMove( move.Index1, move.Index2, move.Index3, solution as AlbaEncoding); } } return(next); }
private void treeView_NodeMouseDoubleClick(object sender, TreeNodeMouseClickEventArgs e) { if (e.Node != null) { IAtomicOperation op = e.Node.Tag as IAtomicOperation; if (op != null) MainFormManager.MainForm.ShowContent(op.Operator); } }
protected virtual void PerformAtomicOperation(IAtomicOperation operation, CancellationToken cancellationToken) { if (operation != null) { try { IOperation successor = operation.Operator.Execute((IExecutionContext)operation, cancellationToken); if (successor != null) { OperatorTrace.RegisterParenthood(operation, successor); ExecutionStack.Add(successor); } CurrentOperation = null; } catch (Exception ex) { if (ex is OperationCanceledException) { throw ex; } else { throw new OperatorExecutionException(operation.Operator, ex); } } } }
private void ApplyInnerSelector() { // necessary for inner GenderSpecificSelector to execute all operations in OperationCollection Stack <IOperation> executionStack = new Stack <IOperation>(); executionStack.Push(ExecutionContext.CreateChildOperation(Selector)); while (executionStack.Count > 0) { CancellationToken.ThrowIfCancellationRequested(); IOperation next = executionStack.Pop(); if (next is OperationCollection) { OperationCollection coll = (OperationCollection)next; for (int i = coll.Count - 1; i >= 0; i--) { if (coll[i] != null) { executionStack.Push(coll[i]); } } } else if (next is IAtomicOperation) { IAtomicOperation operation = (IAtomicOperation)next; next = operation.Operator.Execute((IExecutionContext)operation, CancellationToken); if (next != null) { executionStack.Push(next); } } } }
protected override PrinsEncoding Crossover(IRandom random, PrinsEncoding parent1, PrinsEncoding parent2) { if (parent1.Length != parent2.Length) { return(parent1.Clone() as PrinsEncoding); } //note - the inner crossover is called here and the result is converted to a prins representation //some refactoring should be done here in the future - the crossover operation should be called directly InnerCrossoverParameter.ActualValue.ParentsParameter.ActualName = ParentsParameter.ActualName; IAtomicOperation op = this.ExecutionContext.CreateOperation( InnerCrossoverParameter.ActualValue, this.ExecutionContext.Scope); op.Operator.Execute((IExecutionContext)op, CancellationToken); string childName = InnerCrossoverParameter.ActualValue.ChildParameter.ActualName; if (ExecutionContext.Scope.Variables.ContainsKey(childName)) { Permutation permutation = ExecutionContext.Scope.Variables[childName].Value as Permutation; ExecutionContext.Scope.Variables.Remove(childName); return(new PrinsEncoding(permutation, ProblemInstance)); } else { return(null); } }
/// <summary> /// 添加一个执行器到队列queuedInvocations并执行 /// </summary> /// <param name="executionOperation">执行器</param> /// <param name="execution"></param> /// <param name="performAsync">是否异步</param> public virtual void PerformOperation(IAtomicOperation executionOperation, ExecutionEntity execution, bool performAsync) { AtomicOperationInvocation invocation = new AtomicOperationInvocation(executionOperation, execution, performAsync); queuedInvocations.Enqueue(invocation);//.Insert(0, invocation); PerformNext(); }
protected override void Manipulate(IRandom random, ZhuEncoding individual) { InnerManipulatorParameter.ActualValue.PermutationParameter.ActualName = VRPToursParameter.ActualName; IAtomicOperation op = this.ExecutionContext.CreateOperation( InnerManipulatorParameter.ActualValue, this.ExecutionContext.Scope); op.Operator.Execute((IExecutionContext)op, CancellationToken); }
protected override void PerformMove() { IVRPMove move = VRPMoveParameter.ActualValue as IVRPMove; VRPMoveMaker moveMaker = move.GetMoveMaker(); moveMaker.VRPMoveParameter.ActualName = VRPMoveParameter.Name; IAtomicOperation op = this.ExecutionContext.CreateOperation(moveMaker); op.Operator.Execute((IExecutionContext)op, CancellationToken); }
public virtual bool IsApplicableForOperation(IAtomicOperation operation) { foreach (var identifier in OperationIdentifier) { if (operation.CanonicalName.Equals(identifier)) { return(true); } } return(false); }
public override IOperation InstrumentedApply() { IOperation next = base.InstrumentedApply(); IVRPEncoding solution = VRPToursParameter.ActualValue; PermutationMoveOperatorParameter.PermutationParameter.ActualName = VRPToursParameter.ActualName; IAtomicOperation op = this.ExecutionContext.CreateChildOperation(PermutationMoveOperatorParameter); op.Operator.Execute((IExecutionContext)op, CancellationToken); return next; }
public static void PerformAction(object sender, IAtomicOperation action) { if (IsInDocumentTree(sender)) { (action as DocAtomicOperation).PrepareForHistory(); History.Instance.Execute(action); } else { action.Do(); } }
protected override void PerformMove() { IVariable moveVariable = this.ExecutionContext.Scope.Variables[ TranslocationMoveParameter.ActualName]; TranslocationMove move = moveVariable.Value as TranslocationMove; VRPToursParameter.ActualValue = move.Permutation as AlbaEncoding; moveMaker.PermutationParameter.ActualName = VRPToursParameter.ActualName; IAtomicOperation op = this.ExecutionContext.CreateChildOperation(moveMaker); op.Operator.Execute((IExecutionContext)op, CancellationToken); }
//helper method to evaluate an updated individual protected void UpdateEvaluation(IVRPEncoding updatedTours) { IVRPEvaluator evaluator = ProblemInstance.MoveEvaluator; try { this.ExecutionContext.Scope.Variables.Add(new Variable(evaluator.VRPToursParameter.ActualName, updatedTours)); IAtomicOperation op = this.ExecutionContext.CreateChildOperation(evaluator); op.Operator.Execute((IExecutionContext)op, CancellationToken); } finally { this.ExecutionContext.Scope.Variables.Remove(evaluator.VRPToursParameter.ActualName); } }
private void PerformUndo(IAtomicOperation action) { CheckNotInAction(); DocLogger.WriteLineVerbose("Undo: " + action.ToString()); try { currentlyInAction = true; action.Undo(); } finally { currentlyInAction = false; } }
private int AddStackOperations(TreeNodeCollection nodes, IEnumerable <IOperation> operations) { int count = 0; foreach (IOperation op in operations) { if (op is IAtomicOperation) { IAtomicOperation atom = op as IAtomicOperation; TreeNode node = nodes.Add(atom.Operator.Name ?? atom.Operator.ItemName); node.Tag = atom; node.ToolTipText = string.Format("{0}{1}{1}{2}", Utils.TypeName(atom.Operator), Environment.NewLine, Utils.Wrap(atom.Operator.Description ?? atom.Operator.ItemDescription, 60)); if (atom.Operator.Breakpoint) { node.ForeColor = Color.Red; node.ImageIndex = 2; node.SelectedImageIndex = 2; } else { node.ImageIndex = 0; node.SelectedImageIndex = 0; } count++; } else if (op is OperationCollection) { OperationCollection ops = op as OperationCollection; TreeNode node = nodes.Add( string.Format("{0} {2}Operation{1}", ops.Count, ops.Count == 1 ? string.Empty : "s", ops.Parallel ? "Parallel " : string.Empty )); node.Tag = op; node.ToolTipText = Utils.TypeName(ops); node.ImageIndex = 1; node.SelectedImageIndex = 1; count += AddStackOperations(node.Nodes, ops); } } return(count); }
private void PerformAdd(IAtomicOperation action) { CheckCurrentAction(); if (Object.ReferenceEquals(action, null)) { throw new Exception("Can't add null action"); } while (currentAction < actions.Count - 1) { actions.Remove(actions.Last()); } actions.Add(action); currentAction++; CheckCurrentAction(); }
public static void PerformAction(object sender, EventArgs e) { IAtomicOperation action = (e as IAtomicOperations).CreateActions(sender as IDocLeaf).First(); if (IsInDocumentTree(sender)) { if (History.Instance.MarkDirty != null) { History.Instance.MarkDirty(sender, e); } (action as DocAtomicOperation).PrepareForHistory(); History.Instance.Execute(action); } else { action.Do(); } }
public void Execute(IAtomicOperation action) { CheckThreadId(); Debug.Assert(action.IsValidForHistory); CheckNotInAction(); if (HasTransaction()) { PerformDo(action); transaction.Add(action); } else { PerformDo(action); PerformAdd(action); PerformNotifications(); } }
public virtual void RegisterParenthood(IAtomicOperation parent, IOperation children) { if (!isEnabled) { return; } OperationCollection operations = children as OperationCollection; if (operations != null) { foreach (var op in operations) { RegisterParenthood(parent, op); } } IAtomicOperation atomicOperation = children as IAtomicOperation; if (atomicOperation != null && atomicOperation.Operator != null && !parents.ContainsKey(atomicOperation)) { parents[atomicOperation] = parent; } }
public virtual void Regenerate(IAtomicOperation operation) { if (!isEnabled) { Reset(); return; } if (operation == null) { return; } Stack <IOperator> trace = new Stack <IOperator>(); while (operation != null) { trace.Push(operation.Operator); IAtomicOperation parent = null; parents.TryGetValue(operation, out parent); operation = parent; } ReplaceAll(trace); }
/// <summary> /// 添加一个异步执行的执行器到队列queuedInvocations 并执行 /// </summary> /// <param name="executionOperation">执行器</param> /// <param name="execution"></param> public virtual void PerformOperationAsync(IAtomicOperation executionOperation, ExecutionEntity execution) { PerformOperation(executionOperation, execution, true); }
protected virtual void PerformAtomicOperation(IAtomicOperation operation, CancellationToken cancellationToken) { if (operation != null) { try { IOperation successor = operation.Operator.Execute((IExecutionContext)operation, cancellationToken); if (successor != null) { OperatorTrace.RegisterParenthood(operation, successor); ExecutionStack.Add(successor); } CurrentOperation = null; } catch (Exception ex) { if (ex is OperationCanceledException) throw ex; else throw new OperatorExecutionException(operation.Operator, ex); } } }
public static string Name(IAtomicOperation operation) { return(string.IsNullOrEmpty(operation.Operator.Name) ? operation.Operator.ItemName : operation.Operator.Name); }
public void Add(IAtomicOperation action) { actions.Add(action); }
public static string Name(IAtomicOperation operation) { return string.IsNullOrEmpty(operation.Operator.Name) ? operation.Operator.ItemName : operation.Operator.Name; }
/// <summary> /// 添加一个同步执行的执行器到队列queuedInvocations并执行 /// </summary> /// <param name="executionOperation"></param> /// <param name="execution"></param> public virtual void PerformOperation(IAtomicOperation executionOperation, ExecutionEntity execution) { PerformOperation(executionOperation, execution, false); }
protected internal virtual void Init(IAtomicOperation operation, ExecutionEntity execution, bool performAsync) { this.operation = operation; this.execution = execution; this.performAsync = performAsync; }
/// <summary> /// /// </summary> /// <param name="operation">执行器</param> /// <param name="execution">ExecutionEntity</param> /// <param name="performAsync">是否异步</param> public AtomicOperationInvocation(IAtomicOperation operation, ExecutionEntity execution, bool performAsync) { Init(operation, execution, performAsync); }
public void Append(IAtomicOperation operation) { this.state.AppendedOperations.Add(operation); }