/// <summary> /// Do redo now /// </summary> public void Redo() { if (!CanRedo()) { return; } this.CurrentlyWorking = true; try { Operation op = RedoStack.Pop(); op.Execute(WorkspaceModel); UndoStack.Push(op); while (RedoStack.Count > 0 && op.GetType().Equals(RedoStack.Peek().GetType()) && RedoStack.Peek().Identifier == op.Identifier && (RedoStack.Peek() is MoveModelElementOperation || RedoStack.Peek() is ResizeModelElementOperation || RedoStack.Peek() is MultiOperation)) { op = RedoStack.Pop(); op.Execute(WorkspaceModel); UndoStack.Push(op); } } finally { this.CurrentlyWorking = false; } }
/// <summary> /// Executes dialog/button. /// Dialogs returns redirect or messages. Buttons mostly just result in message; /// </summary> public async virtual Task <BotResponse> Execute(IUser user) { if (!ValidateUser(user.UserRole)) { return(new BotExceptionResponse(null, "txt_accessDenied", user, true)); } OperationResult opResult = new OperationResult(); object data = null; // aware context controller about op. execution if (Operation != null) { opResult = await Operation.Execute(user); if (opResult.ResultType == OperationResult.OperationResultType.Failed || opResult.ResultType == OperationResult.OperationResultType.Unknown) { return(new BotExceptionResponse(opResult.ExceptionMessage, "txt_internalServerError", user, true)); } else { // keep op. data data = opResult.Result; } } BotResponse response = new BotResponse(data, BotResponse.ResponseType.Dialog, user, this); return(response); }
public override async Task <BotResponse> Execute(IUser user) { // get next dialog and call it // if it last or no any dialogs - return container and execute it Dialog next = Next(BotManager.Core.BotApiManager.ContextController.GetUserState(user).CurrentDialog); object data = null; if (next == this) { var opResult = await Operation.Execute(user); if (opResult.ResultType == OperationResult.OperationResultType.Failed || opResult.ResultType == OperationResult.OperationResultType.Unknown) { return(new BotExceptionResponse(opResult.ExceptionMessage, "txt_internalServerError", user, true)); } else { data = opResult.Result; } BotResponse response = new BotResponse(data, BotResponse.ResponseType.Dialog, user, this); return(response); } return(await next.Execute(user)); }
public void Should_not_jump_when_sibling_is_zero() { const int objectNumber = 10; const int sibling = 0; var args = new OperandBuilder() .WithArg(objectNumber) .Build(); var zObj = new ZMachineObjectBuilder() .WithObjectNumber(objectNumber) .WithSibling(sibling) .Build(); Mockery .SetNextObject(zObj); Operation.Execute(args); Mockery .ResultDestinationRetrievedFromPC() .ResultStoredWasByte(sibling) .JumpedWith(false) ; }
public void PressKey(int keyIndex) { if (keyIndex < _operations.Count) { Operation operation = _operations[keyIndex]; if (_input.AddChar(operation.ShortCut)) { return; } if (operation.ShortCut == '\b' && _calculationStack.Count > 0) { _calculationStack.Pop(); return; } if (operation.HasFunction) { if (_input.IsActive) { _calculationStack.Push(_input.ToDouble()); _input.Clear(); if (operation.Name == "Enter") { return; } } operation.Execute(_calculationStack); } } }
static public IEnumerable <T> ExecuteRepeated <T>(this Operation <T> item, int times) { for (int i = 0; i < times; i++) { yield return(item.Execute()); } }
public void Process() { if (Input.GetKeyDown(key)) { operation.Execute(); } }
protected override void RunIterationInternal() { IEnumerable <T> data = data_operation.Execute(); process_a.SetData(data); process_b.SetData(data); }
public void Should_store_parent_and_never_jump() { const int objectNumber = 10; const int parent = 25; var args = new OperandBuilder() .WithArg(AnyVariable) .Build(); var zObj = new ZMachineObjectBuilder() .WithObjectNumber(objectNumber) .WithParent(parent) .Build(); Mockery .SetNextObject(zObj); Operation.Execute(args); Mockery .ResultDestinationRetrievedFromPC() .ResultStoredWasByte(parent) .NeverJumps() ; }
static public T FindRolling <T>(this IEnumerable <T> item, Operation <T, T, T> operation) { T rolling = default(T); item.Process(i => rolling = i, i => rolling = operation.Execute(rolling, i)); return(rolling); }
private void Do(Operation operation) { Log.DebugFormat("Beginning operator {0}...", operation); Action <Operation> proc; switch (operation.Type) { case OperationType.Start: proc = DoStart; break; case OperationType.Stop: proc = DoStop; break; case OperationType.HandleFailure: proc = op => DoHandleFailure(op); break; default: proc = DoNothing; break; } operation.Execute(proc); }
public void Should_set_call_routine_and_store_result() { const ushort packedRoutineAddress = 1234; var routineArgs = new[] { (ushort)1, (ushort)2, (ushort)3 }; var args = new OperandBuilder() .WithArg(packedRoutineAddress) .WithArgs(routineArgs) .Build(); Mockery .SetRoutineArgCount((byte)routineArgs.Length); Operation.Execute(args); var routineArgsOffset = routineArgs.Length * 2;// <= V4 Specific var unpackedAddress = ZMemory.UnpackedAddress(packedRoutineAddress); var expectedPC = (ushort)(unpackedAddress + routineArgsOffset); Mockery .ProgramCounterEquals(expectedPC) .RoutineResultWillBeStored() .LocalVariablesInitialisedFromMemory(routineArgs.Length) .RoutineArgsStoredInLocalVariables(routineArgs) ; }
public void Should_store_child_and_jump() { const int objectNumber = 10; const int child = 15; var args = new OperandBuilder() .WithArg(AnyVariable) .Build(); var zObj = new ZMachineObjectBuilder() .WithObjectNumber(objectNumber) .WithChild(child) .Build(); Mockery .SetNextObject(zObj); Operation.Execute(args); Mockery .ResultDestinationRetrievedFromPC() .ResultStoredWasByte(child) .JumpedWith(true) ; }
public void Should_do_nothing() { Mockery.StrictMode(); InitOperations(); Operation.Execute(null); }
public bool Calculate() { Stack <Operand <bool> > operands = new Stack <Operand <bool> >(); foreach (var item in OutArray) { if (item is Operand <bool> ) { operands.Push(item as Operand <bool>); } else { Operation <bool> oper = item as Operation <bool>; Operand <bool>[] ops = new Operand <bool> [oper.OperandsCount]; for (int i = 0; i < oper.OperandsCount; i++) { ops[i] = operands.Pop(); } operands.Push(oper.Execute(ops)); } } return(operands.Pop().Value); }
public void Should_output_a_single_newline() { Operation.Execute(null); Mockery .Printed(Environment.NewLine) ; }
public virtual void Think(int thought_count) { while (thought_count-- > 0 && Unit.Program.Next != null) { Operation operation = Unit.Program.Next; operation.Execute(Unit); } }
public async void ExecuteOperation(object o) { if (!DebuggerSession.Instance.IsAttached) { DebuggerSession.Instance.Detach(); App.Container.GetExport <IDialogService>().Value.ShowDialog("Process is detached"); return; } CancelOperationVisibility = Visibility.Visible; Items = null; Count = 0; IsLoading = true; IEnumerable <object> result = null; _cancellationToken = new CancellationTokenSource(); try { result = await Operation.Execute(Model, _cancellationToken.Token, o); } catch (OperationCanceledException) { App.Container.GetExport <IDialogService>().Value.ShowDialog("Operation is canceled"); } catch (Exception ex) { App.Container.GetExport <IDialogService>().Value.ShowDialog("Exception \n" + ex.Message); } if (result != null) { Items = new ObservableCollection <object>(result); if (Items.Count > 0) { _results.Add(Items.ToArray()); } } OnOperationCompleted(); //Observe(result, _cancellationToken.Token).SubscribeOn(Scheduler.Default).Buffer(TimeSpan.FromMilliseconds(100)) // .ObserveOn(new DispatcherSynchronizationContext(Dispatcher.CurrentDispatcher, DispatcherPriority.Normal)) // .Subscribe( // onNext => // { // if (onNext == null) return; // foreach (var value in onNext) // Items.Add(value); // Count = Items.Count; // OnPropertyChanged("Count"); // }, // ex => // { // OnOperationCompleted(); // if (ex is OperationCanceledException) // App.Container.GetExport<IDialogService>().Value.ShowDialog("Operation is canceled"); // }, // OnOperationCompleted); }
static public T Convert <KEY_TYPE, VALUE_TYPE, T>(this LookupBackedSet <KEY_TYPE, VALUE_TYPE> item, KEY_TYPE key, Operation <T> default_operation, Operation <T, VALUE_TYPE> operation) { if (item.IsAsBacked(key)) { return(default_operation.Execute()); } return(operation.Execute(item.Lookup(key))); }
static public J IfNotNull <T, J>(this T item, Operation <J, T> operation, Operation <J> if_null) { if (item.IsNotNull()) { return(operation.Execute(item)); } return(if_null.Execute()); }
public string Execute() { if (!Operation.Execute()) { return(State.FileContent); } return(ReplaceContent(State.FileContent, State.OriginalUsesClause, State.Units.ToString())); }
static public IEnumerable <OUTPUT_TYPE> Convert <INPUT_TYPE, OUTPUT_TYPE>(this IEnumerable <INPUT_TYPE> item, Operation <OUTPUT_TYPE, INPUT_TYPE> operation) { if (item != null) { foreach (INPUT_TYPE sub_item in item) { yield return(operation.Execute(sub_item)); } } }
public void Execute() { if (!_halted) { _operation.Execute(); _pc.Value = (ushort)(_pc.Value + _operation.Width); //TODO post execute event } }
public void Execute(C context) { var opContext = context; if (ContextFilter != null) { opContext = ContextFilter.Provide(opContext); } Operation.Execute(opContext); }
public void Should_NOT_jump_when_first_arg_less_than_or_equal_second_arg(ushort firstArg, ushort secondArg) { var args = new OperandBuilder() .WithArg(firstArg) .WithArg(secondArg) .Build(); Operation.Execute(args); Mockery.JumpedWith(false); }
public void Should_jump_when_first_arg_greater_than_second_arg(ushort firstArg, ushort secondArg) { var args = new OperandBuilder() .WithArg(firstArg) .WithArg(secondArg) .Build(); Operation.Execute(args); Mockery.JumpedWith(true); }
static void Main(string[] args) { System.IO.File.WriteAllText("output.txt", ""); string command = System.IO.File.ReadAllText("input.txt"); Operation operation = OperationParser.ParseCommand(command, Database.GetInstance()); operation.Execute(); operation.Revert(); }
public void Should_jump_when_a_value_matches_first_argument(ushort firstValue, params ushort[] toMatch) { var args = new OperandBuilder() .WithArg(firstValue) .WithArgs(toMatch) .Build(); Operation.Execute(args); Mockery.JumpedWith(true); }
/// <summary> /// Runs the task. /// </summary> /// <returns>The task.</returns> /// <param name="operation">Operation.</param> /// <param name="taskId">Task identifier.</param> /// <param name="numberOfOperations">Number of operations.</param> private async Task RunTask(Operation operation, int taskId, int numberOfOperations) { requestUnitsConsumed[taskId] = 0; for (var i = 0; i < numberOfOperations; i++) { await operation.Execute(this, client, collection, DocumentCollectionUri, taskId, Options); } DecrementPendingTaskCount(); }
public void Should_not_jump_when_arg_is_non_zero() { var args = new OperandBuilder() .WithArg(1) .Build(); Operation.Execute(args); Mockery .JumpedWith(false) ; }
public void ExecuteOperation(int idHomeDeviceDestination, string operationName, object[] args) { UnitOfWork repository = UnitOfWork.GetInstance(); HomeDevice homeDeviceDestination = repository.HomeDeviceRespository.GetById(idHomeDeviceDestination); if (homeDeviceDestination == null) throw new ArgumentException("HomeDevice destination id doesn't exist"); if (!homeDeviceDestination.GetHomeDeviceNameOperations().Contains(operationName)) throw new ArgumentException("OperationName is not available on this HomeDevice"); Operation operation = new Operation { DestionationHomeDevice = homeDeviceDestination, OperationName = operationName, Args = new object[]{homeDeviceDestination}.Concat(args).ToArray(), }; operation.Execute(); }