/// <inheritdoc />
 public IDispatcher FromThread(IThread thread)
 {
     var wrap = (thread as ThreadWrap);
     if (wrap == null) throw new ArgumentException("Thread should wrap CLR thread","thread");
     var real = ((IWrap<Thread>) wrap).UnderlyingObject;
     return new DispatcherWrap(Dispatcher.FromThread(real));
 }

 public Thread(Generator generator, Action action)
     : base(generator, typeof(IThread))
 {
     inner = (IThread)Handler;
     this.action = action;
     inner.Create();
 }

        public ExceptionDialog(IThread thread)
        {
            InitializeComponent();
            this.Icon = _icon;

            _exceptionValue = thread.CurrentException;
            _sourceLocation = thread.GetCurrentSourceRange();

            // no need to hook to UILanguageChanged as this dialog will be closed 
            // before the user gets any chance to update the UI language.
            var _componentMuiIdentifiers = new Dictionary<object, string>()
            {
                {this, "ExceptionDialog.Title"},
                {headerLabel, "ExceptionDialog.ExceptionOccured"},
                {fileLabel, "ExceptionDialog.File"},
                {locationLabel, "ExceptionDialog.Location"},
                {messageLabel, "ExceptionDialog.Message"},
                {closeButton, "ExceptionDialog.Close"},
                {goToFileButton, "ExceptionDialog.GoToFile"},
                {detailsButton, "ExceptionDialog.Details"},
            };
            
            DebuggerBase.Instance.MuiProcessor.ApplyLanguageOnComponents(_componentMuiIdentifiers);

            fileTextBox.Text = _sourceLocation.FilePath.FullPath;
            locationTextBox.Text = DebuggerBase.Instance.MuiProcessor.GetString("ExceptionDialog.LocationFormat",
                "line=" + _sourceLocation.Line,
                "column=" + _sourceLocation.Column);
            messageTextBox.Text = _exceptionValue.ValueAsString(thread);
        }

        public MessageReceiverWorkerThread(
			IReceiveFromEndpoints receiverQueue,
			Func<IRouteMessagesToHandlers> routerFactory,
			Func<Action, IThread> thread)
        {
            this.receiverQueue = receiverQueue;
            this.routerFactory = routerFactory;
            this.thread = thread(this.StartReceiving);
        }

        public void UpdateControl(IThread currentThread)
        {
            if (currentThread == null)
            {
                listView1.Items.Clear();
                return;
            }

            UpdateList(currentThread);
        }

        public int AllocateActor(IThread thread)
        {
            lock (_lock)
            {
                int actorId = _nextActorId;
                _nextActorId++;

                _actorsToThreads.Add(actorId, thread);
                return actorId;
            }
        }

        public WorkerPoolWorker(
            int ordinal,
            IThreadFactory threadFactory,
            BlockingCollection<IDelivery> deliveries,
            IDeliveryProcessor connectedProcessor)
            : base(connectedProcessor)
        {
            this.ordinal = ordinal;
            this.deliveries = deliveries;

            thread = threadFactory.Create(StartTakingMessages);
        }

        private bool IsReviewThread(IThread thread)
        {
            var isReview = false;

            if (thread.Behavior == null)
            {
                isReview = thread.Key.EndsWith("_review", StringComparison.Ordinal);
            }
            else
            {
                isReview = thread.Behavior == "review";
            }

            return isReview;
        }

 public override void Execute(IThread thread)
 {
     thread.Syscall (thread.Regs.IntRegs[2]);
 }

 public override uint Ea(IThread thread)
 {
     uint addr = (uint)(thread.Regs.IntRegs[this[BitField.RS]] + this.Displacement);
     uint ea = addr & ~3u;
     return ea;
 }

 public ProcessInformation(IntPtr processHandle, int processId, IntPtr threadHandle, int threadId)
 {
     _process = new Process(new ProcessHandle(processHandle));
     _processId = processId;
     _thread = new Thread(new ThreadHandle(threadHandle));
     _threadId = threadId;
 }

		public void Dispose()
		{
			ShutdownConsole();
			
			if (thread != null) {
				if (thread.Join(100)) {
					thread = null;
					IsRunning = false;
				}
			}
		}

 public Once(OncePool nOncePool)
 {
     mLock = new object();
     mRunning = false;
     mOncePool = nOncePool;
     mRunnable = null;
     PlatformSingleton platformSingleton_ = __singleton<PlatformSingleton>._instance();
     mThread = platformSingleton_._createThread();
     mThread.m_tRunSlot += _runOnce;
     mThread._startRun();
 }