| public abstract Execute ( TransitionInterpreter, interpreter ) : bool | ||
| interpreter | TransitionInterpreter, | |
| Résultat | bool | |
/// <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();
}
