Initial commit

Processing/IPC/InterProcessCommunicator.cs

@@ -0,0 +1,23 @@
+using System;
+using RemSox.Processing;
+
+namespace RemSox.Processing.IPC;
+
+internal static class InterProcessCommunicator
+{
+    public static void Send(int targetProcessId, Message message, Process sender)
+    {
+        message.SenderProcessId = sender.Id; // automatically set
+        ProcessManager.GetProcess(targetProcessId)?.HandleInterProcessMessage(message);
+    }
+
+    public static void SendToAll(Message message, Process sender)
+    {
+        message.SenderProcessId = sender.Id; // automatically set
+
+        foreach (var process in ProcessManager.GetAllProcesses())
+        {
+            process.HandleInterProcessMessage(message);
+        }
+    }
+}

Processing/IPC/Message.cs

@@ -0,0 +1,8 @@
+using System;
+
+namespace RemSox.Processing.IPC;
+
+public abstract class Message
+{
+    public int SenderProcessId { get; internal set; }
+}

Processing/Process.cs

@@ -0,0 +1,34 @@
+using System;
+using RemSox.Processing.IPC;
+
+namespace RemSox.Processing;
+
+public abstract class Process(string name)
+{
+    public int Id { get; init; }
+
+    public string Name { get; set; } = name;
+
+    public bool StopRequested { get; private set; } = false;
+
+    internal abstract void Run();
+
+    internal virtual void HandleInterProcessMessage(Message message)
+    {
+    }
+
+    protected void SendMessageToProcess(int targetProcessId, Message message)
+    {
+        InterProcessCommunicator.Send(targetProcessId, message, this);
+    }
+
+    protected void SendMessageToAllProcesses(Message message)
+    {
+        InterProcessCommunicator.SendToAll(message, this);
+    }
+
+    internal void RequestStop()
+    {
+        StopRequested = true;
+    }
+}

Processing/ProcessManager.cs

@@ -0,0 +1,83 @@
+using System;
+
+namespace RemSox.Processing;
+
+public static class ProcessManager
+{
+    private static readonly Dictionary<int, (Process Process, Thread Thread)> processes = [];
+
+    private static int nextProcessId = 0;
+
+    public static int SpawnProcess<T>() where T : Process, new()
+    {
+        int id = GetNextProcessId();
+
+        T process = new()
+        {
+            Id = id
+        };
+
+        Thread thread = new(process.Run);
+
+        processes.Add(id, (process, thread));
+
+        thread.Start();
+
+        return id;
+    }
+
+    public static void StopProcess(int processId)
+    {
+        if (!processes.TryGetValue(processId, out var entry))
+            return;
+
+        entry.Process.RequestStop();
+
+        processes.Remove(processId);
+    }
+
+    public static void StopAllProcesses()
+    {
+        foreach (var entry in processes.Values)
+        {
+            entry.Process.RequestStop();
+        }
+
+        processes.Clear();
+    }
+
+    public static Process? GetProcess(int processId)
+    {
+        if (processes.TryGetValue(processId, out var entry))
+        {
+            return entry.Process;
+        }
+
+        return null;
+    }
+
+    public static IEnumerable<Process> GetAllProcesses()
+    {
+        foreach (var entry in processes.Values)
+        {
+            yield return entry.Process;
+        }
+    }
+
+    public static bool TryGetProcess(int processId, out Process? process)
+    {
+        if (processes.TryGetValue(processId, out var entry))
+        {
+            process = entry.Process;
+            return true;
+        }
+
+        process = null;
+        return false;
+    }
+
+    private static int GetNextProcessId()
+    {
+        return nextProcessId++;
+    }
+}