/// <summary> /// Creates a processing result with the specified state. /// </summary> /// <param name="state">The state.</param> /// <param name="message">The message.</param> /// <returns></returns> public static ProcessResult Create(ProcessState state, string message) { var result = new ProcessResult(); result.State = state; result.Message = message; return result; }
public ProcessReturnValue() { this.fileName = "result"; this.status = ProcessState.Accepted; this.statusMessage = ""; this.returnValues = new List<OutputData>(); this.responseForm = new ResponseFormType("wps:ResponseForm"); }
public ProcessReturnValue(SerializationInfo info, StreamingContext ctxt) { fileName = (string)info.GetValue("fileName", typeof(string)); status = (ProcessState)info.GetValue("status", typeof(ProcessState)); statusMessage = (string)info.GetValue("statusMessage", typeof(string)); returnValues = (List<OutputData>)info.GetValue("returnValues", typeof(List<OutputData>)); responseForm = (ResponseFormType)info.GetValue("responseForm", typeof(ResponseFormType)); percentageCompleted = (int)info.GetValue("percentageCompleted", typeof(int)); }
public void Start() { thread = new Thread(new ThreadStart(Run)); thread.IsBackground = true; isRun = true; thread.SetApartmentState(ApartmentState.STA); thread.Start(); state = ProcessState.Stared; }
public void Fail() { if (State == ProcessState.Running || State == ProcessState.Paused) { State = ProcessState.Succeeded; return; } throw new InvalidOperationException("Invalid process transition. Process must be either running or paused to fail."); }
private void SetState(ProcessState NewState) { if (State != NewState) { State = NewState; Signaled = true; Signal(); } }
private void SetState(ProcessState newState) { if (State != newState) { State = newState; _signaled = true; Signal(); } }
protected override bool ProcessInteractionObject(Interactable interactable, ProcessState processState) { if (interactable.GetComponent <InteractableUi>() != null && uiLaser != null) { #if UNITY_EDITOR if (debugInteractor) { Debug.Log(name + ": Check selected UI operation: " + 0 + " for state: " + processState); } #endif InteractionEventData eventData = new InteractionEventData() { controller = this }; bool operationStateChanged = false; if (DriverOperationStarted(0)) { eventData.operationId = 0; downedInteractable = interactable; uiLaser.PassButtonDown(interactable); operationStateChanged = true; } if (DriverOperationEnded(0)) { eventData.operationId = 0; downedInteractable = null; uiLaser.PassButtonUp(interactable, clickTolerance); interactable.RemovePressedState(this); SurfaceTopHoveredObject(); operationStateChanged = true; } if (!operationStateChanged) { // Held eventData.operationId = 0; } } else { return(base.ProcessInteractionObject(interactable, processState)); } return(true); }
/// <summary> /// Assumes that nextElementId is a valid task/state /// </summary> private List <InstanceEvent> MoveProcessToNext( Instance instance, string nextElementId, ClaimsPrincipal user) { List <InstanceEvent> events = new List <InstanceEvent>(); ProcessState previousState = JsonConvert.DeserializeObject <ProcessState>(JsonConvert.SerializeObject(instance.Process)); ProcessState currentState = instance.Process; string previousElementId = currentState.CurrentTask?.ElementId; ElementInfo nextElementInfo = ProcessHelper.Process.GetElementInfo(nextElementId); DateTime now = DateTime.UtcNow; // ending previous element if task if (ProcessHelper.IsTask(previousElementId)) { instance.Process = previousState; events.Add(GenerateProcessChangeEvent(InstanceEventType.process_EndTask.ToString(), instance, now, user)); instance.Process = currentState; } // ending process if next element is end event if (ProcessHelper.IsEndEvent(nextElementId)) { currentState.CurrentTask = null; currentState.Ended = now; currentState.EndEvent = nextElementId; events.Add(GenerateProcessChangeEvent(InstanceEventType.process_EndEvent.ToString(), instance, now, user)); // add submit event (to support Altinn2 SBL) events.Add(GenerateProcessChangeEvent(InstanceEventType.Submited.ToString(), instance, now, user)); } else if (ProcessHelper.IsTask(nextElementId)) // starting next task { currentState.CurrentTask = new ProcessElementInfo { Flow = currentState.CurrentTask.Flow + 1, ElementId = nextElementId, Name = nextElementInfo.Name, Started = now, AltinnTaskType = nextElementInfo.AltinnTaskType, Validated = null, }; events.Add(GenerateProcessChangeEvent(InstanceEventType.process_StartTask.ToString(), instance, now, user)); } // current state points to the instance's process object. The following statement is unnecessary, but clarifies logic. instance.Process = currentState; return(events); }
/// <summary> /// Set process state to cancelled and stop the vertex host process if possible /// </summary> public void Cancel(bool suppressNotifications) { DryadLogger.LogMethodEntry(this.DryadId); lock (syncRoot) { if (state == ProcessState.Completed) { // Process has already completed before cancelation made it here, do nothing DryadLogger.LogInformation("Cancel process", "Process {0} has already exited", DryadId); DryadLogger.LogMethodExit(); return; } DryadLogger.LogInformation("Cancel process", "Process {0} has not already exited", DryadId); state = ProcessState.Completed; this.cancelled = true; } // If the process started, kill it if (systemProcess != null) { try { // Killing the process will trigger Process_Exited DryadLogger.LogInformation("Cancel process", "Killing system process for process id {0}", DryadId); if (suppressNotifications) { // Remove the Exited event handler systemProcess.Exited -= this.Process_Exited; } systemProcess.Kill(); DryadLogger.LogMethodExit(); return; } catch (Exception e) { // // Failed to kill process - log exception // DryadLogger.LogError(0, e, "Failed to kill system process for process id {0}", DryadId); } } else { DryadLogger.LogInformation("Cancel process", "Process {0} has not started yet", DryadId); } // Process was either not running or failed to die, trigger Process_Exited ourself if (!suppressNotifications) { Process_Exited(this, null); } DryadLogger.LogMethodExit(); }
static void GetProcessor([Domain("currentBar")] Bar b) { if (Resources.cpus > 0) { state = ProcessState.RUN; } else { TimeUpdate.tickEnabled = true; } }
public static void PreProcessSQLTree(ref Node parentNode) { ProcessState state = new ProcessState(); var childList = new List <Node>(parentNode.Children); PreProcessChildren(ref childList, state); //if (state.ScriptOutsideOfProcedure && !state.IsTransactionIsolationSet) //{ // parentNode.InsertChildAtIndex(CreateIsolationNode(), 0); //} }
/// <summary> /// Processes a single statement from the decompiler and returns an AST entry for it /// </summary> /// <param name="network">The top-level network.</param> /// <param name="proc">The process where the method is located.</param> /// <param name="method">The method where the statement is found.</param> /// <param name="statement">The decompiler statement to process.</param> protected virtual Statement Decompile(NetworkState network, ProcessState proc, MethodState method, ICSharpCode.Decompiler.CSharp.Syntax.ReturnStatement statement) { var s = new ReturnStatement() { Parent = method }; s.ReturnExpression = Decompile(network, proc, method, s, statement.Expression); return(s); }
/// <summary> /// Locates the target for an expression, and throws an exception if not found. /// </summary> /// <returns>The data element.</returns> /// <param name="network">The top-level network.</param> /// <param name="proc">The process where the method is located.</param> /// <param name="method">The method where the statement is found.</param> /// <param name="statement">The statement where the expression is found.</param> /// <param name="expression">The expression to examine.</param> protected virtual DataElement LocateDataElement(NetworkState network, ProcessState proc, MethodState method, Statement statement, ICSharpCode.Decompiler.CSharp.Syntax.Expression expression) { var res = TryLocateDataElement(network, proc, method, statement, expression); if (res == null) { throw new Exception($"Unable to locate item for {expression}"); } return(res); }
//操作类型 public static ProcessState ToProcessState(object objOpt) { ProcessState processState = ProcessState.Run; try { processState = (ProcessState)System.Enum.Parse(typeof(ProcessState), Convert.ToString(objOpt), true); } catch { } return(processState); }
/// <summary> /// Parses a a parameter reference and returns a new AST reference /// </summary> /// <returns>The constant element.</returns> /// <param name="network">The top-level network.</param> /// <param name="proc">The process where the method is located.</param> /// <param name="method">The method the parameter belongs to.</param> /// <param name="parameter">The parameter to parse.</param> protected virtual Parameter ParseParameter(NetworkState network, ProcessState proc, MethodState method, ParameterDefinition parameter) { return(new Parameter() { CecilType = parameter.ParameterType, Name = parameter.Name, DefaultValue = null, Source = parameter, Parent = method }); }
static void GetStack([Domain("currentBar")] Bar b) { if (Resources.stacks > 0) { state = ProcessState.READY; } else { TimeUpdate.tickEnabled = true; } }
//if the state is running state public bool isRunningState(ProcessState state) { if (state == ProcessState.Cleanup || state == ProcessState.Running || state == ProcessState.Setup) { return(true); } else { return(false); } }
public void FireStateChange(int processId, ProcessState newState) { try { vertexScheduler.ProcessChangeState(processId, newState); } catch (Exception e) { DryadLogger.LogError(0, e, "Failed to change state to {0} for process {1}", newState.ToString(), processId); } }
/// <summary> /// Locates a bus by reference /// </summary> /// <returns>The bus.</returns> /// <param name="network">The top-level network.</param> /// <param name="proc">The process where the method is located.</param> /// <param name="method">The method the expression is found.</param> /// <param name="expression">The expression used to initialize the bus.</param> protected virtual Bus LocateBus(NetworkState network, ProcessState proc, MethodState method, ICSharpCode.Decompiler.CSharp.Syntax.Expression expression) { var de = TryLocateElement(network, proc, method, null, expression); if (de is AST.Bus) { return(de as AST.Bus); } throw new Exception("Need to walk the tree?"); }
/// <summary> /// Copy Constructor. /// </summary> /// <param name="p"></param> public Process(Process p) { this._state = p._state; this._executiontime = p._executiontime; this._name = p._name; this._hasRun = p._hasRun; this._waitingtime = p._waitingtime; this._turnaroundtime = p._turnaroundtime; this._responsetime = p._responsetime; this._activeTimeOnProc = p._activeTimeOnProc; }
public XComputeProcess(int m_id) { this.m_id = m_id; this.m_currentState = ProcessState.Uninitialized; this.m_exitCode = 0; m_stateChangeListeners = new Dictionary <ProcessState, StateChangeEventHandler>(); m_stateChangeWaiters = new Dictionary <ProcessState, List <ManualResetEvent> >(); m_stateChangeTimers = new Dictionary <StateChangeEventHandler, Timer>(); m_propertyListeners = new Dictionary <string, Dictionary <ulong, GetSetPropertyEventHandler> >(); }
public void Update() { _state = _process.Responding ? ProcessState.Active : ProcessState.NotResponding; _memory = _process.PagedMemorySize64 / 1024; _memoryPercent = Math.Round((double)_memory / TotalRam * 1000) / 10; _threadCount = _process.Threads.Count; if (_username == null) { _username = GetProcessUser(_process); } if (!_system) { try { if (_filePath == null) { _filePath = _process.MainModule.FileName; } } catch (Exception) { _filePath = "N/A"; } try { _startDate = _process.StartTime; } catch (Exception) { _system = false; } } try { float f1 = _processCounter.NextValue(); _cpuUsage = f1 / Environment.ProcessorCount; } catch (Exception) { // ignored } OnPropertyChanged($"CPULoad"); OnPropertyChanged($"State"); OnPropertyChanged($"MemoryPercent"); OnPropertyChanged($"Memory"); OnPropertyChanged($"ThreadCount"); }
private void PushSubSearchAttributeToStack(ProcessState top, BlobFieldAttribute attrib, PropertyInfo prop, object target) { ProcessState state = new ProcessState(EProcessingState.SubFieldSearch, depth, target); state.Attributes.Add(attrib); state.Properties.Add(prop); state.WorkingType = top.WorkingType; processStack.Push(state); }
public Process() { CurrentState = ProcessState.Inactive; transitions = new Dictionary <StateTransition, ProcessState> { { new StateTransition(ProcessState.Inactive, Command.Active), ProcessState.Active }, { new StateTransition(ProcessState.Active, Command.Terminated), ProcessState.Inactive }, { new StateTransition(ProcessState.Active, Command.Raised), ProcessState.Raised }, { new StateTransition(ProcessState.Raised, Command.Handled), ProcessState.Inactive } }; }
public async Task <IHttpActionResult> PostAppoval(MdPeriod instance) { var result = new TransferObj <MdPeriod>(); var exist = _service.Find(instance); if (exist != null) { if (instance.TrangThai == (int)ApprovalState.IsComplete) { return(BadRequest("Kỳ này đã được duyệt!")); } var unitCode = _service.GetCurrentUnitCode(); var exsitPeriodNotClose = _service.Repository.DbSet.Any(x => x.Year == exist.Year && x.Period < exist.Period && x.TrangThai != (int)ApprovalState.IsComplete && x.UnitCode == unitCode); if (exsitPeriodNotClose) { return(BadRequest("Chưa khóa kỳ trước")); } var talbeName = instance.GetTableName(); var preTalbeName = _service.GetPreTableName(instance); ProcessState stateOfPeriod = _service.CheckProcess(instance); switch (stateOfPeriod) { case ProcessState.IsPending: try { _close.ProcedureCloseInventory(preTalbeName, talbeName, instance.UnitCode, instance.Year, instance.Period); exist.TrangThai = (int)ApprovalState.IsComplete; exist.ObjectState = ObjectState.Modified; result.Status = true; result.Message = "Khóa sổ thành công"; _service.UnitOfWork.Save(); } catch (Exception e) { return(InternalServerError(e)); } break; case ProcessState.IsComplete: break; case ProcessState.IsRunning: return(BadRequest("Đang trong quá trình khóa")); case ProcessState.IsError: break; default: break; } } return(Ok(result)); }
public async Task <ActionResult <ProcessState> > GetProcessState( [FromRoute] string org, [FromRoute] string app, [FromRoute] int instanceOwnerId, [FromRoute] Guid instanceGuid) { Instance instance = await instanceService.GetInstance(app, org, instanceOwnerId, instanceGuid); ProcessState processState = instance.Process; return(Ok(processState)); }
public DistributedProcessModel(string host, string process, string path, int portNum, bool local) { hostName = host; processName = process; processPath = path; port = portNum; arguments.Add(host); arguments.Add(port.ToString()); procState = ProcessState.Stopped; routing = new RouteModel(host, port - 10000, local); routing.openServerSocket(); }
public void AddProcessStateTest() { DataChamber data = new DataChamber(); DefaultDataGeneration filler = new DefaultDataGeneration(); DatabaseActions test = new DatabaseActions(data, filler); Catalog catalog = new Catalog("Andrzej", "Sapkowski", 2000, "The Witcher", 8); ProcessState processState = new ProcessState(catalog, "Znak", 1990, "Good"); test.AddProcessState(processState); Assert.AreEqual(test.ReadProcessState(5), processState); }
public void GetProcessStateOfInstanceWithoutProcessReturnsNull() { Mock <HttpContext> contextMock = MockContext(); ProcessController processController = NewProcessController(contextMock, null); ActionResult <ProcessState> result = processController.GetProcessState(org, app, int.Parse(instanceOwnerId), instanceGuid).Result; ProcessState state = result.Value; Assert.Null(state); }
/// <summary> /// Notify URI of state change /// </summary> /// <param name="replyUri">where to send state change notification</param> /// <param name="processId">vertex process id</param> /// <param name="newState">updated state</param> /// <returns>success/failure of state change notification</returns> public static bool FireStateChange(string replyUri, int processId, ProcessState newState) { DryadLogger.LogMethodEntry(replyUri, processId, newState); bool result = false; VertexCallbackServiceClient client = GetClient(replyUri); // // Try to notify GM of state change up to numRetries times // for (int index = 0; index < numRetries; index++) { try { // // If client is null, try reopening it // if (client == null) { client = CreateClient(replyUri); } // // Make FireStateChange WCF call, return success // client.FireStateChange(processId, newState); result = true; break; } catch (Exception e) { if (shuttingDown) { // if shutting down, just return DisposeClient(ref client); return(true); } else { // // If call failed, try reopening WCF client and calling again // client = ReopenClientForRetry(replyUri, e); } } } // // If failure occurs after X retry attempts, report error // DryadLogger.LogMethodExit(result); return(result); }
//returns first CafeNPC from activeNPC queue that fits state description. Returns null if there are no CafeNPC objects in that state. public CafeNPC firstCustomer(ProcessState state) { foreach (CafeNPC npc in GameManager.instance.activeNPC) { if (npc.state == state) { return(npc); } } return(null); }
public Process() { CurrentState = ProcessState.WithoutMesh; transitions = new Dictionary <StateTransition, ProcessState> { { new StateTransition(ProcessState.WithoutMesh, Command.FindServer), ProcessState.Searching }, { new StateTransition(ProcessState.HasMesh, Command.FindServer), ProcessState.Searching }, { new StateTransition(ProcessState.Searching, Command.Download), ProcessState.Downloading }, { new StateTransition(ProcessState.Downloading, Command.DownloadFinished), ProcessState.HasMesh }, }; }
private ChangelogIdentificationType OrderChangelogAsyncCaller(ChangelogOrderType order) { int id = -1; int.TryParse(order.datasetId, out id); IChangelogProvider changelogprovider; OrderChangelog resp; int startindex = -1; int count = -1; string initType; var datasets = from d in db.Datasets where d.DatasetId == id select d; initType = datasets.First().DatasetProvider; //Initiate provider from config/dataset Type providerType = Assembly.GetExecutingAssembly().GetType(initType); changelogprovider = Activator.CreateInstance(providerType) as IChangelogProvider; changelogprovider.Intitalize(id); int.TryParse(order.startIndex, out startindex); int.TryParse(order.count, out count); if (startindex == -1) { throw new Exception("MissingParameterValue : startindex"); } if (count == -1) { throw new Exception("MissingParameterValue : count"); } if (datasets.First().ServerMaxCount.HasValue&& (datasets.First().ServerMaxCount < count || count == 0)) { count = (int)datasets.First().ServerMaxCount; } resp = changelogprovider.CreateChangelog(startindex, count, "", id); // Create the delegate. OrderChangelogAsync caller = OrderChangeLogAsync; ProcessState state = new ProcessState(resp.changelogId); state.Request = caller; caller.BeginInvoke(changelogprovider, startindex, count, "", id, CallbackProcessStatus, state); ChangelogIdentificationType res = new ChangelogIdentificationType(); res.changelogId = resp.changelogId; return(res); }
protected override void SetProcessState(ProcessState State) { switch (State) { case ProcessState.Error: case ProcessState.Running: case ProcessState.Stopped: ProcessStatusText = string.Format("Đã ngừng đọc", TotalError); break; } base.SetProcessState(State); }
public DownloadDialogModel(Encoder encoder, Video video) { this.encoder = encoder; this.encoder.OnEncodeProgress += EncoderOnEncodeProgress; this.encoder.OnEncodeFinished += EncoderOnEncodeFinished; this.video = video; title = TitleDownloading; active = true; state = ProcessState.Downloading; }
protected ProcessState GetState(ProcessInfo process) { ProcessState result; if (!States.TryGetValue(process.Process.Id, out result)) { result = new ProcessState(process); States[process.Process.Id] = result; } return(result); }
public ProcessState MoveNext() { Command command = CurrentState switch { ProcessState.Active => Command.Raised, ProcessState.Raised => Command.Handled, _ => Command.Active, }; CurrentState = GetNext(command); return(CurrentState); }
public override void DoInstruction(ExpressionMediator exm, InstructionLine func, ProcessState state) { ExpressionArrayArgument intExpArg = (ExpressionArrayArgument)func.Argument; Int64 integer = -1; foreach (IOperandTerm int64Term in intExpArg.TermList) { integer = int64Term.GetIntValue(exm); if(isDel) exm.VEvaluator.DelCharacter(integer); else exm.VEvaluator.AddCharacter(integer, isSp); } }
public void Debug(int processID) { debugger = new CorDebugger(CorDebugger.GetDefaultDebuggerVersion()); process = debugger.DebugActiveProcess(processID, false); process.OnException += OnException; process.OnCreateAppDomain += OnNewAppDomain; process.OnProcessExit += OnExit; process.OnModuleLoad += OnModuleLoad; process.OnBreakpoint += OnBreakpoint; process.OnStepComplete += OnStepComplete; process.Continue(false); state = ProcessState.Started; subscriber.Published(string.Format("Successfully attached to Process with ID [{0}]", processID)); }
public void StartProcess() { State = ProcessState.Running; _programData.Lot.LotProgress = 0; for (int w = 0; w < 5; w++) { _programData.Lot.WaferProgress = 0; _programData.Lot.WaferId = (w + 1).ToString(); for (int d = 0; d < 100; d++) { Thread.Sleep(20); _programData.Lot.WaferProgress = d; } _programData.Lot.WaferProgress = 100; _programData.Lot.WaferId = ""; Thread.Sleep(100); _programData.Lot.LotProgress = 20 * (w + 1); } _programData.Lot.LotProgress = 100; State = ProcessState.Idle; }
public bool CheckValidity() { try { GBDebug.WriteLine(assembly); GBDebug.Assert(prState == ProcessState.PendingValidation, "Process state error. It is " + prState + ". It must be " + ProcessState.PendingValidation); userProcess = (GBProcess)assembly.CreateInstance(ProcessMainClass); if (userProcess == null) { prState = ProcessState.InitError; GBInfo.WriteLine(ProcessMainClass + " not found."); return false; } prState = ProcessState.StartPending; return true; } catch (Exception) { prState = ProcessState.InitError; return false; } }
internal void Start() { GBDebug.Assert(prState == ProcessState.StartPending, "Process state error. It is " + prState + ". It must be " + ProcessState.StartPending); GBInfo.WriteLine("Starting process " + assembly.GetName()); // FIXME: Doing nothing userProcess.Start(); if (currentScene != null) currentScene.LoadNotLoadedResources(); prState = ProcessState.Running; }
public void LoadModuleFromFile(string fileName) { GBDebug.Assert(prState == ProcessState.NotLoaded, "Process state error. It is " + prState + ". It must be " + ProcessState.NotLoaded); name = fileName; completeFileName = GBFileSystem.CompleteFileNameForFile(baseDir, fileName + "." + ModuleExtension); if (GBFileSystem.FileExists(completeFileName)) { assembly = Assembly.LoadFrom(completeFileName); GBDebug.Assert(assembly != null, "Assembly " + fileName + " cannot be loaded"); prState = ProcessState.PendingValidation; } else { prState = ProcessState.InitError; throw new GBException(GBException.Reason.FileNotFound); } }
public override void DoInstruction(ExpressionMediator exm, InstructionLine func, ProcessState state) { string label = null; LogicalLine jumpto = null; if (func.Argument.IsConst) { label = func.Argument.ConstStr; jumpto = func.JumpTo; } else { label = ((SpCallArgment)func.Argument).FuncnameTerm.GetStrValue(exm); if (Config.ICVariable) label = label.ToUpper(); jumpto = state.CurrentCalled.CallLabel(GlobalStatic.Process, label); } if (jumpto == null) { if (!func.Function.IsTry()) throw new CodeEE("指定されたラベル名\"$" + label + "\"は現在の関数内に存在しません"); if (func.JumpToEndCatch != null) state.JumpTo(func.JumpToEndCatch); return; } else if (jumpto.IsError) throw new CodeEE("指定されたラベル名\"$" + label + "\"は無効な$ラベル行です"); state.JumpTo(jumpto); }
CommandResult CloneParentOperation(SingleSteppingEngine new_thread) { if (parent.current_state == ProcessState.SingleThreaded) { current_state = ProcessState.SingleThreaded; return new ThreadCommandResult (new_thread.Thread); } if (parent.current_state != ProcessState.Running) throw new InternalError (); current_state = ProcessState.Running; if ((parent.current_operation.ThreadingModel & ThreadingModel.ThreadingMode) == ThreadingModel.Global) current_operation = parent.current_operation; else if ((parent.current_operation.ThreadingModel & ThreadingModel.ThreadingMode) == ThreadingModel.Process) current_operation = new ProcessCommandResult (this, parent.current_operation.ThreadingModel); else throw new InternalError (); return current_operation; }
public override void DoInstruction(ExpressionMediator exm, InstructionLine func, ProcessState state) { exm.VEvaluator.InitRanddata(); }
internal void OperationCompleted(SingleSteppingEngine caller, TargetEventArgs result, ThreadingModel model) { if (!ThreadManager.InBackgroundThread && Inferior.HasThreadEvents) throw new InternalError (); if (current_state == ProcessState.Stopping) return; else if (current_state != ProcessState.Running) throw new InternalError (); if ((result != null) && (caller != main_thread) && ((result.Type == TargetEventType.TargetExited) || (result.Type == TargetEventType.TargetSignaled))) return; current_state = ProcessState.Stopping; SuspendUserThreads (model, caller); lock (this) { current_state = ProcessState.Stopped; current_operation.Completed (); current_operation = null; stopped_event.Set (); } }
public ProcessStateInfo(int msg, Stream data) : base(msg, data) { Id = readStream.ReadInt32(); Alias = readStream.ReadString(); State = (ProcessState)readStream.ReadByte(); }
public virtual void DoInstruction(ExpressionMediator exm, InstructionLine func, ProcessState state) { throw new ExeEE("未実装 or 呼び出しミス"); }
internal CommandResult StartOperation(ThreadingModel model, SingleSteppingEngine caller) { if (!ThreadManager.InBackgroundThread) throw new InternalError (); if ((current_state != ProcessState.Stopped) && (current_state != ProcessState.SingleThreaded)) throw new TargetException (TargetError.NotStopped); if ((model & ThreadingModel.ThreadingMode) == ThreadingModel.Single) { current_state = ProcessState.SingleThreaded; if ((model & ThreadingModel.ResumeThreads) != 0) ResumeUserThreads (model, caller); return new ThreadCommandResult (caller.Thread); } else if ((model & ThreadingModel.ThreadingMode) != ThreadingModel.Process) { throw new ArgumentException (); } lock (this) { current_state = ProcessState.Running; stopped_event.Reset (); current_operation = new ProcessCommandResult (this, model); } ResumeUserThreads (model, caller); return current_operation; }
internal void OnProcessExitedEvent() { DropGlobalThreadLock (); if (current_state == ProcessState.Running) { current_state = ProcessState.Exited; current_operation.Completed (); current_operation = null; stopped_event.Set (); } if (!is_forked) session.OnProcessExited (this); session.MainThreadGroup.RemoveThread (main_thread.ID); manager.Debugger.OnProcessExitedEvent (this); }
public override void DoInstruction(ExpressionMediator exm, InstructionLine func, ProcessState state) { LogicalLine ifJumpto = func.JumpTo;//ENDIF //チェック済み //if (func.IfCaseList == null) // throw new ExeEE("IFのIF-ELSEIFリストが適正に作成されていない"); //if (func.JumpTo == null) // throw new ExeEE("IFに対応するENDIFが設定されていない"); InstructionLine line = null; for (int i = 0; i < func.IfCaseList.Count; i++) { line = func.IfCaseList[i]; if (line.IsError) continue; if (line.FunctionCode == FunctionCode.ELSE) { ifJumpto = line; break; } //ExpressionArgument expArg = (ExpressionArgument)(line.Argument); //チェック済み //if (expArg == null) // throw new ExeEE("IFチェック中。引数が解析されていない。", func.IfCaseList[i].Position); //1730 ELSEIFが出したエラーがIFのエラーとして検出されていた state.CurrentLine = line; Int64 value = ((ExpressionArgument)(line.Argument)).Term.GetIntValue(exm); if (value != 0)//式が真 { ifJumpto = line; break; } } if (ifJumpto != func)//自分自身がジャンプ先ならそのまま state.JumpTo(ifJumpto); //state.RunningLine = null; }
internal void StartGlobalOperation(ThreadingModel model, SingleSteppingEngine caller, OperationCommandResult operation) { if (!ThreadManager.InBackgroundThread) throw new InternalError (); if ((current_state != ProcessState.Stopped) && (current_state != ProcessState.SingleThreaded)) throw new TargetException (TargetError.NotStopped); lock (this) { current_state = ProcessState.Running; stopped_event.Reset (); current_operation = operation; } ResumeUserThreads (model, caller); }
private void DownloaderRunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e) { title = TitleEncoding; state = ProcessState.Encoding; SetChanged(); }
internal void Stop() { main_thread.Invoke (delegate { current_state = ProcessState.Stopping; SuspendUserThreads (ThreadingModel.Process, null); current_state = ProcessState.Stopped; if (current_operation != null) { current_operation.Completed (); current_operation = null; } stopped_event.Set (); return null; }, null); }
public void LoadMetadata(string fileName) { GBDebug.Assert(prState == ProcessState.NotLoaded, "Process state error. It is " + prState + ". It must be " + ProcessState.NotLoaded); completePropertiesFileName = GBFileSystem.CompleteFileNameForFile(baseDir, fileName + "." + MetaDataExtension); if (GBFileSystem.FileExists(completePropertiesFileName)) { metadata = GBXMLContainer.LoadOrNull(completePropertiesFileName); GBDebug.WriteLine(metadata); } else { prState = ProcessState.InitError; throw new GBException(GBException.Reason.FileNotFound); } }
/// <summary> /// Runs the process. Assesses the correct state based on process' current executiontimeunit type. /// </summary> public void Run() { //If the process has never run before, run. if (!this._hasRun) this._hasRun = true; //Decrement the execution time. this._executiontime--; //Increase turnaround time. this._turnaroundtime++; //If there's no time remaining after running, change state to complete. if (this._executiontime.Remaining == 0) this._state = ProcessState.COMPLETE; else { //Change process state to IO if necessary. if (this._executiontime.Current.Type == ExecutionTimeType.IO) this._state = ProcessState.IO; //Change process state to Ready if necessary. else if (this._executiontime.Current.Type == ExecutionTimeType.BURST) this._state = ProcessState.READY; } }
public override void DoInstruction(ExpressionMediator exm, InstructionLine func, ProcessState state) { exm.Console.SetStringStyle(FontStyle.Regular); }