diff options
Diffstat (limited to 'src')
-rw-r--r-- | src/main/java/org/bukkit/plugin/java/JavaPluginLoader.java | 149 | ||||
-rw-r--r-- | src/main/java/org/bukkit/plugin/java/PluginClassLoader.java | 58 |
2 files changed, 172 insertions, 35 deletions
diff --git a/src/main/java/org/bukkit/plugin/java/JavaPluginLoader.java b/src/main/java/org/bukkit/plugin/java/JavaPluginLoader.java index 1c04edfe..c90056d4 100644 --- a/src/main/java/org/bukkit/plugin/java/JavaPluginLoader.java +++ b/src/main/java/org/bukkit/plugin/java/JavaPluginLoader.java @@ -50,13 +50,43 @@ import com.google.common.collect.ImmutableList; * Represents a Java plugin loader, allowing plugins in the form of .jar */ public class JavaPluginLoader implements PluginLoader { - private final Server server; - protected final Pattern[] fileFilters = new Pattern[] { Pattern.compile("\\.jar$"), }; - protected final Map<String, Class<?>> classes = new HashMap<String, Class<?>>(); - protected final Map<String, PluginClassLoader> loaders = new LinkedHashMap<String, PluginClassLoader>(); - + final Server server; + final boolean extended = this.getClass() != JavaPluginLoader.class; + boolean warn; + + private final Pattern[] fileFilters0 = new Pattern[] { Pattern.compile("\\.jar$"), }; + /** + * @deprecated Internal field that wasn't intended to be exposed + */ + @Deprecated + protected final Pattern[] fileFilters = fileFilters0; + + private final Map<String, Class<?>> classes0 = new HashMap<String, Class<?>>(); + /** + * @deprecated Internal field that wasn't intended to be exposed + */ + @Deprecated + protected final Map<String, Class<?>> classes = classes0; + + private final Map<String, PluginClassLoader> loaders0 = new LinkedHashMap<String, PluginClassLoader>(); + /** + * @deprecated Internal field that wasn't intended to be exposed + */ + @Deprecated + protected final Map<String, PluginClassLoader> loaders = loaders0; + + /** + * This class was not meant to be extended + */ + @Deprecated public JavaPluginLoader(Server instance) { + Validate.notNull(instance, "Server cannot be null"); server = instance; + warn = instance.getWarningState() != WarningState.OFF; + if (extended && warn) { + warn = false; + instance.getLogger().log(Level.WARNING, "JavaPluginLoader not intended to be extended by " + getClass() + ", and may be final in a future version of Bukkit"); + } } public Plugin loadPlugin(File file) throws InvalidPluginException { @@ -74,7 +104,7 @@ public class JavaPluginLoader implements PluginLoader { } File dataFolder = new File(file.getParentFile(), description.getName()); - File oldDataFolder = getDataFolder(file); + File oldDataFolder = extended ? getDataFolder(file) : getDataFolder0(file); // Don't warn on deprecation, but maintain overridability // Found old data folder if (dataFolder.equals(oldDataFolder)) { @@ -115,10 +145,10 @@ public class JavaPluginLoader implements PluginLoader { } for (String pluginName : depend) { - if (loaders == null) { + if (loaders0 == null) { throw new UnknownDependencyException(pluginName); } - PluginClassLoader current = loaders.get(pluginName); + PluginClassLoader current = loaders0.get(pluginName); if (current == null) { throw new UnknownDependencyException(pluginName); @@ -134,10 +164,10 @@ public class JavaPluginLoader implements PluginLoader { urls[0] = file.toURI().toURL(); if (description.getClassLoaderOf() != null) { - loader = loaders.get(description.getClassLoaderOf()); + loader = loaders0.get(description.getClassLoaderOf()); loader.addURL(urls[0]); } else { - loader = new PluginClassLoader(this, urls, getClass().getClassLoader()); + loader = new PluginClassLoader(this, urls, getClass().getClassLoader(), null); } Class<?> jarClass = Class.forName(description.getMain(), true, loader); @@ -154,16 +184,36 @@ public class JavaPluginLoader implements PluginLoader { throw new InvalidPluginException(ex); } - loaders.put(description.getName(), loader); + loaders0.put(description.getName(), loader); return result; } + /** + * @deprecated Relic method from PluginLoader that didn't get purged + */ + @Deprecated public Plugin loadPlugin(File file, boolean ignoreSoftDependencies) throws InvalidPluginException { + if (warn) { + server.getLogger().log(Level.WARNING, "Method \"public Plugin loadPlugin(File, boolean)\" is Deprecated, and may be removed in a future version of Bukkit", new AuthorNagException("")); + warn = false; + } return loadPlugin(file); } + /** + * @deprecated Internal method that wasn't intended to be exposed + */ + @Deprecated protected File getDataFolder(File file) { + if (warn) { + server.getLogger().log(Level.WARNING, "Method \"protected File getDataFolder(File)\" is Deprecated, and may be removed in a future version of Bukkit", new AuthorNagException("")); + warn = false; + } + return getDataFolder0(file); + } + + private File getDataFolder0(File file) { File dataFolder = null; String filename = file.getName(); @@ -222,20 +272,32 @@ public class JavaPluginLoader implements PluginLoader { } public Pattern[] getPluginFileFilters() { - return fileFilters; + return fileFilters0.clone(); } + /** + * @deprecated Internal method that wasn't intended to be exposed + */ + @Deprecated public Class<?> getClassByName(final String name) { - Class<?> cachedClass = classes.get(name); + if (warn) { + server.getLogger().log(Level.WARNING, "Method \"public Plugin loadPlugin(File, boolean)\" is Deprecated, and may be removed in a future version of Bukkit", new AuthorNagException("")); + warn = false; + } + return getClassByName0(name); + } + + Class<?> getClassByName0(final String name) { + Class<?> cachedClass = classes0.get(name); if (cachedClass != null) { return cachedClass; } else { - for (String current : loaders.keySet()) { - PluginClassLoader loader = loaders.get(current); + for (String current : loaders0.keySet()) { + PluginClassLoader loader = loaders0.get(current); try { - cachedClass = loader.findClass(name, false); + cachedClass = loader.extended ? loader.findClass(name, false) : loader.findClass0(name, false); // Don't warn on deprecation, but maintain overridability } catch (ClassNotFoundException cnfe) {} if (cachedClass != null) { return cachedClass; @@ -245,9 +307,21 @@ public class JavaPluginLoader implements PluginLoader { return null; } + /** + * @deprecated Internal method that wasn't intended to be exposed + */ + @Deprecated public void setClass(final String name, final Class<?> clazz) { - if (!classes.containsKey(name)) { - classes.put(name, clazz); + if (warn) { + server.getLogger().log(Level.WARNING, "Method \"public Plugin loadPlugin(File, boolean)\" is Deprecated, and may be removed in a future version of Bukkit", new AuthorNagException("")); + warn = false; + } + setClass0(name, clazz); + } + + void setClass0(final String name, final Class<?> clazz) { + if (!classes0.containsKey(name)) { + classes0.put(name, clazz); if (ConfigurationSerializable.class.isAssignableFrom(clazz)) { Class<? extends ConfigurationSerializable> serializable = clazz.asSubclass(ConfigurationSerializable.class); @@ -256,8 +330,20 @@ public class JavaPluginLoader implements PluginLoader { } } + /** + * @deprecated Internal method that wasn't intended to be exposed + */ + @Deprecated public void removeClass(String name) { - Class<?> clazz = classes.remove(name); + if (warn) { + server.getLogger().log(Level.WARNING, "Method \"public void removeClass(String)\" is Deprecated, and may be removed in a future version of Bukkit", new AuthorNagException("")); + warn = false; + } + removeClass0(name); + } + + private void removeClass0(String name) { + Class<?> clazz = classes0.remove(name); try { if ((clazz != null) && (ConfigurationSerializable.class.isAssignableFrom(clazz))) { @@ -354,20 +440,17 @@ public class JavaPluginLoader implements PluginLoader { } public void enablePlugin(final Plugin plugin) { - if (!(plugin instanceof JavaPlugin)) { - throw new IllegalArgumentException("Plugin is not associated with this PluginLoader"); - } + Validate.isTrue(plugin instanceof JavaPlugin, "Plugin is not associated with this PluginLoader"); if (!plugin.isEnabled()) { - String message = String.format("Enabling %s", plugin.getDescription().getFullName()); - plugin.getLogger().info(message); + plugin.getLogger().info("Enabling " + plugin.getDescription().getFullName()); JavaPlugin jPlugin = (JavaPlugin) plugin; String pluginName = jPlugin.getDescription().getName(); - if (!loaders.containsKey(pluginName)) { - loaders.put(pluginName, (PluginClassLoader) jPlugin.getClassLoader()); + if (!loaders0.containsKey(pluginName)) { + loaders0.put(pluginName, (PluginClassLoader) jPlugin.getClassLoader()); } try { @@ -383,9 +466,7 @@ public class JavaPluginLoader implements PluginLoader { } public void disablePlugin(Plugin plugin) { - if (!(plugin instanceof JavaPlugin)) { - throw new IllegalArgumentException("Plugin is not associated with this PluginLoader"); - } + Validate.isTrue(plugin instanceof JavaPlugin, "Plugin is not associated with this PluginLoader"); if (plugin.isEnabled()) { String message = String.format("Disabling %s", plugin.getDescription().getFullName()); @@ -402,14 +483,18 @@ public class JavaPluginLoader implements PluginLoader { server.getLogger().log(Level.SEVERE, "Error occurred while disabling " + plugin.getDescription().getFullName() + " (Is it up to date?)", ex); } - loaders.remove(jPlugin.getDescription().getName()); + loaders0.remove(jPlugin.getDescription().getName()); if (cloader instanceof PluginClassLoader) { PluginClassLoader loader = (PluginClassLoader) cloader; - Set<String> names = loader.getClasses(); + Set<String> names = loader.extended ? loader.getClasses() : loader.getClasses0(); // Don't warn on deprecation, but maintain overridability for (String name : names) { - removeClass(name); + if (extended) { + removeClass(name); + } else { + removeClass0(name); + } } } } diff --git a/src/main/java/org/bukkit/plugin/java/PluginClassLoader.java b/src/main/java/org/bukkit/plugin/java/PluginClassLoader.java index 3e26e755..29ec3fc4 100644 --- a/src/main/java/org/bukkit/plugin/java/PluginClassLoader.java +++ b/src/main/java/org/bukkit/plugin/java/PluginClassLoader.java @@ -5,6 +5,10 @@ import java.net.URLClassLoader; import java.util.HashMap; import java.util.Map; import java.util.Set; +import java.util.logging.Level; + +import org.apache.commons.lang.Validate; +import org.bukkit.plugin.AuthorNagException; /** * A ClassLoader for plugins, to allow shared classes across multiple plugins @@ -12,9 +16,29 @@ import java.util.Set; public class PluginClassLoader extends URLClassLoader { private final JavaPluginLoader loader; private final Map<String, Class<?>> classes = new HashMap<String, Class<?>>(); + final boolean extended = this.getClass() != PluginClassLoader.class; + /** + * Internal class not intended to be exposed + */ + @Deprecated public PluginClassLoader(final JavaPluginLoader loader, final URL[] urls, final ClassLoader parent) { + this(loader, urls, parent, null); + + if (loader.warn) { + if (extended) { + loader.server.getLogger().log(Level.WARNING, "PluginClassLoader not intended to be extended by " + getClass() + ", and may be final in a future version of Bukkit"); + } else { + loader.server.getLogger().log(Level.WARNING, "Constructor \"public PluginClassLoader(JavaPluginLoader, URL[], ClassLoader)\" is Deprecated, and may be removed in a future version of Bukkit", new AuthorNagException("")); + } + loader.warn = false; + } + } + + + PluginClassLoader(final JavaPluginLoader loader, final URL[] urls, final ClassLoader parent, final Object methodSignature) { super(urls, parent); + Validate.notNull(loader, "Loader cannot be null"); this.loader = loader; } @@ -26,10 +50,22 @@ public class PluginClassLoader extends URLClassLoader { @Override protected Class<?> findClass(String name) throws ClassNotFoundException { - return findClass(name, true); + return extended ? findClass(name, true) : findClass0(name, true); // Don't warn on deprecation, but maintain overridability } + /** + * @deprecated Internal method that wasn't intended to be exposed + */ + @Deprecated protected Class<?> findClass(String name, boolean checkGlobal) throws ClassNotFoundException { + if (loader.warn) { + loader.server.getLogger().log(Level.WARNING, "Method \"protected Class<?> findClass(String, boolean)\" is Deprecated, and may be removed in a future version of Bukkit", new AuthorNagException("")); + loader.warn = false; + } + return findClass0(name, checkGlobal); + } + + Class<?> findClass0(String name, boolean checkGlobal) throws ClassNotFoundException { if (name.startsWith("org.bukkit.") || name.startsWith("net.minecraft.")) { throw new ClassNotFoundException(name); } @@ -37,14 +73,18 @@ public class PluginClassLoader extends URLClassLoader { if (result == null) { if (checkGlobal) { - result = loader.getClassByName(name); + result = loader.extended ? loader.getClassByName(name) : loader.getClassByName0(name); // Don't warn on deprecation, but maintain overridability } if (result == null) { result = super.findClass(name); if (result != null) { - loader.setClass(name, result); + if (loader.extended) { // Don't warn on deprecation, but maintain overridability + loader.setClass(name, result); + } else { + loader.setClass0(name, result); + } } } @@ -54,7 +94,19 @@ public class PluginClassLoader extends URLClassLoader { return result; } + /** + * @deprecated Internal method that wasn't intended to be exposed + */ + @Deprecated public Set<String> getClasses() { + if (loader.warn) { + loader.server.getLogger().log(Level.WARNING, "Method \"public Set<String> getClasses()\" is Deprecated, and may be removed in a future version of Bukkit", new AuthorNagException("")); + loader.warn = false; + } + return getClasses0(); + } + + Set<String> getClasses0() { return classes.keySet(); } } |