Upgrades

Patchwork/src/main/java/me/totalfreedom/data/CommandRegistry.java

@@ -0,0 +1,61 @@
+package me.totalfreedom.data;
+
+import co.aikar.commands.*;
+import me.totalfreedom.base.CommonsBase;
+
+public class CommandRegistry
+{
+    private final PaperCommandManager manager;
+    private final PaperCommandContexts contexts;
+    private final PaperCommandCompletions completions;
+    private final CommandReplacements replacements;
+    private final CommandConditions<BukkitCommandIssuer,
+            BukkitCommandExecutionContext,
+            BukkitConditionContext> conditions;
+
+    public CommandRegistry()
+    {
+        this.manager = new PaperCommandManager(CommonsBase.getInstance());
+        this.contexts = new PaperCommandContexts(manager);
+        this.completions = new PaperCommandCompletions(manager);
+        this.replacements = manager.getCommandReplacements();
+        this.conditions = manager.getCommandConditions();
+    }
+
+    public PaperCommandManager getManager()
+    {
+        return manager;
+    }
+
+    public PaperCommandContexts getContexts()
+    {
+        return contexts;
+    }
+
+    public PaperCommandCompletions getCompletions()
+    {
+        return completions;
+    }
+
+    public CommandReplacements getReplacements()
+    {
+        return replacements;
+    }
+
+    public CommandConditions<BukkitCommandIssuer,
+            BukkitCommandExecutionContext,
+            BukkitConditionContext> getConditions()
+    {
+        return conditions;
+    }
+
+    public void register(BaseCommand cmd)
+    {
+        manager.registerCommand(cmd);
+    }
+
+    public void unregister(BaseCommand cmd)
+    {
+        manager.unregisterCommand(cmd);
+    }
+}

Patchwork/src/main/java/me/totalfreedom/data/ConfigRegistry.java

@@ -0,0 +1,11 @@
+package me.totalfreedom.data;
+
+import me.totalfreedom.config.Configuration;
+
+import java.util.HashSet;
+import java.util.Set;
+
+public class ConfigRegistry
+{
+    Set<Configuration> configurationSet = new HashSet<>();
+}

Patchwork/src/main/java/me/totalfreedom/data/EventRegistry.java

@@ -0,0 +1,39 @@
+package me.totalfreedom.data;
+
+import me.totalfreedom.event.FEvent;
+import me.totalfreedom.provider.EventProvider;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class EventRegistry
+{
+    private final List<FEvent> events;
+
+    public EventRegistry()
+    {
+        this.events = new ArrayList<>();
+    }
+
+    public void register(final FEvent event)
+    {
+        this.events.add(event);
+    }
+
+    public void unregister(final FEvent event)
+    {
+        this.events.remove(event);
+    }
+
+    public <T extends FEvent> EventProvider<T> getEvent(final Class<T> clazz)
+    {
+        for (final FEvent event : this.events)
+        {
+            if (clazz.isInstance(event))
+            {
+                return () -> (T) event;
+            }
+        }
+        return null;
+    }
+}

Patchwork/src/main/java/me/totalfreedom/data/GroupRegistry.java

@@ -0,0 +1,40 @@
+package me.totalfreedom.data;
+
+import me.totalfreedom.security.Group;
+import net.kyori.adventure.text.serializer.plain.PlainTextComponentSerializer;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class GroupRegistry
+{
+    private final List<Group> groups;
+
+    public GroupRegistry()
+    {
+        this.groups = new ArrayList<>();
+    }
+
+    public boolean registerGroup(Group group) {
+        return groups.add(group);
+    }
+
+    public boolean unregisterGroup(Group group) {
+        return groups.remove(group);
+    }
+
+    public Group getGroup(String name) {
+        PlainTextComponentSerializer s = PlainTextComponentSerializer.plainText();
+        for (Group group : groups) {
+            String n = s.serialize(group.getName());
+            if (n.equalsIgnoreCase(name)) {
+                return group;
+            }
+        }
+        return null;
+    }
+
+    public List<Group> getGroups() {
+        return groups;
+    }
+}

Patchwork/src/main/java/me/totalfreedom/data/ModuleRegistry.java

@@ -0,0 +1,44 @@
+package me.totalfreedom.data;
+
+import me.totalfreedom.provider.ModuleProvider;
+import org.bukkit.plugin.java.JavaPlugin;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class ModuleRegistry
+{
+    private final List<JavaPlugin> plugins;
+
+    public ModuleRegistry()
+    {
+        this.plugins = new ArrayList<>();
+    }
+
+    public void addModule(final JavaPlugin plugin)
+    {
+        if (this.plugins.contains(plugin))
+        {
+            return;
+        }
+        this.plugins.add(plugin);
+    }
+
+    public void removeModule(final JavaPlugin plugin) {
+        this.plugins.remove(plugin);
+    }
+
+    @SuppressWarnings("unchecked")
+    public <T extends JavaPlugin> ModuleProvider<T> getModule(Class<T> clazz)
+    {
+        for (JavaPlugin plugin : plugins)
+        {
+            if (clazz.isInstance(plugin))
+            {
+                return () -> (T) plugin;
+            }
+        }
+
+        return () -> null;
+    }
+}

Patchwork/src/main/java/me/totalfreedom/data/ServiceRegistry.java

@@ -0,0 +1,70 @@
+package me.totalfreedom.data;
+
+import me.totalfreedom.service.Service;
+import org.bukkit.Bukkit;
+import org.bukkit.plugin.Plugin;
+import org.bukkit.plugin.RegisteredServiceProvider;
+import org.bukkit.plugin.ServicePriority;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class ServiceRegistry
+{
+    private final List<Service> services;
+
+    public ServiceRegistry()
+    {
+        this.services = new ArrayList<>();
+    }
+
+    public void startAll()
+    {
+        for (Service service : this.services)
+        {
+            service.start();
+        }
+    }
+
+    public void stopAll()
+    {
+        for (Service service : this.services)
+        {
+            service.stop();
+        }
+    }
+
+    @SuppressWarnings("unchecked")
+    // Suppressing is fine here; we know that the service is of type T extends Service,
+    // and calling getClass() on this object would effectively be Class<T>, though we may lose
+    // the identity of the code signature in the process.
+    // In this case, that is fine.
+    public <T extends Service> void register(Plugin plugin, final T service)
+    {
+        this.services.add(service);
+        if (!service.getClass().isInstance(service))
+        {
+            throw new UnknownError("""
+                    A critical issue has been encountered:
+                    The service %s is not an instance of itself.
+                    This is a critical issue and should be reported immediately.
+                    """.formatted(service.getClass().getName()));
+        }
+        Bukkit.getServicesManager().register(
+                (Class<T>) service.getClass(),
+                service,
+                plugin,
+                ServicePriority.Normal);
+    }
+
+    public <T extends Service> RegisteredServiceProvider<T> getService(Class<T> clazz)
+    {
+        return Bukkit.getServicesManager().getRegistration(clazz);
+    }
+
+    public void unregister(Class<? extends Service> clazz, Service service)
+    {
+        this.services.remove(service);
+        Bukkit.getServicesManager().unregister(clazz, service);
+    }
+}

Patchwork/src/main/java/me/totalfreedom/data/UserRegistry.java

@@ -0,0 +1,37 @@
+package me.totalfreedom.data;
+
+import me.totalfreedom.user.User;
+import me.totalfreedom.user.UserData;
+
+import java.util.HashMap;
+import java.util.Map;
+
+public class UserRegistry
+{
+    private final Map<User, UserData> userDataMap;
+
+    public UserRegistry()
+    {
+        this.userDataMap = new HashMap<>();
+    }
+
+    public UserData getUserData(User user)
+    {
+        return userDataMap.get(user);
+    }
+
+    public void registerUserData(User user, UserData userData)
+    {
+        userDataMap.put(user, userData);
+    }
+
+    public void unregisterUserData(User user)
+    {
+        userDataMap.remove(user);
+    }
+
+    public Map<User, UserData> getUserDataMap()
+    {
+        return userDataMap;
+    }
+}