diff --git a/paper-api/src/org/bukkit/plugin/PluginManager.java b/paper-api/src/org/bukkit/plugin/PluginManager.java index 0be6fa5ed9..dbd43ccca7 100644 --- a/paper-api/src/org/bukkit/plugin/PluginManager.java +++ b/paper-api/src/org/bukkit/plugin/PluginManager.java @@ -2,30 +2,11 @@ package org.bukkit.plugin; import java.io.File; -import java.lang.reflect.Constructor; -import java.util.ArrayList; -import java.util.HashMap; -import java.util.List; -import java.util.Map; -import java.util.Set; -import java.util.logging.Level; -import java.util.logging.Logger; -import java.util.regex.Matcher; -import org.bukkit.Server; -import java.util.regex.Pattern; /** * Handles all plugin management from the Server */ -public final class PluginManager { - private final Server server; - private final Map<Pattern, PluginLoader> fileAssociations = new HashMap<Pattern, PluginLoader>(); - private final List<Plugin> plugins = new ArrayList<Plugin>(); - private final Map<String, Plugin> lookupNames = new HashMap<String, Plugin>(); - - public PluginManager(Server instance) { - server = instance; - } +public interface PluginManager { /** * Registers the specified plugin loader @@ -33,56 +14,35 @@ public final class PluginManager { * @param loader Class name of the PluginLoader to register * @throws IllegalArgumentException Thrown when the given Class is not a valid PluginLoader */ - public void RegisterInterface(Class loader) throws IllegalArgumentException { - PluginLoader instance; - - if (PluginLoader.class.isAssignableFrom(loader)) { - Constructor constructor; - try { - constructor = loader.getConstructor(Server.class); - instance = (PluginLoader) constructor.newInstance(server); - } catch (NoSuchMethodException ex) { - throw new IllegalArgumentException(String.format("Class %s does not have a public %s(Server) constructor", loader.getName()), ex); - } catch (Exception ex) { - throw new IllegalArgumentException(String.format("Unexpected exception %s while attempting to construct a new instance of %s", ex.getClass().getName(), loader.getName()), ex); - } - } else { - throw new IllegalArgumentException(String.format("Class %s does not implement interface PluginLoader", loader.getName())); - } - - Pattern[] patterns = instance.getPluginFileFilters(); - - for (Pattern pattern : patterns) { - fileAssociations.put(pattern, instance); - } - } + void RegisterInterface(Class loader) throws IllegalArgumentException; /** - * Loads the plugins contained within the specified directory + * Checks if the given plugin is loaded and returns it when applicable * - * @param directory Directory to check for plugins - * @return A list of all plugins loaded + * Please note that the name of the plugin is case-sensitive + * + * @param name Name of the plugin to check + * @return Plugin if it exists, otherwise null */ - public Plugin[] loadPlugins(File directory) { - List<Plugin> result = new ArrayList<Plugin>(); - File[] files = directory.listFiles(); + Plugin getPlugin(String name); - for (File file : files) { - Plugin plugin = null; + /** + * Checks if the given plugin is enabled or not + * + * Please note that the name of the plugin is case-sensitive. + * + * @param name Name of the plugin to check + * @return true if the plugin is enabled, otherwise false + */ + boolean isPluginEnabled(String name); - try { - plugin = loadPlugin(file); - } catch (InvalidPluginException ex) { - Logger.getLogger(PluginManager.class.getName()).log(Level.SEVERE, "Could not load " + file.getPath() + " in " + directory.getPath(), ex); - } - - if (plugin != null) { - result.add(plugin); - } - } - - return result.toArray(new Plugin[result.size()]); - } + /** + * Checks if the given plugin is enabled or not + * + * @param plugin Plugin to check + * @return true if the plugin is enabled, otherwise false + */ + boolean isPluginEnabled(Plugin plugin); /** * Loads the plugin in the specified file @@ -93,65 +53,13 @@ public final class PluginManager { * @return The Plugin loaded, or null if it was invalid * @throws InvalidPluginException Thrown when the specified file is not a valid plugin */ - public Plugin loadPlugin(File file) throws InvalidPluginException { - Set<Pattern> filters = fileAssociations.keySet(); - Plugin result = null; - - for (Pattern filter : filters) { - String name = file.getName(); - Matcher match = filter.matcher(name); - - if (match.find()) { - PluginLoader loader = fileAssociations.get(filter); - result = loader.loadPlugin(file); - } - } - - if (result != null) { - plugins.add(result); - lookupNames.put(result.getDescription().getName(), result); - } - - return result; - } - - /** - * Checks if the given plugin is loaded and returns it when applicable - * - * Please note that the name of the plugin is case-sensitive - * - * @param name Name of the plugin to check - * @return Plugin if it exists, otherwise null - */ - public Plugin getPlugin(String name) { - return lookupNames.get(name); - } + Plugin loadPlugin(File file) throws InvalidPluginException; /** - * Checks if the given plugin is enabled or not + * Loads the plugins contained within the specified directory * - * Please note that the name of the plugin is case-sensitive. - * - * @param name Name of the plugin to check - * @return true if the plugin is enabled, otherwise false + * @param directory Directory to check for plugins + * @return A list of all plugins loaded */ - public boolean isPluginEnabled(String name) { - Plugin plugin = getPlugin(name); - - return isPluginEnabled(plugin); - } - - /** - * Checks if the given plugin is enabled or not - * - * @param plugin Plugin to check - * @return true if the plugin is enabled, otherwise false - */ - public boolean isPluginEnabled(Plugin plugin) { - if ((plugin != null) && (plugins.contains(plugin))) { - return plugin.isEnabled(); - } else { - return false; - } - } + Plugin[] loadPlugins(File directory); } diff --git a/paper-api/src/org/bukkit/plugin/SimplePluginManager.java b/paper-api/src/org/bukkit/plugin/SimplePluginManager.java new file mode 100644 index 0000000000..01e8c9c366 --- /dev/null +++ b/paper-api/src/org/bukkit/plugin/SimplePluginManager.java @@ -0,0 +1,157 @@ + +package org.bukkit.plugin; + +import java.io.File; +import java.lang.reflect.Constructor; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.Set; +import java.util.logging.Level; +import java.util.logging.Logger; +import java.util.regex.Matcher; +import org.bukkit.Server; +import java.util.regex.Pattern; + +/** + * Handles all plugin management from the Server + */ +public final class SimplePluginManager implements PluginManager { + private final Server server; + private final Map<Pattern, PluginLoader> fileAssociations = new HashMap<Pattern, PluginLoader>(); + private final List<Plugin> plugins = new ArrayList<Plugin>(); + private final Map<String, Plugin> lookupNames = new HashMap<String, Plugin>(); + + public SimplePluginManager(Server instance) { + server = instance; + } + + /** + * Registers the specified plugin loader + * + * @param loader Class name of the PluginLoader to register + * @throws IllegalArgumentException Thrown when the given Class is not a valid PluginLoader + */ + public void RegisterInterface(Class loader) throws IllegalArgumentException { + PluginLoader instance; + + if (PluginLoader.class.isAssignableFrom(loader)) { + Constructor constructor; + try { + constructor = loader.getConstructor(Server.class); + instance = (PluginLoader) constructor.newInstance(server); + } catch (NoSuchMethodException ex) { + throw new IllegalArgumentException(String.format("Class %s does not have a public %s(Server) constructor", loader.getName()), ex); + } catch (Exception ex) { + throw new IllegalArgumentException(String.format("Unexpected exception %s while attempting to construct a new instance of %s", ex.getClass().getName(), loader.getName()), ex); + } + } else { + throw new IllegalArgumentException(String.format("Class %s does not implement interface PluginLoader", loader.getName())); + } + + Pattern[] patterns = instance.getPluginFileFilters(); + + for (Pattern pattern : patterns) { + fileAssociations.put(pattern, instance); + } + } + + /** + * Loads the plugins contained within the specified directory + * + * @param directory Directory to check for plugins + * @return A list of all plugins loaded + */ + public Plugin[] loadPlugins(File directory) { + List<Plugin> result = new ArrayList<Plugin>(); + File[] files = directory.listFiles(); + + for (File file : files) { + Plugin plugin = null; + + try { + plugin = loadPlugin(file); + } catch (InvalidPluginException ex) { + Logger.getLogger(SimplePluginManager.class.getName()).log(Level.SEVERE, "Could not load " + file.getPath() + " in " + directory.getPath(), ex); + } + + if (plugin != null) { + result.add(plugin); + } + } + + return result.toArray(new Plugin[result.size()]); + } + + /** + * Loads the plugin in the specified file + * + * File must be valid according to the current enabled Plugin interfaces + * + * @param file File containing the plugin to load + * @return The Plugin loaded, or null if it was invalid + * @throws InvalidPluginException Thrown when the specified file is not a valid plugin + */ + public Plugin loadPlugin(File file) throws InvalidPluginException { + Set<Pattern> filters = fileAssociations.keySet(); + Plugin result = null; + + for (Pattern filter : filters) { + String name = file.getName(); + Matcher match = filter.matcher(name); + + if (match.find()) { + PluginLoader loader = fileAssociations.get(filter); + result = loader.loadPlugin(file); + } + } + + if (result != null) { + plugins.add(result); + lookupNames.put(result.getDescription().getName(), result); + } + + return result; + } + + /** + * Checks if the given plugin is loaded and returns it when applicable + * + * Please note that the name of the plugin is case-sensitive + * + * @param name Name of the plugin to check + * @return Plugin if it exists, otherwise null + */ + public Plugin getPlugin(String name) { + return lookupNames.get(name); + } + + /** + * Checks if the given plugin is enabled or not + * + * Please note that the name of the plugin is case-sensitive. + * + * @param name Name of the plugin to check + * @return true if the plugin is enabled, otherwise false + */ + public boolean isPluginEnabled(String name) { + Plugin plugin = getPlugin(name); + + return isPluginEnabled(plugin); + } + + /** + * Checks if the given plugin is enabled or not + * + * @param plugin Plugin to check + * @return true if the plugin is enabled, otherwise false + */ + public boolean isPluginEnabled(Plugin plugin) { + if ((plugin != null) && (plugins.contains(plugin))) { + return plugin.isEnabled(); + } else { + return false; + } + } +}