public Thread(Generator generator, Action action)
: base(generator, typeof(IThread))
{
inner = (IThread)Handler;
this.action = action;
inner.Create();
}
MessagesBuilderCallback CreateMessageBuilderCallback()
{
IThread fakeThread = null;
//fakeThread = threads.GetThread("");
return(new MessagesBuilderCallback(threads, fakeThread));
}
/// <summary>
/// Initializes a new instance of the <see cref="BaseRunTests"/> class.
/// </summary>
/// <param name="requestData">Provides services and data for execution</param>
/// <param name="package">The user input test source(package) list if it differs from actual test source otherwise null.</param>
/// <param name="runSettings">The run settings.</param>
/// <param name="testExecutionContext">The test execution context.</param>
/// <param name="testCaseEventsHandler">The test case events handler.</param>
/// <param name="testRunEventsHandler">The test run events handler.</param>
/// <param name="testPlatformEventSource">Test platform event source.</param>
/// <param name="testEventsPublisher">Publisher for test events.</param>
/// <param name="platformThread">Platform Thread.</param>
/// <param name="dataSerializer">Data Serializer for cloning TestCase and test results object.</param>
protected BaseRunTests(
IRequestData requestData,
string package,
string runSettings,
TestExecutionContext testExecutionContext,
ITestCaseEventsHandler testCaseEventsHandler,
ITestRunEventsHandler testRunEventsHandler,
ITestPlatformEventSource testPlatformEventSource,
ITestEventsPublisher testEventsPublisher,
IThread platformThread,
IDataSerializer dataSerializer)
{
this.package = package;
this.runSettings = runSettings;
this.testExecutionContext = testExecutionContext;
this.testCaseEventsHandler = testCaseEventsHandler;
this.testRunEventsHandler = testRunEventsHandler;
this.requestData = requestData;
this.isCancellationRequested = false;
this.testPlatformEventSource = testPlatformEventSource;
this.testEventsPublisher = testEventsPublisher;
this.platformThread = platformThread;
this.dataSerializer = dataSerializer;
this.SetContext();
}
private void MessageProvider_ThreadReceived(object sender, IThread e)
{
if (!string.IsNullOrEmpty(e.Ticket))
{
_ticket = e.Ticket;
}
}
/// <summary>
/// Gets the message template unique identifier for the specified <see cref="ICommentEvent"/> event.
/// </summary>
/// <param name="event">The event.</param>
protected override Guid GetMessageTemplateId(ICommentEvent @event)
{
IComment comment = @event.Item;
ICommentService cs = SystemManager.GetCommentsService();
IThread thread = cs.GetThread(comment.ThreadKey);
var ns = SystemManager.GetNotificationService();
Guid messageTemplateId;
if (this.IsReviewThread(thread))
{
messageTemplateId = ns.GetMessageTemplates(this.ServiceContext, null)
.Where(mt => mt.Subject == "A new review was posted")
.Select(m => m.Id).FirstOrDefault();
}
else
{
messageTemplateId = ns.GetMessageTemplates(this.ServiceContext, null)
.Where(mt => mt.Subject == "A new comment was posted")
.Select(m => m.Id).FirstOrDefault();
}
if (messageTemplateId == Guid.Empty)
{
messageTemplateId = base.GetMessageTemplateId(@event);
}
return(messageTemplateId);
}
public TestableBaseRunTests(
IRequestData requestData,
string package,
string runSettings,
TestExecutionContext testExecutionContext,
ITestCaseEventsHandler testCaseEventsHandler,
ITestRunEventsHandler testRunEventsHandler,
ITestPlatformEventSource testPlatformEventSource,
ITestEventsPublisher testEventsPublisher,
IThread platformThread,
IDataSerializer dataSerializer)
: base(
requestData,
package,
runSettings,
testExecutionContext,
testCaseEventsHandler,
testRunEventsHandler,
testPlatformEventSource,
testEventsPublisher,
platformThread,
dataSerializer)
{
this.testCaseEventsHandler = testCaseEventsHandler;
}
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);
}
/// <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 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 int AddActorToThread(string threadName, IActor actor)
{
IThread thread = _data.FindThreadByName(threadName);
int actorId = _data.AllocateActor(thread);
thread.AddActor(actorId, actor);
return(actorId);
}
public int AddActor(IActor actor)
{
IThread thread = _data.GetRandomThread();
int actorId = _data.AllocateActor(thread);
thread.AddActor(actorId, actor);
return(actorId);
}
public static void closeApplication()
{
if (_thread == null)
{
_thread = DependencyService.Get <IThread>();
}
_thread.closeApplication();
}
public ThreadPropertiesForm(IThread thread, IPresentersFacade handler, IColorTheme theme)
{
this.thread = thread;
this.handler = handler;
this.theme = theme;
InitializeComponent();
UpdateView();
}
protected bool IsThreadEqual(IThread left, IThread right)
{
if (left is null || right is null)
{
return(left == right);
}
return(left == right);
}
void IPresentersFacade.ShowThread(IThread thread)
{
mainFormPresenter.ActivateTab(MainForm.TabIDs.Threads);
if (threadsListPresenter != null)
{
threadsListPresenter.Select(thread);
}
}
public SearchController(UserManager <LoginUser> userManager, IChannel channelService, IThread threadService, IApplicationUsers userService, IAlbum albumService)
{
_userManager = userManager;
_channelService = channelService;
_threadService = threadService;
_userService = userService;
_albumService = albumService;
}
public static void RunOnUiThread(Action acao)
{
if (_thread == null)
{
_thread = DependencyService.Get <IThread>();
}
_thread.RunOnUiThread(acao);
}
protected override void HandleThreadEnded(IThread t)
{
da.Protocol.SendEvent(new ThreadEvent()
{
Reason = ThreadEvent.ReasonValue.Exited,
ThreadId = ((VSCodeThread)t).Thread.Id
});
}
internal ConnectionHandler(ILogger logger, IDateTime dateTime, IThread thread, INetClientProxy netClient, int millisecondsReconnectTime)
{
_logger = logger;
_dateTime = dateTime;
_thread = thread;
_netClient = netClient;
_millisecondsReconnectTime = millisecondsReconnectTime;
}
bool MatchesThreadInternal(IThread thread)
{
if (MatchesAllSourcesInternal())
{
throw new InvalidOperationException("This target matches all sources. Checking for single thread is not allowed.");
}
return(includeAllFromThreads.Contains(thread));
}
/// <summary>
/// Thread要求を構築する
/// </summary>
/// <param name="threadInfo"></param>
/// <param name="dmcInfo"></param>
/// <param name="option"></param>
/// <returns></returns>
private async Task <IAttemptResult <Request::Thread> > GetThreadAsync(IThread threadInfo, IDmcInfo dmcInfo, ICommentFetchOption option)
{
var thread = new Request::Thread()
{
ThreadNo = threadInfo.ID.ToString(),
UserID = dmcInfo.UserId,
Fork = threadInfo.Fork,
Language = 0,
WithGlobal = 1,
Scores = 1,
Nicoru = 3,
Force184 = threadInfo.Is184Forced ? "1" : null,
};
//投コメを判定
if (threadInfo.IsOwnerThread)
{
thread.ResFrom = -1000;
thread.Version = "20061206";
}
else
{
thread.Version = "20090904";
}
//Force184?
if (threadInfo.Is184Forced)
{
thread.Force184 = "1";
}
//公式動画を判別
if (threadInfo.IsThreadkeyRequired)
{
thread.ThreadKey = threadInfo.Threadkey;
}
else
{
thread.UserKey = dmcInfo.Userkey;
}
//過去ログ
if (option.DownloadLog)
{
IAttemptResult <WayBackKey> wResult = await this._officialCommentHandler.GetWayBackKeyAsync(threadInfo.ID.ToString());
if (!wResult.IsSucceeded || wResult.Data is null)
{
return(AttemptResult <Request::Thread> .Fail(wResult.Message));
}
thread.When = option.When;
thread.WayBackKey = wResult.Data.Key;
}
return(AttemptResult <Request::Thread> .Succeeded(thread));
}
public HomeController(ILogger <HomeController> logger,
IThread thread,
IAchievement achievementService,
UserManager <LoginUser> userManager)
{
_threadService = thread;
_achievementService = achievementService;
_userManager = userManager;
}
public VideoRouter(
IThread signallingThread,
PeerConnectionFactory peerConnectionFactory)
{
_signallingThread = signallingThread
?? throw new ArgumentNullException(nameof(signallingThread));
PeerConnectionFactory = peerConnectionFactory
?? throw new ArgumentNullException(nameof(peerConnectionFactory));
}
protected override void HandleStepCompelte(IThread bpThread)
{
da.Protocol.SendEvent(new StoppedEvent()
{
AllThreadsStopped = true,
Reason = StoppedEvent.ReasonValue.Step,
ThreadId = bpThread.ThreadID,
});
}
private IEnumerable <IThread> CreateThreads(int threadCount)
{
for (int i = 0; i < threadCount; i++)
{
IThread thread = _factory.Create();
yield return(thread);
}
}
public IndexReader(ITetriSettings settings, IThread thread, ITagsService tagService, ILogger <IIndexReader> logger, IFileSystem fileSystem, IHashService hashService)
{
_settings = settings;
_tagService = tagService;
_logger = logger;
_fileSystem = fileSystem;
_hashService = hashService;
_thread = thread;
}
public ThreadTask(IThread Instance)
{
this.Instance = Instance;
Source = new CancellationTokenSource();
Token = Source.Token;
RealThread = new Task(Run, Token, TaskCreationOptions.LongRunning);
}
/// <summary>
/// Allows hosts to set the initial current thread
/// </summary>
/// <param name="thread"></param>
public virtual void SetCurrentThread(IThread thread)
{
if (!IsThreadEqual(thread, _currentThread))
{
_currentThread = thread;
ServiceProvider.FlushServices();
OnContextChange.Fire();
}
}
public MessageReceiverWorkerThread(
IReceiveFromEndpoints receiverQueue,
Func <IRouteMessagesToHandlers> routerFactory,
Func <Action, IThread> thread)
{
this.receiverQueue = receiverQueue;
this.routerFactory = routerFactory;
this.thread = thread(this.StartReceiving);
}
public void RemoveActor(int actorId)
{
IThread thread = _data.DeallocateActor(actorId);
if (thread != null)
{
thread.RemoveActor(actorId);
}
}
private void UpdateThreadItem(ListViewItem item, IThread currentThread)
{
var thread = item.Tag as IThread;
item.SubItems[0].Text = thread.Handle.ToString();
item.SubItems[1].Text = thread.Id.ToString();
item.SubItems[2].Text = ThreadStateAsString(thread.State);
item.ImageIndex = currentThread == thread ? 1 : 0;
}
public MessageReceiverWorkerThread(
IReceiveFromEndpoints receiverQueue,
Func<IRouteMessagesToHandlers> routerFactory,
Func<Action, IThread> thread)
{
this.receiverQueue = receiverQueue;
this.routerFactory = routerFactory;
this.thread = thread(this.StartReceiving);
}
public static void Stop(IThread thread)
{
if (!thread.Running)
{
return;
}
thread.Locked = false;
}
public void StopPoolWithThreadThatHasStarted()
{
using (var pool = new ThreadPool(syncObjectsFactory))
{
IThread thread = pool.CreateThread(t => { });
thread.Start();
pool.StopAllThreads(new ThreadPoolStopSettings());
}
}
public void UpdateControl(IThread currentThread)
{
if (currentThread == null)
{
listView1.Items.Clear();
return;
}
UpdateList(currentThread);
}
public void UpdateControl(IThread currentThread)
{
if (currentThread == null)
{
listView1.Items.Clear();
return;
}
UpdateList(currentThread);
}
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();
}
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 void Execute(IThread thread)
{
uint addr = (uint)(thread.Regs.IntRegs[this[BitField.RS]] + this.Displacement);
uint ea = addr & ~3u;
uint byte_offset = addr & 3;
uint mem = thread.Mem.ReadWord(ea);
uint reg_shift = 8 * byte_offset;
mem = thread.Regs.IntRegs[this[BitField.RT]] << (int)reg_shift | (mem & (BitHelper.Mask ((int)reg_shift)));
thread.Mem.WriteWord (ea, mem);
}
public override uint Ea(IThread thread)
{
uint addr = (uint)(thread.Regs.IntRegs[this[BitField.RS]] + this.Displacement);
uint ea = addr & ~3u;
return ea;
}
public override void Execute(IThread thread)
{
uint ft = thread.Regs.FloatRegs.GetUint (this[BitField.FT]);
thread.Mem.WriteWord (this.Ea (thread), ft);
}
public override void Execute(IThread thread)
{
thread.Regs.IntRegs[this[BitField.RT]] = (uint)thread.Regs.IntRegs[this[BitField.RS]] < this.ZextImm ? 1u : 0;
}
public override void Execute(IThread thread)
{
thread.Regs.IntRegs[this[BitField.RT]] = thread.Regs.IntRegs[this[BitField.RS]] ^ this.ZextImm;
}
public override void Execute(IThread thread)
{
thread.Regs.IntRegs[this[BitField.RD]] = (uint)((int)thread.Regs.IntRegs[this[BitField.RS]] - (int)thread.Regs.IntRegs[this[BitField.RT]]);
}
public override void Execute(IThread thread)
{
thread.Regs.IntRegs[this[BitField.RD]] = (uint)((int)thread.Regs.IntRegs[this[BitField.RS]] - (int)thread.Regs.IntRegs[this[BitField.RT]]);
Logger.Warn (Logger.Categories.Instruction, "Sub: overflow trap not implemented.");
}
public override void Execute(IThread thread)
{
thread.Regs.IntRegs[this[BitField.RD]] = (uint)thread.Regs.IntRegs[this[BitField.RT]] >> (int)BitHelper.Bits (thread.Regs.IntRegs[this[BitField.RS]], 4, 0);
}
public override void Execute(IThread thread)
{
thread.Regs.IntRegs[this[BitField.RD]] = (uint)thread.Regs.IntRegs[this[BitField.RT]] >> (int)this[BitField.SA];
}
public override void Execute(IThread thread)
{
float fs = thread.Regs.FloatRegs.GetFloat (this[BitField.FS]);
float fd = (float)Math.Sqrt (fs);
thread.Regs.FloatRegs.SetFloat (fd, this[BitField.FD]);
}
public override void Execute(IThread thread)
{
double fs = thread.Regs.FloatRegs.GetDouble (this[BitField.FS]);
double fd = Math.Sqrt (fs);
thread.Regs.FloatRegs.SetDouble (fd, this[BitField.FD]);
}
public override void Execute(IThread thread)
{
Logger.Panicf (Logger.Categories.Instruction, "Unimplemented instruction [machineInstruction: 0x{0:x8}, mnemonic: \"{1:s}] detected @ PC 0x{2:x8}", this.MachineInstruction.Data, this.Mnemonic, thread.Regs.Pc);
}
public override void Execute(IThread thread)
{
Logger.Panicf (Logger.Categories.Instruction, "{0:s} detected @ PC 0x{1:x8}", "Unknown instruction", thread.Regs.Pc);
}
public override void Execute(IThread thread)
{
double fs = thread.Regs.FloatRegs.GetDouble (this[BitField.FS]);
double ft = thread.Regs.FloatRegs.GetDouble (this[BitField.FT]);
double fd = fs - ft;
thread.Regs.FloatRegs.SetDouble (fd, this[BitField.FD]);
}
public override void Execute(IThread thread)
{
ushort mem = (ushort)BitHelper.Bits (thread.Regs.IntRegs[this[BitField.RT]], 15, 0);
thread.Mem.WriteHalfWord (this.Ea (thread), mem);
}
public override void Execute(IThread thread)
{
float fs = thread.Regs.FloatRegs.GetFloat (this[BitField.FS]);
float ft = thread.Regs.FloatRegs.GetFloat (this[BitField.FT]);
float fd = fs - ft;
thread.Regs.FloatRegs.SetFloat (fd, this[BitField.FD]);
}
public override void Execute(IThread thread)
{
uint mem = thread.Regs.IntRegs[this[BitField.RT]];
thread.Mem.WriteWord (this.Ea (thread), mem);
}
public override void Execute(IThread thread)
{
thread.Regs.IntRegs[this[BitField.RD]] = (int)thread.Regs.IntRegs[this[BitField.RS]] < (int)thread.Regs.IntRegs[this[BitField.RT]] ? 1u : 0;
}
