/// <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 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.");
 }

 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);
     }
 }

        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;
        }

 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 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 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 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);
     }
 }

        private void DownloaderRunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
        {
            title = TitleEncoding;
            state = ProcessState.Encoding;

            SetChanged();
        }

        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;
        }

        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 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 virtual void DoInstruction(ExpressionMediator exm, InstructionLine func, ProcessState state)
 {
     throw new ExeEE("未実装 or 呼び出しミス");
 }

        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 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 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);
        }