+ * If no source {@link Configuration} was provided as a default
+ * collection, then a new {@link MemoryConfiguration} will be created to
+ * hold the new default value.
+ *
+ * If value is null, the value will be removed from the default
+ * Configuration source.
+ *
+ * @param path Path of the value to set.
+ * @param value Value to set the default to.
+ * @throws IllegalArgumentException Thrown if path is null.
+ */
+ @Override
+ public void addDefault(@NotNull String path, @Nullable Object value);
+
+ /**
+ * Sets the default values of the given paths as provided.
+ *
+ * If no source {@link Configuration} was provided as a default
+ * collection, then a new {@link MemoryConfiguration} will be created to
+ * hold the new default values.
+ *
+ * @param defaults A map of Path{@literal ->}Values to add to defaults.
+ * @throws IllegalArgumentException Thrown if defaults is null.
+ */
+ public void addDefaults(@NotNull Map defaults);
+
+ /**
+ * Sets the default values of the given paths as provided.
+ *
+ * If no source {@link Configuration} was provided as a default
+ * collection, then a new {@link MemoryConfiguration} will be created to
+ * hold the new default value.
+ *
+ * This method will not hold a reference to the specified Configuration,
+ * nor will it automatically update if that Configuration ever changes. If
+ * you require this, you should set the default source with {@link
+ * #setDefaults(org.bukkit.configuration.Configuration)}.
+ *
+ * @param defaults A configuration holding a list of defaults to copy.
+ * @throws IllegalArgumentException Thrown if defaults is null or this.
+ */
+ public void addDefaults(@NotNull Configuration defaults);
+
+ /**
+ * Sets the source of all default values for this {@link Configuration}.
+ *
+ * If a previous source was set, or previous default values were defined,
+ * then they will not be copied to the new source.
+ *
+ * @param defaults New source of default values for this configuration.
+ * @throws IllegalArgumentException Thrown if defaults is null or this.
+ */
+ public void setDefaults(@NotNull Configuration defaults);
+
+ /**
+ * Gets the source {@link Configuration} for this configuration.
+ *
+ * If no configuration source was set, but default values were added, then
+ * a {@link MemoryConfiguration} will be returned. If no source was set
+ * and no defaults were set, then this method will return null.
+ *
+ * @return Configuration source for default values, or null if none exist.
+ */
+ @Nullable
+ public Configuration getDefaults();
+
+ /**
+ * Gets the {@link ConfigurationOptions} for this {@link Configuration}.
+ *
+ * All setters through this method are chainable.
+ *
+ * @return Options for this configuration
+ */
+ @NotNull
+ public ConfigurationOptions options();
+}
diff --git a/src/main/java/org/bukkit/configuration/ConfigurationOptions.java b/src/main/java/org/bukkit/configuration/ConfigurationOptions.java
new file mode 100644
index 0000000..356bad6
--- /dev/null
+++ b/src/main/java/org/bukkit/configuration/ConfigurationOptions.java
@@ -0,0 +1,95 @@
+package org.bukkit.configuration;
+
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * Various settings for controlling the input and output of a {@link
+ * Configuration}
+ */
+public class ConfigurationOptions {
+ private char pathSeparator = '.';
+ private boolean copyDefaults = false;
+ private final Configuration configuration;
+
+ protected ConfigurationOptions(@NotNull Configuration configuration) {
+ this.configuration = configuration;
+ }
+
+ /**
+ * Returns the {@link Configuration} that this object is responsible for.
+ *
+ * @return Parent configuration
+ */
+ @NotNull
+ public Configuration configuration() {
+ return configuration;
+ }
+
+ /**
+ * Gets the char that will be used to separate {@link
+ * ConfigurationSection}s
+ *
+ * This value does not affect how the {@link Configuration} is stored,
+ * only in how you access the data. The default value is '.'.
+ *
+ * @return Path separator
+ */
+ public char pathSeparator() {
+ return pathSeparator;
+ }
+
+ /**
+ * Sets the char that will be used to separate {@link
+ * ConfigurationSection}s
+ *
+ * This value does not affect how the {@link Configuration} is stored,
+ * only in how you access the data. The default value is '.'.
+ *
+ * @param value Path separator
+ * @return This object, for chaining
+ */
+ @NotNull
+ public ConfigurationOptions pathSeparator(char value) {
+ this.pathSeparator = value;
+ return this;
+ }
+
+ /**
+ * Checks if the {@link Configuration} should copy values from its default
+ * {@link Configuration} directly.
+ *
+ * If this is true, all values in the default Configuration will be
+ * directly copied, making it impossible to distinguish between values
+ * that were set and values that are provided by default. As a result,
+ * {@link ConfigurationSection#contains(java.lang.String)} will always
+ * return the same value as {@link
+ * ConfigurationSection#isSet(java.lang.String)}. The default value is
+ * false.
+ *
+ * @return Whether or not defaults are directly copied
+ */
+ public boolean copyDefaults() {
+ return copyDefaults;
+ }
+
+ /**
+ * Sets if the {@link Configuration} should copy values from its default
+ * {@link Configuration} directly.
+ *
+ * If this is true, all values in the default Configuration will be
+ * directly copied, making it impossible to distinguish between values
+ * that were set and values that are provided by default. As a result,
+ * {@link ConfigurationSection#contains(java.lang.String)} will always
+ * return the same value as {@link
+ * ConfigurationSection#isSet(java.lang.String)}. The default value is
+ * false.
+ *
+ * @param value Whether or not defaults are directly copied
+ * @return This object, for chaining
+ */
+ @NotNull
+ public ConfigurationOptions copyDefaults(boolean value) {
+ this.copyDefaults = value;
+ return this;
+ }
+}
diff --git a/src/main/java/org/bukkit/configuration/ConfigurationSection.java b/src/main/java/org/bukkit/configuration/ConfigurationSection.java
new file mode 100644
index 0000000..28c4185
--- /dev/null
+++ b/src/main/java/org/bukkit/configuration/ConfigurationSection.java
@@ -0,0 +1,829 @@
+package org.bukkit.configuration;
+
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import org.bukkit.configuration.serialization.ConfigurationSerializable;
+import org.jetbrains.annotations.Contract;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+/**
+ * Represents a section of a {@link Configuration}
+ */
+public interface ConfigurationSection {
+ /**
+ * Gets a set containing all keys in this section.
+ *
+ * If deep is set to true, then this will contain all the keys within any
+ * child {@link ConfigurationSection}s (and their children, etc). These
+ * will be in a valid path notation for you to use.
+ *
+ * If deep is set to false, then this will contain only the keys of any
+ * direct children, and not their own children.
+ *
+ * @param deep Whether or not to get a deep list, as opposed to a shallow
+ * list.
+ * @return Set of keys contained within this ConfigurationSection.
+ */
+ @NotNull
+ public Set getKeys(boolean deep);
+
+ /**
+ * Gets a Map containing all keys and their values for this section.
+ *
+ * If deep is set to true, then this will contain all the keys and values
+ * within any child {@link ConfigurationSection}s (and their children,
+ * etc). These keys will be in a valid path notation for you to use.
+ *
+ * If deep is set to false, then this will contain only the keys and
+ * values of any direct children, and not their own children.
+ *
+ * @param deep Whether or not to get a deep list, as opposed to a shallow
+ * list.
+ * @return Map of keys and values of this section.
+ */
+ @NotNull
+ public Map getValues(boolean deep);
+
+ /**
+ * Checks if this {@link ConfigurationSection} contains the given path.
+ *
+ * If the value for the requested path does not exist but a default value
+ * has been specified, this will return true.
+ *
+ * @param path Path to check for existence.
+ * @return True if this section contains the requested path, either via
+ * default or being set.
+ * @throws IllegalArgumentException Thrown when path is null.
+ */
+ public boolean contains(@NotNull String path);
+
+ /**
+ * Checks if this {@link ConfigurationSection} contains the given path.
+ *
+ * If the value for the requested path does not exist, the boolean parameter
+ * of true has been specified, a default value for the path exists, this
+ * will return true.
+ *
+ * If a boolean parameter of false has been specified, true will only be
+ * returned if there is a set value for the specified path.
+ *
+ * @param path Path to check for existence.
+ * @param ignoreDefault Whether or not to ignore if a default value for the
+ * specified path exists.
+ * @return True if this section contains the requested path, or if a default
+ * value exist and the boolean parameter for this method is true.
+ * @throws IllegalArgumentException Thrown when path is null.
+ */
+ public boolean contains(@NotNull String path, boolean ignoreDefault);
+
+ /**
+ * Checks if this {@link ConfigurationSection} has a value set for the
+ * given path.
+ *
+ * If the value for the requested path does not exist but a default value
+ * has been specified, this will still return false.
+ *
+ * @param path Path to check for existence.
+ * @return True if this section contains the requested path, regardless of
+ * having a default.
+ * @throws IllegalArgumentException Thrown when path is null.
+ */
+ public boolean isSet(@NotNull String path);
+
+ /**
+ * Gets the path of this {@link ConfigurationSection} from its root {@link
+ * Configuration}
+ *
+ * For any {@link Configuration} themselves, this will return an empty
+ * string.
+ *
+ * If the section is no longer contained within its root for any reason,
+ * such as being replaced with a different value, this may return null.
+ *
+ * To retrieve the single name of this section, that is, the final part of
+ * the path returned by this method, you may use {@link #getName()}.
+ *
+ * @return Path of this section relative to its root
+ */
+ @Nullable
+ public String getCurrentPath();
+
+ /**
+ * Gets the name of this individual {@link ConfigurationSection}, in the
+ * path.
+ *
+ * This will always be the final part of {@link #getCurrentPath()}, unless
+ * the section is orphaned.
+ *
+ * @return Name of this section
+ */
+ @NotNull
+ public String getName();
+
+ /**
+ * Gets the root {@link Configuration} that contains this {@link
+ * ConfigurationSection}
+ *
+ * For any {@link Configuration} themselves, this will return its own
+ * object.
+ *
+ * If the section is no longer contained within its root for any reason,
+ * such as being replaced with a different value, this may return null.
+ *
+ * @return Root configuration containing this section.
+ */
+ @Nullable
+ public Configuration getRoot();
+
+ /**
+ * Gets the parent {@link ConfigurationSection} that directly contains
+ * this {@link ConfigurationSection}.
+ *
+ * For any {@link Configuration} themselves, this will return null.
+ *
+ * If the section is no longer contained within its parent for any reason,
+ * such as being replaced with a different value, this may return null.
+ *
+ * @return Parent section containing this section.
+ */
+ @Nullable
+ public ConfigurationSection getParent();
+
+ /**
+ * Gets the requested Object by path.
+ *
+ * If the Object does not exist but a default value has been specified,
+ * this will return the default value. If the Object does not exist and no
+ * default value was specified, this will return null.
+ *
+ * @param path Path of the Object to get.
+ * @return Requested Object.
+ */
+ @Nullable
+ public Object get(@NotNull String path);
+
+ /**
+ * Gets the requested Object by path, returning a default value if not
+ * found.
+ *
+ * If the Object does not exist then the specified default value will
+ * returned regardless of if a default has been identified in the root
+ * {@link Configuration}.
+ *
+ * @param path Path of the Object to get.
+ * @param def The default value to return if the path is not found.
+ * @return Requested Object.
+ */
+ @Contract("_, !null -> !null")
+ @Nullable
+ public Object get(@NotNull String path, @Nullable Object def);
+
+ /**
+ * Sets the specified path to the given value.
+ *
+ * If value is null, the entry will be removed. Any existing entry will be
+ * replaced, regardless of what the new value is.
+ *
+ * Some implementations may have limitations on what you may store. See
+ * their individual javadocs for details. No implementations should allow
+ * you to store {@link Configuration}s or {@link ConfigurationSection}s,
+ * please use {@link #createSection(java.lang.String)} for that.
+ *
+ * @param path Path of the object to set.
+ * @param value New value to set the path to.
+ */
+ public void set(@NotNull String path, @Nullable Object value);
+
+ /**
+ * Creates an empty {@link ConfigurationSection} at the specified path.
+ *
+ * Any value that was previously set at this path will be overwritten. If
+ * the previous value was itself a {@link ConfigurationSection}, it will
+ * be orphaned.
+ *
+ * @param path Path to create the section at.
+ * @return Newly created section
+ */
+ @NotNull
+ public ConfigurationSection createSection(@NotNull String path);
+
+ /**
+ * Creates a {@link ConfigurationSection} at the specified path, with
+ * specified values.
+ *
+ * Any value that was previously set at this path will be overwritten. If
+ * the previous value was itself a {@link ConfigurationSection}, it will
+ * be orphaned.
+ *
+ * @param path Path to create the section at.
+ * @param map The values to used.
+ * @return Newly created section
+ */
+ @NotNull
+ public ConfigurationSection createSection(@NotNull String path, @NotNull Map map);
+
+ // Primitives
+ /**
+ * Gets the requested String by path.
+ *
+ * If the String does not exist but a default value has been specified,
+ * this will return the default value. If the String does not exist and no
+ * default value was specified, this will return null.
+ *
+ * @param path Path of the String to get.
+ * @return Requested String.
+ */
+ @Nullable
+ public String getString(@NotNull String path);
+
+ /**
+ * Gets the requested String by path, returning a default value if not
+ * found.
+ *
+ * If the String does not exist then the specified default value will
+ * returned regardless of if a default has been identified in the root
+ * {@link Configuration}.
+ *
+ * @param path Path of the String to get.
+ * @param def The default value to return if the path is not found or is
+ * not a String.
+ * @return Requested String.
+ */
+ @Contract("_, !null -> !null")
+ @Nullable
+ public String getString(@NotNull String path, @Nullable String def);
+
+ /**
+ * Checks if the specified path is a String.
+ *
+ * If the path exists but is not a String, this will return false. If the
+ * path does not exist, this will return false. If the path does not exist
+ * but a default value has been specified, this will check if that default
+ * value is a String and return appropriately.
+ *
+ * @param path Path of the String to check.
+ * @return Whether or not the specified path is a String.
+ */
+ public boolean isString(@NotNull String path);
+
+ /**
+ * Gets the requested int by path.
+ *
+ * If the int does not exist but a default value has been specified, this
+ * will return the default value. If the int does not exist and no default
+ * value was specified, this will return 0.
+ *
+ * @param path Path of the int to get.
+ * @return Requested int.
+ */
+ public int getInt(@NotNull String path);
+
+ /**
+ * Gets the requested int by path, returning a default value if not found.
+ *
+ * If the int does not exist then the specified default value will
+ * returned regardless of if a default has been identified in the root
+ * {@link Configuration}.
+ *
+ * @param path Path of the int to get.
+ * @param def The default value to return if the path is not found or is
+ * not an int.
+ * @return Requested int.
+ */
+ public int getInt(@NotNull String path, int def);
+
+ /**
+ * Checks if the specified path is an int.
+ *
+ * If the path exists but is not a int, this will return false. If the
+ * path does not exist, this will return false. If the path does not exist
+ * but a default value has been specified, this will check if that default
+ * value is a int and return appropriately.
+ *
+ * @param path Path of the int to check.
+ * @return Whether or not the specified path is an int.
+ */
+ public boolean isInt(@NotNull String path);
+
+ /**
+ * Gets the requested boolean by path.
+ *
+ * If the boolean does not exist but a default value has been specified,
+ * this will return the default value. If the boolean does not exist and
+ * no default value was specified, this will return false.
+ *
+ * @param path Path of the boolean to get.
+ * @return Requested boolean.
+ */
+ public boolean getBoolean(@NotNull String path);
+
+ /**
+ * Gets the requested boolean by path, returning a default value if not
+ * found.
+ *
+ * If the boolean does not exist then the specified default value will
+ * returned regardless of if a default has been identified in the root
+ * {@link Configuration}.
+ *
+ * @param path Path of the boolean to get.
+ * @param def The default value to return if the path is not found or is
+ * not a boolean.
+ * @return Requested boolean.
+ */
+ public boolean getBoolean(@NotNull String path, boolean def);
+
+ /**
+ * Checks if the specified path is a boolean.
+ *
+ * If the path exists but is not a boolean, this will return false. If the
+ * path does not exist, this will return false. If the path does not exist
+ * but a default value has been specified, this will check if that default
+ * value is a boolean and return appropriately.
+ *
+ * @param path Path of the boolean to check.
+ * @return Whether or not the specified path is a boolean.
+ */
+ public boolean isBoolean(@NotNull String path);
+
+ /**
+ * Gets the requested double by path.
+ *
+ * If the double does not exist but a default value has been specified,
+ * this will return the default value. If the double does not exist and no
+ * default value was specified, this will return 0.
+ *
+ * @param path Path of the double to get.
+ * @return Requested double.
+ */
+ public double getDouble(@NotNull String path);
+
+ /**
+ * Gets the requested double by path, returning a default value if not
+ * found.
+ *
+ * If the double does not exist then the specified default value will
+ * returned regardless of if a default has been identified in the root
+ * {@link Configuration}.
+ *
+ * @param path Path of the double to get.
+ * @param def The default value to return if the path is not found or is
+ * not a double.
+ * @return Requested double.
+ */
+ public double getDouble(@NotNull String path, double def);
+
+ /**
+ * Checks if the specified path is a double.
+ *
+ * If the path exists but is not a double, this will return false. If the
+ * path does not exist, this will return false. If the path does not exist
+ * but a default value has been specified, this will check if that default
+ * value is a double and return appropriately.
+ *
+ * @param path Path of the double to check.
+ * @return Whether or not the specified path is a double.
+ */
+ public boolean isDouble(@NotNull String path);
+
+ /**
+ * Gets the requested long by path.
+ *
+ * If the long does not exist but a default value has been specified, this
+ * will return the default value. If the long does not exist and no
+ * default value was specified, this will return 0.
+ *
+ * @param path Path of the long to get.
+ * @return Requested long.
+ */
+ public long getLong(@NotNull String path);
+
+ /**
+ * Gets the requested long by path, returning a default value if not
+ * found.
+ *
+ * If the long does not exist then the specified default value will
+ * returned regardless of if a default has been identified in the root
+ * {@link Configuration}.
+ *
+ * @param path Path of the long to get.
+ * @param def The default value to return if the path is not found or is
+ * not a long.
+ * @return Requested long.
+ */
+ public long getLong(@NotNull String path, long def);
+
+ /**
+ * Checks if the specified path is a long.
+ *
+ * If the path exists but is not a long, this will return false. If the
+ * path does not exist, this will return false. If the path does not exist
+ * but a default value has been specified, this will check if that default
+ * value is a long and return appropriately.
+ *
+ * @param path Path of the long to check.
+ * @return Whether or not the specified path is a long.
+ */
+ public boolean isLong(@NotNull String path);
+
+ // Java
+ /**
+ * Gets the requested List by path.
+ *
+ * If the List does not exist but a default value has been specified, this
+ * will return the default value. If the List does not exist and no
+ * default value was specified, this will return null.
+ *
+ * @param path Path of the List to get.
+ * @return Requested List.
+ */
+ @Nullable
+ public List getList(@NotNull String path);
+
+ /**
+ * Gets the requested List by path, returning a default value if not
+ * found.
+ *
+ * If the List does not exist then the specified default value will
+ * returned regardless of if a default has been identified in the root
+ * {@link Configuration}.
+ *
+ * @param path Path of the List to get.
+ * @param def The default value to return if the path is not found or is
+ * not a List.
+ * @return Requested List.
+ */
+ @Contract("_, !null -> !null")
+ @Nullable
+ public List getList(@NotNull String path, @Nullable List def);
+
+ /**
+ * Checks if the specified path is a List.
+ *
+ * If the path exists but is not a List, this will return false. If the
+ * path does not exist, this will return false. If the path does not exist
+ * but a default value has been specified, this will check if that default
+ * value is a List and return appropriately.
+ *
+ * @param path Path of the List to check.
+ * @return Whether or not the specified path is a List.
+ */
+ public boolean isList(@NotNull String path);
+
+ /**
+ * Gets the requested List of String by path.
+ *
+ * If the List does not exist but a default value has been specified, this
+ * will return the default value. If the List does not exist and no
+ * default value was specified, this will return an empty List.
+ *
+ * This method will attempt to cast any values into a String if possible,
+ * but may miss any values out if they are not compatible.
+ *
+ * @param path Path of the List to get.
+ * @return Requested List of String.
+ */
+ @NotNull
+ public List getStringList(@NotNull String path);
+
+ /**
+ * Gets the requested List of Integer by path.
+ *
+ * If the List does not exist but a default value has been specified, this
+ * will return the default value. If the List does not exist and no
+ * default value was specified, this will return an empty List.
+ *
+ * This method will attempt to cast any values into a Integer if possible,
+ * but may miss any values out if they are not compatible.
+ *
+ * @param path Path of the List to get.
+ * @return Requested List of Integer.
+ */
+ @NotNull
+ public List getIntegerList(@NotNull String path);
+
+ /**
+ * Gets the requested List of Boolean by path.
+ *
+ * If the List does not exist but a default value has been specified, this
+ * will return the default value. If the List does not exist and no
+ * default value was specified, this will return an empty List.
+ *
+ * This method will attempt to cast any values into a Boolean if possible,
+ * but may miss any values out if they are not compatible.
+ *
+ * @param path Path of the List to get.
+ * @return Requested List of Boolean.
+ */
+ @NotNull
+ public List getBooleanList(@NotNull String path);
+
+ /**
+ * Gets the requested List of Double by path.
+ *
+ * If the List does not exist but a default value has been specified, this
+ * will return the default value. If the List does not exist and no
+ * default value was specified, this will return an empty List.
+ *
+ * This method will attempt to cast any values into a Double if possible,
+ * but may miss any values out if they are not compatible.
+ *
+ * @param path Path of the List to get.
+ * @return Requested List of Double.
+ */
+ @NotNull
+ public List getDoubleList(@NotNull String path);
+
+ /**
+ * Gets the requested List of Float by path.
+ *
+ * If the List does not exist but a default value has been specified, this
+ * will return the default value. If the List does not exist and no
+ * default value was specified, this will return an empty List.
+ *
+ * This method will attempt to cast any values into a Float if possible,
+ * but may miss any values out if they are not compatible.
+ *
+ * @param path Path of the List to get.
+ * @return Requested List of Float.
+ */
+ @NotNull
+ public List getFloatList(@NotNull String path);
+
+ /**
+ * Gets the requested List of Long by path.
+ *
+ * If the List does not exist but a default value has been specified, this
+ * will return the default value. If the List does not exist and no
+ * default value was specified, this will return an empty List.
+ *
+ * This method will attempt to cast any values into a Long if possible,
+ * but may miss any values out if they are not compatible.
+ *
+ * @param path Path of the List to get.
+ * @return Requested List of Long.
+ */
+ @NotNull
+ public List getLongList(@NotNull String path);
+
+ /**
+ * Gets the requested List of Byte by path.
+ *
+ * If the List does not exist but a default value has been specified, this
+ * will return the default value. If the List does not exist and no
+ * default value was specified, this will return an empty List.
+ *
+ * This method will attempt to cast any values into a Byte if possible,
+ * but may miss any values out if they are not compatible.
+ *
+ * @param path Path of the List to get.
+ * @return Requested List of Byte.
+ */
+ @NotNull
+ public List getByteList(@NotNull String path);
+
+ /**
+ * Gets the requested List of Character by path.
+ *
+ * If the List does not exist but a default value has been specified, this
+ * will return the default value. If the List does not exist and no
+ * default value was specified, this will return an empty List.
+ *
+ * This method will attempt to cast any values into a Character if
+ * possible, but may miss any values out if they are not compatible.
+ *
+ * @param path Path of the List to get.
+ * @return Requested List of Character.
+ */
+ @NotNull
+ public List getCharacterList(@NotNull String path);
+
+ /**
+ * Gets the requested List of Short by path.
+ *
+ * If the List does not exist but a default value has been specified, this
+ * will return the default value. If the List does not exist and no
+ * default value was specified, this will return an empty List.
+ *
+ * This method will attempt to cast any values into a Short if possible,
+ * but may miss any values out if they are not compatible.
+ *
+ * @param path Path of the List to get.
+ * @return Requested List of Short.
+ */
+ @NotNull
+ public List getShortList(@NotNull String path);
+
+ /**
+ * Gets the requested List of Maps by path.
+ *
+ * If the List does not exist but a default value has been specified, this
+ * will return the default value. If the List does not exist and no
+ * default value was specified, this will return an empty List.
+ *
+ * This method will attempt to cast any values into a Map if possible, but
+ * may miss any values out if they are not compatible.
+ *
+ * @param path Path of the List to get.
+ * @return Requested List of Maps.
+ */
+ @NotNull
+ public List> getMapList(@NotNull String path);
+
+ // Bukkit
+ /**
+ * Gets the requested object at the given path.
+ *
+ * If the Object does not exist but a default value has been specified, this
+ * will return the default value. If the Object does not exist and no
+ * default value was specified, this will return null.
+ *
+ * Note: For example #getObject(path, String.class) is not
+ * equivalent to {@link #getString(String) #getString(path)} because
+ * {@link #getString(String) #getString(path)} converts internally all
+ * Objects to Strings. However, #getObject(path, Boolean.class) is
+ * equivalent to {@link #getBoolean(String) #getBoolean(path)} for example.
+ *
+ * @param the type of the requested object
+ * @param path the path to the object.
+ * @param clazz the type of the requested object
+ * @return Requested object
+ */
+ @Nullable
+ public T getObject(@NotNull String path, @NotNull Class clazz);
+
+ /**
+ * Gets the requested object at the given path, returning a default value if
+ * not found
+ *
+ * If the Object does not exist then the specified default value will
+ * returned regardless of if a default has been identified in the root
+ * {@link Configuration}.
+ *
+ * Note: For example #getObject(path, String.class, def) is
+ * not equivalent to
+ * {@link #getString(String, String) #getString(path, def)} because
+ * {@link #getString(String, String) #getString(path, def)} converts
+ * internally all Objects to Strings. However, #getObject(path,
+ * Boolean.class, def) is equivalent to {@link #getBoolean(String, boolean) #getBoolean(path,
+ * def)} for example.
+ *
+ * @param the type of the requested object
+ * @param path the path to the object.
+ * @param clazz the type of the requested object
+ * @param def the default object to return if the object is not present at
+ * the path
+ * @return Requested object
+ */
+ @Contract("_, _, !null -> !null")
+ @Nullable
+ public T getObject(@NotNull String path, @NotNull Class clazz, @Nullable T def);
+
+ /**
+ * Gets the requested {@link ConfigurationSerializable} object at the given
+ * path.
+ *
+ * If the Object does not exist but a default value has been specified, this
+ * will return the default value. If the Object does not exist and no
+ * default value was specified, this will return null.
+ *
+ * @param the type of {@link ConfigurationSerializable}
+ * @param path the path to the object.
+ * @param clazz the type of {@link ConfigurationSerializable}
+ * @return Requested {@link ConfigurationSerializable} object
+ */
+ @Nullable
+ public T getSerializable(@NotNull String path, @NotNull Class clazz);
+
+ /**
+ * Gets the requested {@link ConfigurationSerializable} object at the given
+ * path, returning a default value if not found
+ *
+ * If the Object does not exist then the specified default value will
+ * returned regardless of if a default has been identified in the root
+ * {@link Configuration}.
+ *
+ * @param the type of {@link ConfigurationSerializable}
+ * @param path the path to the object.
+ * @param clazz the type of {@link ConfigurationSerializable}
+ * @param def the default object to return if the object is not present at
+ * the path
+ * @return Requested {@link ConfigurationSerializable} object
+ */
+ @Contract("_, _, !null -> !null")
+ @Nullable
+ public T getSerializable(@NotNull String path, @NotNull Class clazz, @Nullable T def);
+
+ @Nullable
+ public ConfigurationSection getConfigurationSection(@NotNull String path);
+
+ /**
+ * Checks if the specified path is a ConfigurationSection.
+ *
+ * If the path exists but is not a ConfigurationSection, this will return
+ * false. If the path does not exist, this will return false. If the path
+ * does not exist but a default value has been specified, this will check
+ * if that default value is a ConfigurationSection and return
+ * appropriately.
+ *
+ * @param path Path of the ConfigurationSection to check.
+ * @return Whether or not the specified path is a ConfigurationSection.
+ */
+ public boolean isConfigurationSection(@NotNull String path);
+
+ /**
+ * Gets the equivalent {@link ConfigurationSection} from the default
+ * {@link Configuration} defined in {@link #getRoot()}.
+ *
+ * If the root contains no defaults, or the defaults doesn't contain a
+ * value for this path, or the value at this path is not a {@link
+ * ConfigurationSection} then this will return null.
+ *
+ * @return Equivalent section in root configuration
+ */
+ @Nullable
+ public ConfigurationSection getDefaultSection();
+
+ /**
+ * Sets the default value in the root at the given path as provided.
+ *
+ * If no source {@link Configuration} was provided as a default
+ * collection, then a new {@link MemoryConfiguration} will be created to
+ * hold the new default value.
+ *
+ * If value is null, the value will be removed from the default
+ * Configuration source.
+ *
+ * If the value as returned by {@link #getDefaultSection()} is null, then
+ * this will create a new section at the path, replacing anything that may
+ * have existed there previously.
+ *
+ * @param path Path of the value to set.
+ * @param value Value to set the default to.
+ * @throws IllegalArgumentException Thrown if path is null.
+ */
+ public void addDefault(@NotNull String path, @Nullable Object value);
+
+ /**
+ * Gets the requested comment list by path.
+ *
+ * If no comments exist, an empty list will be returned. A null entry
+ * represents an empty line and an empty String represents an empty comment
+ * line.
+ *
+ * @param path Path of the comments to get.
+ * @return A unmodifiable list of the requested comments, every entry
+ * represents one line.
+ */
+ @NotNull
+ public List getComments(@NotNull String path);
+
+ /**
+ * Gets the requested inline comment list by path.
+ *
+ * If no comments exist, an empty list will be returned. A null entry
+ * represents an empty line and an empty String represents an empty comment
+ * line.
+ *
+ * @param path Path of the comments to get.
+ * @return A unmodifiable list of the requested comments, every entry
+ * represents one line.
+ */
+ @NotNull
+ public List getInlineComments(@NotNull String path);
+
+ /**
+ * Sets the comment list at the specified path.
+ *
+ * If value is null, the comments will be removed. A null entry is an empty
+ * line and an empty String entry is an empty comment line. If the path does
+ * not exist, no comments will be set. Any existing comments will be
+ * replaced, regardless of what the new comments are.
+ *
+ * Some implementations may have limitations on what persists. See their
+ * individual javadocs for details.
+ *
+ * @param path Path of the comments to set.
+ * @param comments New comments to set at the path, every entry represents
+ * one line.
+ */
+ public void setComments(@NotNull String path, @Nullable List comments);
+
+ /**
+ * Sets the inline comment list at the specified path.
+ *
+ * If value is null, the comments will be removed. A null entry is an empty
+ * line and an empty String entry is an empty comment line. If the path does
+ * not exist, no comment will be set. Any existing comments will be
+ * replaced, regardless of what the new comments are.
+ *
+ * Some implementations may have limitations on what persists. See their
+ * individual javadocs for details.
+ *
+ * @param path Path of the comments to set.
+ * @param comments New comments to set at the path, every entry represents
+ * one line.
+ */
+ public void setInlineComments(@NotNull String path, @Nullable List comments);
+}
diff --git a/src/main/java/org/bukkit/configuration/InvalidConfigurationException.java b/src/main/java/org/bukkit/configuration/InvalidConfigurationException.java
new file mode 100644
index 0000000..d23480e
--- /dev/null
+++ b/src/main/java/org/bukkit/configuration/InvalidConfigurationException.java
@@ -0,0 +1,45 @@
+package org.bukkit.configuration;
+
+/**
+ * Exception thrown when attempting to load an invalid {@link Configuration}
+ */
+@SuppressWarnings("serial")
+public class InvalidConfigurationException extends Exception {
+
+ /**
+ * Creates a new instance of InvalidConfigurationException without a
+ * message or cause.
+ */
+ public InvalidConfigurationException() {}
+
+ /**
+ * Constructs an instance of InvalidConfigurationException with the
+ * specified message.
+ *
+ * @param msg The details of the exception.
+ */
+ public InvalidConfigurationException(String msg) {
+ super(msg);
+ }
+
+ /**
+ * Constructs an instance of InvalidConfigurationException with the
+ * specified cause.
+ *
+ * @param cause The cause of the exception.
+ */
+ public InvalidConfigurationException(Throwable cause) {
+ super(cause);
+ }
+
+ /**
+ * Constructs an instance of InvalidConfigurationException with the
+ * specified message and cause.
+ *
+ * @param cause The cause of the exception.
+ * @param msg The details of the exception.
+ */
+ public InvalidConfigurationException(String msg, Throwable cause) {
+ super(msg, cause);
+ }
+}
diff --git a/src/main/java/org/bukkit/configuration/MemoryConfiguration.java b/src/main/java/org/bukkit/configuration/MemoryConfiguration.java
new file mode 100644
index 0000000..47dbd5c
--- /dev/null
+++ b/src/main/java/org/bukkit/configuration/MemoryConfiguration.java
@@ -0,0 +1,92 @@
+package org.bukkit.configuration;
+
+import java.util.Map;
+import org.apache.commons.lang.Validate;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+/**
+ * This is a {@link Configuration} implementation that does not save or load
+ * from any source, and stores all values in memory only.
+ * This is useful for temporary Configurations for providing defaults.
+ */
+public class MemoryConfiguration extends MemorySection implements Configuration {
+ protected Configuration defaults;
+ protected MemoryConfigurationOptions options;
+
+ /**
+ * Creates an empty {@link MemoryConfiguration} with no default values.
+ */
+ public MemoryConfiguration() {}
+
+ /**
+ * Creates an empty {@link MemoryConfiguration} using the specified {@link
+ * Configuration} as a source for all default values.
+ *
+ * @param defaults Default value provider
+ * @throws IllegalArgumentException Thrown if defaults is null
+ */
+ public MemoryConfiguration(@Nullable Configuration defaults) {
+ this.defaults = defaults;
+ }
+
+ @Override
+ public void addDefault(@NotNull String path, @Nullable Object value) {
+ Validate.notNull(path, "Path may not be null");
+
+ if (defaults == null) {
+ defaults = new MemoryConfiguration();
+ }
+
+ defaults.set(path, value);
+ }
+
+ @Override
+ public void addDefaults(@NotNull Map defaults) {
+ Validate.notNull(defaults, "Defaults may not be null");
+
+ for (Map.Entry entry : defaults.entrySet()) {
+ addDefault(entry.getKey(), entry.getValue());
+ }
+ }
+
+ @Override
+ public void addDefaults(@NotNull Configuration defaults) {
+ Validate.notNull(defaults, "Defaults may not be null");
+
+ for (String key : defaults.getKeys(true)) {
+ if (!defaults.isConfigurationSection(key)) {
+ addDefault(key, defaults.get(key));
+ }
+ }
+ }
+
+ @Override
+ public void setDefaults(@NotNull Configuration defaults) {
+ Validate.notNull(defaults, "Defaults may not be null");
+
+ this.defaults = defaults;
+ }
+
+ @Override
+ @Nullable
+ public Configuration getDefaults() {
+ return defaults;
+ }
+
+ @Nullable
+ @Override
+ public ConfigurationSection getParent() {
+ return null;
+ }
+
+ @Override
+ @NotNull
+ public MemoryConfigurationOptions options() {
+ if (options == null) {
+ options = new MemoryConfigurationOptions(this);
+ }
+
+ return options;
+ }
+}
diff --git a/src/main/java/org/bukkit/configuration/MemoryConfigurationOptions.java b/src/main/java/org/bukkit/configuration/MemoryConfigurationOptions.java
new file mode 100644
index 0000000..ead85f6
--- /dev/null
+++ b/src/main/java/org/bukkit/configuration/MemoryConfigurationOptions.java
@@ -0,0 +1,33 @@
+package org.bukkit.configuration;
+
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * Various settings for controlling the input and output of a {@link
+ * MemoryConfiguration}
+ */
+public class MemoryConfigurationOptions extends ConfigurationOptions {
+ protected MemoryConfigurationOptions(@NotNull MemoryConfiguration configuration) {
+ super(configuration);
+ }
+
+ @NotNull
+ @Override
+ public MemoryConfiguration configuration() {
+ return (MemoryConfiguration) super.configuration();
+ }
+
+ @NotNull
+ @Override
+ public MemoryConfigurationOptions copyDefaults(boolean value) {
+ super.copyDefaults(value);
+ return this;
+ }
+
+ @NotNull
+ @Override
+ public MemoryConfigurationOptions pathSeparator(char value) {
+ super.pathSeparator(value);
+ return this;
+ }
+}
diff --git a/src/main/java/org/bukkit/configuration/MemorySection.java b/src/main/java/org/bukkit/configuration/MemorySection.java
new file mode 100644
index 0000000..dc958a8
--- /dev/null
+++ b/src/main/java/org/bukkit/configuration/MemorySection.java
@@ -0,0 +1,949 @@
+package org.bukkit.configuration;
+
+import static org.bukkit.util.NumberConversions.*;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.LinkedHashMap;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import org.apache.commons.lang.Validate;
+import org.bukkit.configuration.serialization.ConfigurationSerializable;
+import org.jetbrains.annotations.Contract;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+/**
+ * A type of {@link ConfigurationSection} that is stored in memory.
+ */
+public class MemorySection implements ConfigurationSection {
+ protected final Map map = new LinkedHashMap();
+ private final Configuration root;
+ private final ConfigurationSection parent;
+ private final String path;
+ private final String fullPath;
+
+ /**
+ * Creates an empty MemorySection for use as a root {@link Configuration}
+ * section.
+ *
+ * Note that calling this without being yourself a {@link Configuration}
+ * will throw an exception!
+ *
+ * @throws IllegalStateException Thrown if this is not a {@link
+ * Configuration} root.
+ */
+ protected MemorySection() {
+ if (!(this instanceof Configuration)) {
+ throw new IllegalStateException("Cannot construct a root MemorySection when not a Configuration");
+ }
+
+ this.path = "";
+ this.fullPath = "";
+ this.parent = null;
+ this.root = (Configuration) this;
+ }
+
+ /**
+ * Creates an empty MemorySection with the specified parent and path.
+ *
+ * @param parent Parent section that contains this own section.
+ * @param path Path that you may access this section from via the root
+ * {@link Configuration}.
+ * @throws IllegalArgumentException Thrown is parent or path is null, or
+ * if parent contains no root Configuration.
+ */
+ protected MemorySection(@NotNull ConfigurationSection parent, @NotNull String path) {
+ Validate.notNull(parent, "Parent cannot be null");
+ Validate.notNull(path, "Path cannot be null");
+
+ this.path = path;
+ this.parent = parent;
+ this.root = parent.getRoot();
+
+ Validate.notNull(root, "Path cannot be orphaned");
+
+ this.fullPath = createPath(parent, path);
+ }
+
+ @Override
+ @NotNull
+ public Set getKeys(boolean deep) {
+ Set result = new LinkedHashSet();
+
+ Configuration root = getRoot();
+ if (root != null && root.options().copyDefaults()) {
+ ConfigurationSection defaults = getDefaultSection();
+
+ if (defaults != null) {
+ result.addAll(defaults.getKeys(deep));
+ }
+ }
+
+ mapChildrenKeys(result, this, deep);
+
+ return result;
+ }
+
+ @Override
+ @NotNull
+ public Map getValues(boolean deep) {
+ Map result = new LinkedHashMap();
+
+ Configuration root = getRoot();
+ if (root != null && root.options().copyDefaults()) {
+ ConfigurationSection defaults = getDefaultSection();
+
+ if (defaults != null) {
+ result.putAll(defaults.getValues(deep));
+ }
+ }
+
+ mapChildrenValues(result, this, deep);
+
+ return result;
+ }
+
+ @Override
+ public boolean contains(@NotNull String path) {
+ return contains(path, false);
+ }
+
+ @Override
+ public boolean contains(@NotNull String path, boolean ignoreDefault) {
+ return ((ignoreDefault) ? get(path, null) : get(path)) != null;
+ }
+
+ @Override
+ public boolean isSet(@NotNull String path) {
+ Configuration root = getRoot();
+ if (root == null) {
+ return false;
+ }
+ if (root.options().copyDefaults()) {
+ return contains(path);
+ }
+ return get(path, null) != null;
+ }
+
+ @Override
+ @NotNull
+ public String getCurrentPath() {
+ return fullPath;
+ }
+
+ @Override
+ @NotNull
+ public String getName() {
+ return path;
+ }
+
+ @Override
+ @Nullable
+ public Configuration getRoot() {
+ return root;
+ }
+
+ @Override
+ @Nullable
+ public ConfigurationSection getParent() {
+ return parent;
+ }
+
+ @Override
+ public void addDefault(@NotNull String path, @Nullable Object value) {
+ Validate.notNull(path, "Path cannot be null");
+
+ Configuration root = getRoot();
+ if (root == null) {
+ throw new IllegalStateException("Cannot add default without root");
+ }
+ if (root == this) {
+ throw new UnsupportedOperationException("Unsupported addDefault(String, Object) implementation");
+ }
+ root.addDefault(createPath(this, path), value);
+ }
+
+ @Override
+ @Nullable
+ public ConfigurationSection getDefaultSection() {
+ Configuration root = getRoot();
+ Configuration defaults = root == null ? null : root.getDefaults();
+
+ if (defaults != null) {
+ if (defaults.isConfigurationSection(getCurrentPath())) {
+ return defaults.getConfigurationSection(getCurrentPath());
+ }
+ }
+
+ return null;
+ }
+
+ @Override
+ public void set(@NotNull String path, @Nullable Object value) {
+ Validate.notEmpty(path, "Cannot set to an empty path");
+
+ Configuration root = getRoot();
+ if (root == null) {
+ throw new IllegalStateException("Cannot use section without a root");
+ }
+
+ final char separator = root.options().pathSeparator();
+ // i1 is the leading (higher) index
+ // i2 is the trailing (lower) index
+ int i1 = -1, i2;
+ ConfigurationSection section = this;
+ while ((i1 = path.indexOf(separator, i2 = i1 + 1)) != -1) {
+ String node = path.substring(i2, i1);
+ ConfigurationSection subSection = section.getConfigurationSection(node);
+ if (subSection == null) {
+ if (value == null) {
+ // no need to create missing sub-sections if we want to remove the value:
+ return;
+ }
+ section = section.createSection(node);
+ } else {
+ section = subSection;
+ }
+ }
+
+ String key = path.substring(i2);
+ if (section == this) {
+ if (value == null) {
+ map.remove(key);
+ } else {
+ SectionPathData entry = map.get(key);
+ if (entry == null) {
+ map.put(key, new SectionPathData(value));
+ } else {
+ entry.setData(value);
+ }
+ }
+ } else {
+ section.set(key, value);
+ }
+ }
+
+ @Override
+ @Nullable
+ public Object get(@NotNull String path) {
+ return get(path, getDefault(path));
+ }
+
+ @Override
+ @Contract("_, !null -> !null")
+ @Nullable
+ public Object get(@NotNull String path, @Nullable Object def) {
+ Validate.notNull(path, "Path cannot be null");
+
+ if (path.length() == 0) {
+ return this;
+ }
+
+ Configuration root = getRoot();
+ if (root == null) {
+ throw new IllegalStateException("Cannot access section without a root");
+ }
+
+ final char separator = root.options().pathSeparator();
+ // i1 is the leading (higher) index
+ // i2 is the trailing (lower) index
+ int i1 = -1, i2;
+ ConfigurationSection section = this;
+ while ((i1 = path.indexOf(separator, i2 = i1 + 1)) != -1) {
+ final String currentPath = path.substring(i2, i1);
+ if (!section.contains(currentPath, true)) {
+ return def;
+ }
+ section = section.getConfigurationSection(currentPath);
+ if (section == null) {
+ return def;
+ }
+ }
+
+ String key = path.substring(i2);
+ if (section == this) {
+ SectionPathData result = map.get(key);
+ return (result == null) ? def : result.getData();
+ }
+ return section.get(key, def);
+ }
+
+ @Override
+ @NotNull
+ public ConfigurationSection createSection(@NotNull String path) {
+ Validate.notEmpty(path, "Cannot create section at empty path");
+ Configuration root = getRoot();
+ if (root == null) {
+ throw new IllegalStateException("Cannot create section without a root");
+ }
+
+ final char separator = root.options().pathSeparator();
+ // i1 is the leading (higher) index
+ // i2 is the trailing (lower) index
+ int i1 = -1, i2;
+ ConfigurationSection section = this;
+ while ((i1 = path.indexOf(separator, i2 = i1 + 1)) != -1) {
+ String node = path.substring(i2, i1);
+ ConfigurationSection subSection = section.getConfigurationSection(node);
+ if (subSection == null) {
+ section = section.createSection(node);
+ } else {
+ section = subSection;
+ }
+ }
+
+ String key = path.substring(i2);
+ if (section == this) {
+ ConfigurationSection result = new MemorySection(this, key);
+ map.put(key, new SectionPathData(result));
+ return result;
+ }
+ return section.createSection(key);
+ }
+
+ @Override
+ @NotNull
+ public ConfigurationSection createSection(@NotNull String path, @NotNull Map map) {
+ ConfigurationSection section = createSection(path);
+
+ for (Map.Entry entry : map.entrySet()) {
+ if (entry.getValue() instanceof Map) {
+ section.createSection(entry.getKey().toString(), (Map) entry.getValue());
+ } else {
+ section.set(entry.getKey().toString(), entry.getValue());
+ }
+ }
+
+ return section;
+ }
+
+ // Primitives
+ @Override
+ @Nullable
+ public String getString(@NotNull String path) {
+ Object def = getDefault(path);
+ return getString(path, def != null ? def.toString() : null);
+ }
+
+ @Override
+ @Contract("_, !null -> !null")
+ @Nullable
+ public String getString(@NotNull String path, @Nullable String def) {
+ Object val = get(path, def);
+ return (val != null) ? val.toString() : def;
+ }
+
+ @Override
+ public boolean isString(@NotNull String path) {
+ Object val = get(path);
+ return val instanceof String;
+ }
+
+ @Override
+ public int getInt(@NotNull String path) {
+ Object def = getDefault(path);
+ return getInt(path, (def instanceof Number) ? toInt(def) : 0);
+ }
+
+ @Override
+ public int getInt(@NotNull String path, int def) {
+ Object val = get(path, def);
+ return (val instanceof Number) ? toInt(val) : def;
+ }
+
+ @Override
+ public boolean isInt(@NotNull String path) {
+ Object val = get(path);
+ return val instanceof Integer;
+ }
+
+ @Override
+ public boolean getBoolean(@NotNull String path) {
+ Object def = getDefault(path);
+ return getBoolean(path, (def instanceof Boolean) ? (Boolean) def : false);
+ }
+
+ @Override
+ public boolean getBoolean(@NotNull String path, boolean def) {
+ Object val = get(path, def);
+ return (val instanceof Boolean) ? (Boolean) val : def;
+ }
+
+ @Override
+ public boolean isBoolean(@NotNull String path) {
+ Object val = get(path);
+ return val instanceof Boolean;
+ }
+
+ @Override
+ public double getDouble(@NotNull String path) {
+ Object def = getDefault(path);
+ return getDouble(path, (def instanceof Number) ? toDouble(def) : 0);
+ }
+
+ @Override
+ public double getDouble(@NotNull String path, double def) {
+ Object val = get(path, def);
+ return (val instanceof Number) ? toDouble(val) : def;
+ }
+
+ @Override
+ public boolean isDouble(@NotNull String path) {
+ Object val = get(path);
+ return val instanceof Double;
+ }
+
+ @Override
+ public long getLong(@NotNull String path) {
+ Object def = getDefault(path);
+ return getLong(path, (def instanceof Number) ? toLong(def) : 0);
+ }
+
+ @Override
+ public long getLong(@NotNull String path, long def) {
+ Object val = get(path, def);
+ return (val instanceof Number) ? toLong(val) : def;
+ }
+
+ @Override
+ public boolean isLong(@NotNull String path) {
+ Object val = get(path);
+ return val instanceof Long;
+ }
+
+ // Java
+ @Override
+ @Nullable
+ public List getList(@NotNull String path) {
+ Object def = getDefault(path);
+ return getList(path, (def instanceof List) ? (List) def : null);
+ }
+
+ @Override
+ @Contract("_, !null -> !null")
+ @Nullable
+ public List getList(@NotNull String path, @Nullable List def) {
+ Object val = get(path, def);
+ return (List) ((val instanceof List) ? val : def);
+ }
+
+ @Override
+ public boolean isList(@NotNull String path) {
+ Object val = get(path);
+ return val instanceof List;
+ }
+
+ @Override
+ @NotNull
+ public List getStringList(@NotNull String path) {
+ List list = getList(path);
+
+ if (list == null) {
+ return new ArrayList(0);
+ }
+
+ List result = new ArrayList();
+
+ for (Object object : list) {
+ if ((object instanceof String) || (isPrimitiveWrapper(object))) {
+ result.add(String.valueOf(object));
+ }
+ }
+
+ return result;
+ }
+
+ @Override
+ @NotNull
+ public List getIntegerList(@NotNull String path) {
+ List list = getList(path);
+
+ if (list == null) {
+ return new ArrayList(0);
+ }
+
+ List result = new ArrayList();
+
+ for (Object object : list) {
+ if (object instanceof Integer) {
+ result.add((Integer) object);
+ } else if (object instanceof String) {
+ try {
+ result.add(Integer.valueOf((String) object));
+ } catch (Exception ex) {
+ }
+ } else if (object instanceof Character) {
+ result.add((int) ((Character) object).charValue());
+ } else if (object instanceof Number) {
+ result.add(((Number) object).intValue());
+ }
+ }
+
+ return result;
+ }
+
+ @Override
+ @NotNull
+ public List getBooleanList(@NotNull String path) {
+ List list = getList(path);
+
+ if (list == null) {
+ return new ArrayList(0);
+ }
+
+ List result = new ArrayList();
+
+ for (Object object : list) {
+ if (object instanceof Boolean) {
+ result.add((Boolean) object);
+ } else if (object instanceof String) {
+ if (Boolean.TRUE.toString().equals(object)) {
+ result.add(true);
+ } else if (Boolean.FALSE.toString().equals(object)) {
+ result.add(false);
+ }
+ }
+ }
+
+ return result;
+ }
+
+ @Override
+ @NotNull
+ public List getDoubleList(@NotNull String path) {
+ List list = getList(path);
+
+ if (list == null) {
+ return new ArrayList(0);
+ }
+
+ List result = new ArrayList();
+
+ for (Object object : list) {
+ if (object instanceof Double) {
+ result.add((Double) object);
+ } else if (object instanceof String) {
+ try {
+ result.add(Double.valueOf((String) object));
+ } catch (Exception ex) {
+ }
+ } else if (object instanceof Character) {
+ result.add((double) ((Character) object).charValue());
+ } else if (object instanceof Number) {
+ result.add(((Number) object).doubleValue());
+ }
+ }
+
+ return result;
+ }
+
+ @Override
+ @NotNull
+ public List getFloatList(@NotNull String path) {
+ List list = getList(path);
+
+ if (list == null) {
+ return new ArrayList(0);
+ }
+
+ List result = new ArrayList();
+
+ for (Object object : list) {
+ if (object instanceof Float) {
+ result.add((Float) object);
+ } else if (object instanceof String) {
+ try {
+ result.add(Float.valueOf((String) object));
+ } catch (Exception ex) {
+ }
+ } else if (object instanceof Character) {
+ result.add((float) ((Character) object).charValue());
+ } else if (object instanceof Number) {
+ result.add(((Number) object).floatValue());
+ }
+ }
+
+ return result;
+ }
+
+ @Override
+ @NotNull
+ public List getLongList(@NotNull String path) {
+ List list = getList(path);
+
+ if (list == null) {
+ return new ArrayList(0);
+ }
+
+ List result = new ArrayList();
+
+ for (Object object : list) {
+ if (object instanceof Long) {
+ result.add((Long) object);
+ } else if (object instanceof String) {
+ try {
+ result.add(Long.valueOf((String) object));
+ } catch (Exception ex) {
+ }
+ } else if (object instanceof Character) {
+ result.add((long) ((Character) object).charValue());
+ } else if (object instanceof Number) {
+ result.add(((Number) object).longValue());
+ }
+ }
+
+ return result;
+ }
+
+ @Override
+ @NotNull
+ public List getByteList(@NotNull String path) {
+ List list = getList(path);
+
+ if (list == null) {
+ return new ArrayList(0);
+ }
+
+ List result = new ArrayList();
+
+ for (Object object : list) {
+ if (object instanceof Byte) {
+ result.add((Byte) object);
+ } else if (object instanceof String) {
+ try {
+ result.add(Byte.valueOf((String) object));
+ } catch (Exception ex) {
+ }
+ } else if (object instanceof Character) {
+ result.add((byte) ((Character) object).charValue());
+ } else if (object instanceof Number) {
+ result.add(((Number) object).byteValue());
+ }
+ }
+
+ return result;
+ }
+
+ @Override
+ @NotNull
+ public List getCharacterList(@NotNull String path) {
+ List list = getList(path);
+
+ if (list == null) {
+ return new ArrayList(0);
+ }
+
+ List result = new ArrayList();
+
+ for (Object object : list) {
+ if (object instanceof Character) {
+ result.add((Character) object);
+ } else if (object instanceof String) {
+ String str = (String) object;
+
+ if (str.length() == 1) {
+ result.add(str.charAt(0));
+ }
+ } else if (object instanceof Number) {
+ result.add((char) ((Number) object).intValue());
+ }
+ }
+
+ return result;
+ }
+
+ @Override
+ @NotNull
+ public List getShortList(@NotNull String path) {
+ List list = getList(path);
+
+ if (list == null) {
+ return new ArrayList(0);
+ }
+
+ List result = new ArrayList();
+
+ for (Object object : list) {
+ if (object instanceof Short) {
+ result.add((Short) object);
+ } else if (object instanceof String) {
+ try {
+ result.add(Short.valueOf((String) object));
+ } catch (Exception ex) {
+ }
+ } else if (object instanceof Character) {
+ result.add((short) ((Character) object).charValue());
+ } else if (object instanceof Number) {
+ result.add(((Number) object).shortValue());
+ }
+ }
+
+ return result;
+ }
+
+ @Override
+ @NotNull
+ public List> getMapList(@NotNull String path) {
+ List list = getList(path);
+ List> result = new ArrayList>();
+
+ if (list == null) {
+ return result;
+ }
+
+ for (Object object : list) {
+ if (object instanceof Map) {
+ result.add((Map) object);
+ }
+ }
+
+ return result;
+ }
+
+ // Bukkit
+ @Nullable
+ @Override
+ public T getObject(@NotNull String path, @NotNull Class clazz) {
+ Validate.notNull(clazz, "Class cannot be null");
+ Object def = getDefault(path);
+ return getObject(path, clazz, (def != null && clazz.isInstance(def)) ? clazz.cast(def) : null);
+ }
+
+ @Contract("_, _, !null -> !null")
+ @Nullable
+ @Override
+ public T getObject(@NotNull String path, @NotNull Class clazz, @Nullable T def) {
+ Validate.notNull(clazz, "Class cannot be null");
+ Object val = get(path, def);
+ return (val != null && clazz.isInstance(val)) ? clazz.cast(val) : def;
+ }
+
+ @Nullable
+ @Override
+ public T getSerializable(@NotNull String path, @NotNull Class clazz) {
+ return getObject(path, clazz);
+ }
+
+ @Contract("_, _, !null -> !null")
+ @Nullable
+ @Override
+ public T getSerializable(@NotNull String path, @NotNull Class clazz, @Nullable T def) {
+ return getObject(path, clazz, def);
+ }
+
+ @Override
+ @Nullable
+ public ConfigurationSection getConfigurationSection(@NotNull String path) {
+ Object val = get(path, null);
+ if (val != null) {
+ return (val instanceof ConfigurationSection) ? (ConfigurationSection) val : null;
+ }
+
+ val = get(path, getDefault(path));
+ return (val instanceof ConfigurationSection) ? createSection(path) : null;
+ }
+
+ @Override
+ public boolean isConfigurationSection(@NotNull String path) {
+ Object val = get(path);
+ return val instanceof ConfigurationSection;
+ }
+
+ protected boolean isPrimitiveWrapper(@Nullable Object input) {
+ return input instanceof Integer || input instanceof Boolean
+ || input instanceof Character || input instanceof Byte
+ || input instanceof Short || input instanceof Double
+ || input instanceof Long || input instanceof Float;
+ }
+
+ @Nullable
+ protected Object getDefault(@NotNull String path) {
+ Validate.notNull(path, "Path cannot be null");
+
+ Configuration root = getRoot();
+ Configuration defaults = root == null ? null : root.getDefaults();
+ return (defaults == null) ? null : defaults.get(createPath(this, path));
+ }
+
+ protected void mapChildrenKeys(@NotNull Set output, @NotNull ConfigurationSection section, boolean deep) {
+ if (section instanceof MemorySection) {
+ MemorySection sec = (MemorySection) section;
+
+ for (Map.Entry entry : sec.map.entrySet()) {
+ output.add(createPath(section, entry.getKey(), this));
+
+ if ((deep) && (entry.getValue().getData() instanceof ConfigurationSection)) {
+ ConfigurationSection subsection = (ConfigurationSection) entry.getValue().getData();
+ mapChildrenKeys(output, subsection, deep);
+ }
+ }
+ } else {
+ Set keys = section.getKeys(deep);
+
+ for (String key : keys) {
+ output.add(createPath(section, key, this));
+ }
+ }
+ }
+
+ protected void mapChildrenValues(@NotNull Map output, @NotNull ConfigurationSection section, boolean deep) {
+ if (section instanceof MemorySection) {
+ MemorySection sec = (MemorySection) section;
+
+ for (Map.Entry entry : sec.map.entrySet()) {
+ // Because of the copyDefaults call potentially copying out of order, we must remove and then add in our saved order
+ // This means that default values we haven't set end up getting placed first
+ // See SPIGOT-4558 for an example using spigot.yml - watch subsections move around to default order
+ String childPath = createPath(section, entry.getKey(), this);
+ output.remove(childPath);
+ output.put(childPath, entry.getValue().getData());
+
+ if (entry.getValue().getData() instanceof ConfigurationSection) {
+ if (deep) {
+ mapChildrenValues(output, (ConfigurationSection) entry.getValue().getData(), deep);
+ }
+ }
+ }
+ } else {
+ Map values = section.getValues(deep);
+
+ for (Map.Entry entry : values.entrySet()) {
+ output.put(createPath(section, entry.getKey(), this), entry.getValue());
+ }
+ }
+ }
+
+ /**
+ * Creates a full path to the given {@link ConfigurationSection} from its
+ * root {@link Configuration}.
+ *
+ * You may use this method for any given {@link ConfigurationSection}, not
+ * only {@link MemorySection}.
+ *
+ * @param section Section to create a path for.
+ * @param key Name of the specified section.
+ * @return Full path of the section from its root.
+ */
+ @NotNull
+ public static String createPath(@NotNull ConfigurationSection section, @Nullable String key) {
+ return createPath(section, key, (section == null) ? null : section.getRoot());
+ }
+
+ /**
+ * Creates a relative path to the given {@link ConfigurationSection} from
+ * the given relative section.
+ *
+ * You may use this method for any given {@link ConfigurationSection}, not
+ * only {@link MemorySection}.
+ *
+ * @param section Section to create a path for.
+ * @param key Name of the specified section.
+ * @param relativeTo Section to create the path relative to.
+ * @return Full path of the section from its root.
+ */
+ @NotNull
+ public static String createPath(@NotNull ConfigurationSection section, @Nullable String key, @Nullable ConfigurationSection relativeTo) {
+ Validate.notNull(section, "Cannot create path without a section");
+ Configuration root = section.getRoot();
+ if (root == null) {
+ throw new IllegalStateException("Cannot create path without a root");
+ }
+ char separator = root.options().pathSeparator();
+
+ StringBuilder builder = new StringBuilder();
+ for (ConfigurationSection parent = section; (parent != null) && (parent != relativeTo); parent = parent.getParent()) {
+ if (builder.length() > 0) {
+ builder.insert(0, separator);
+ }
+ builder.insert(0, parent.getName());
+ }
+
+ if ((key != null) && (key.length() > 0)) {
+ if (builder.length() > 0) {
+ builder.append(separator);
+ }
+
+ builder.append(key);
+ }
+
+ return builder.toString();
+ }
+
+ @Override
+ @NotNull
+ public List getComments(@NotNull final String path) {
+ final SectionPathData pathData = getSectionPathData(path);
+ return pathData == null ? Collections.emptyList() : pathData.getComments();
+ }
+
+ @Override
+ @NotNull
+ public List getInlineComments(@NotNull final String path) {
+ final SectionPathData pathData = getSectionPathData(path);
+ return pathData == null ? Collections.emptyList() : pathData.getInlineComments();
+ }
+
+ @Override
+ public void setComments(@NotNull final String path, @Nullable final List comments) {
+ final SectionPathData pathData = getSectionPathData(path);
+ if (pathData != null) {
+ pathData.setComments(comments);
+ }
+ }
+
+ @Override
+ public void setInlineComments(@NotNull final String path, @Nullable final List comments) {
+ final SectionPathData pathData = getSectionPathData(path);
+ if (pathData != null) {
+ pathData.setInlineComments(comments);
+ }
+ }
+
+ @Nullable
+ private SectionPathData getSectionPathData(@NotNull String path) {
+ Validate.notNull(path, "Path cannot be null");
+
+ Configuration root = getRoot();
+ if (root == null) {
+ throw new IllegalStateException("Cannot access section without a root");
+ }
+
+ final char separator = root.options().pathSeparator();
+ // i1 is the leading (higher) index
+ // i2 is the trailing (lower) index
+ int i1 = -1, i2;
+ ConfigurationSection section = this;
+ while ((i1 = path.indexOf(separator, i2 = i1 + 1)) != -1) {
+ section = section.getConfigurationSection(path.substring(i2, i1));
+ if (section == null) {
+ return null;
+ }
+ }
+
+ String key = path.substring(i2);
+ if (section == this) {
+ SectionPathData entry = map.get(key);
+ if (entry != null) {
+ return entry;
+ }
+ } else if (section instanceof MemorySection) {
+ return ((MemorySection) section).getSectionPathData(key);
+ }
+ return null;
+ }
+
+ @Override
+ public String toString() {
+ Configuration root = getRoot();
+ return new StringBuilder()
+ .append(getClass().getSimpleName())
+ .append("[path='")
+ .append(getCurrentPath())
+ .append("', root='")
+ .append(root == null ? null : root.getClass().getSimpleName())
+ .append("']")
+ .toString();
+ }
+}
diff --git a/src/main/java/org/bukkit/configuration/SectionPathData.java b/src/main/java/org/bukkit/configuration/SectionPathData.java
new file mode 100644
index 0000000..54647c8
--- /dev/null
+++ b/src/main/java/org/bukkit/configuration/SectionPathData.java
@@ -0,0 +1,81 @@
+package org.bukkit.configuration;
+
+import java.util.Collections;
+import java.util.List;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+final class SectionPathData {
+
+ private Object data;
+ private List comments;
+ private List inlineComments;
+
+ public SectionPathData(@Nullable Object data) {
+ this.data = data;
+ comments = Collections.emptyList();
+ inlineComments = Collections.emptyList();
+ }
+
+ @Nullable
+ public Object getData() {
+ return data;
+ }
+
+ public void setData(@Nullable final Object data) {
+ this.data = data;
+ }
+
+ /**
+ * If no comments exist, an empty list will be returned. A null entry in the
+ * list represents an empty line and an empty String represents an empty
+ * comment line.
+ *
+ * @return A unmodifiable list of the requested comments, every entry
+ * represents one line.
+ */
+ @NotNull
+ public List getComments() {
+ return comments;
+ }
+
+ /**
+ * Represents the comments on a {@link ConfigurationSection} entry.
+ *
+ * A null entry in the List is an empty line and an empty String entry is an
+ * empty comment line. Any existing comments will be replaced, regardless of
+ * what the new comments are.
+ *
+ * @param comments New comments to set every entry represents one line.
+ */
+ public void setComments(@Nullable final List comments) {
+ this.comments = (comments == null) ? Collections.emptyList() : Collections.unmodifiableList(comments);
+ }
+
+ /**
+ * If no comments exist, an empty list will be returned. A null entry in the
+ * list represents an empty line and an empty String represents an empty
+ * comment line.
+ *
+ * @return A unmodifiable list of the requested comments, every entry
+ * represents one line.
+ */
+ @NotNull
+ public List getInlineComments() {
+ return inlineComments;
+ }
+
+ /**
+ * Represents the comments on a {@link ConfigurationSection} entry.
+ *
+ * A null entry in the List is an empty line and an empty String entry is an
+ * empty comment line. Any existing comments will be replaced, regardless of
+ * what the new comments are.
+ *
+ * @param inlineComments New comments to set every entry represents one
+ * line.
+ */
+ public void setInlineComments(@Nullable final List inlineComments) {
+ this.inlineComments = (inlineComments == null) ? Collections.emptyList() : Collections.unmodifiableList(inlineComments);
+ }
+}
diff --git a/src/main/java/org/bukkit/configuration/file/BukkitYaml.java b/src/main/java/org/bukkit/configuration/file/BukkitYaml.java
new file mode 100644
index 0000000..ba20419
--- /dev/null
+++ b/src/main/java/org/bukkit/configuration/file/BukkitYaml.java
@@ -0,0 +1,74 @@
+package org.bukkit.configuration.file;
+
+import java.io.IOException;
+import java.io.Writer;
+import java.lang.reflect.Field;
+import java.util.ArrayDeque;
+import java.util.Queue;
+import org.jetbrains.annotations.NotNull;
+import org.yaml.snakeyaml.DumperOptions;
+import org.yaml.snakeyaml.LoaderOptions;
+import org.yaml.snakeyaml.Yaml;
+import org.yaml.snakeyaml.comments.CommentEventsCollector;
+import org.yaml.snakeyaml.comments.CommentType;
+import org.yaml.snakeyaml.constructor.BaseConstructor;
+import org.yaml.snakeyaml.emitter.Emitter;
+import org.yaml.snakeyaml.error.YAMLException;
+import org.yaml.snakeyaml.events.Event;
+import org.yaml.snakeyaml.nodes.Node;
+import org.yaml.snakeyaml.representer.Representer;
+import org.yaml.snakeyaml.serializer.Serializer;
+
+final class BukkitYaml extends Yaml {
+
+ private static final Field events;
+ private static final Field blockCommentsCollector;
+ private static final Field inlineCommentsCollector;
+
+ private static Field getEmitterField(String name) {
+ Field field = null;
+ try {
+ field = Emitter.class.getDeclaredField(name);
+ field.setAccessible(true);
+ } catch (ReflectiveOperationException ex) {
+ // Ignore as a fail-safe fallback
+ }
+ return field;
+ }
+
+ static {
+ events = getEmitterField("events");
+ blockCommentsCollector = getEmitterField("blockCommentsCollector");
+ inlineCommentsCollector = getEmitterField("inlineCommentsCollector");
+ }
+
+ public BukkitYaml(@NotNull BaseConstructor constructor, @NotNull Representer representer, @NotNull DumperOptions dumperOptions, @NotNull LoaderOptions loadingConfig) {
+ super(constructor, representer, dumperOptions, loadingConfig);
+ }
+
+ @Override
+ public void serialize(@NotNull Node node, @NotNull Writer output) {
+ Emitter emitter = new Emitter(output, dumperOptions);
+ if (events != null && blockCommentsCollector != null && inlineCommentsCollector != null) {
+ Queue newEvents = new ArrayDeque<>(100);
+
+ try {
+ events.set(emitter, newEvents);
+ blockCommentsCollector.set(emitter, new CommentEventsCollector(newEvents, CommentType.BLANK_LINE, CommentType.BLOCK));
+ inlineCommentsCollector.set(emitter, new CommentEventsCollector(newEvents, CommentType.IN_LINE));
+ } catch (ReflectiveOperationException ex) {
+ // Don't ignore this as we could be in an inconsistent state
+ throw new RuntimeException("Could not update Yaml event queue", ex);
+ }
+ }
+
+ Serializer serializer = new Serializer(emitter, resolver, dumperOptions, null);
+ try {
+ serializer.open();
+ serializer.serialize(node);
+ serializer.close();
+ } catch (IOException ex) {
+ throw new YAMLException(ex);
+ }
+ }
+}
diff --git a/src/main/java/org/bukkit/configuration/file/FileConfiguration.java b/src/main/java/org/bukkit/configuration/file/FileConfiguration.java
new file mode 100644
index 0000000..50c58f1
--- /dev/null
+++ b/src/main/java/org/bukkit/configuration/file/FileConfiguration.java
@@ -0,0 +1,226 @@
+package org.bukkit.configuration.file;
+
+import com.google.common.base.Charsets;
+import com.google.common.io.Files;
+import java.io.BufferedReader;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.OutputStreamWriter;
+import java.io.Reader;
+import java.io.Writer;
+import org.apache.commons.lang.Validate;
+import org.bukkit.configuration.Configuration;
+import org.bukkit.configuration.InvalidConfigurationException;
+import org.bukkit.configuration.MemoryConfiguration;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+/**
+ * This is a base class for all File based implementations of {@link
+ * Configuration}
+ */
+public abstract class FileConfiguration extends MemoryConfiguration {
+
+ /**
+ * Creates an empty {@link FileConfiguration} with no default values.
+ */
+ public FileConfiguration() {
+ super();
+ }
+
+ /**
+ * Creates an empty {@link FileConfiguration} using the specified {@link
+ * Configuration} as a source for all default values.
+ *
+ * @param defaults Default value provider
+ */
+ public FileConfiguration(@Nullable Configuration defaults) {
+ super(defaults);
+ }
+
+ /**
+ * Saves this {@link FileConfiguration} to the specified location.
+ *
+ * If the file does not exist, it will be created. If already exists, it
+ * will be overwritten. If it cannot be overwritten or created, an
+ * exception will be thrown.
+ *
+ * This method will save using the system default encoding, or possibly
+ * using UTF8.
+ *
+ * @param file File to save to.
+ * @throws IOException Thrown when the given file cannot be written to for
+ * any reason.
+ * @throws IllegalArgumentException Thrown when file is null.
+ */
+ public void save(@NotNull File file) throws IOException {
+ Validate.notNull(file, "File cannot be null");
+
+ Files.createParentDirs(file);
+
+ String data = saveToString();
+
+ Writer writer = new OutputStreamWriter(new FileOutputStream(file), Charsets.UTF_8);
+
+ try {
+ writer.write(data);
+ } finally {
+ writer.close();
+ }
+ }
+
+ /**
+ * Saves this {@link FileConfiguration} to the specified location.
+ *
+ * If the file does not exist, it will be created. If already exists, it
+ * will be overwritten. If it cannot be overwritten or created, an
+ * exception will be thrown.
+ *
+ * This method will save using the system default encoding, or possibly
+ * using UTF8.
+ *
+ * @param file File to save to.
+ * @throws IOException Thrown when the given file cannot be written to for
+ * any reason.
+ * @throws IllegalArgumentException Thrown when file is null.
+ */
+ public void save(@NotNull String file) throws IOException {
+ Validate.notNull(file, "File cannot be null");
+
+ save(new File(file));
+ }
+
+ /**
+ * Saves this {@link FileConfiguration} to a string, and returns it.
+ *
+ * @return String containing this configuration.
+ */
+ @NotNull
+ public abstract String saveToString();
+
+ /**
+ * Loads this {@link FileConfiguration} from the specified location.
+ *
+ * All the values contained within this configuration will be removed,
+ * leaving only settings and defaults, and the new values will be loaded
+ * from the given file.
+ *
+ * If the file cannot be loaded for any reason, an exception will be
+ * thrown.
+ *
+ * @param file File to load from.
+ * @throws FileNotFoundException Thrown when the given file cannot be
+ * opened.
+ * @throws IOException Thrown when the given file cannot be read.
+ * @throws InvalidConfigurationException Thrown when the given file is not
+ * a valid Configuration.
+ * @throws IllegalArgumentException Thrown when file is null.
+ */
+ public void load(@NotNull File file) throws FileNotFoundException, IOException, InvalidConfigurationException {
+ Validate.notNull(file, "File cannot be null");
+
+ final FileInputStream stream = new FileInputStream(file);
+
+ load(new InputStreamReader(stream, Charsets.UTF_8));
+ }
+
+ /**
+ * Loads this {@link FileConfiguration} from the specified reader.
+ *
+ * All the values contained within this configuration will be removed,
+ * leaving only settings and defaults, and the new values will be loaded
+ * from the given stream.
+ *
+ * @param reader the reader to load from
+ * @throws IOException thrown when underlying reader throws an IOException
+ * @throws InvalidConfigurationException thrown when the reader does not
+ * represent a valid Configuration
+ * @throws IllegalArgumentException thrown when reader is null
+ */
+ public void load(@NotNull Reader reader) throws IOException, InvalidConfigurationException {
+ BufferedReader input = reader instanceof BufferedReader ? (BufferedReader) reader : new BufferedReader(reader);
+
+ StringBuilder builder = new StringBuilder();
+
+ try {
+ String line;
+
+ while ((line = input.readLine()) != null) {
+ builder.append(line);
+ builder.append('\n');
+ }
+ } finally {
+ input.close();
+ }
+
+ loadFromString(builder.toString());
+ }
+
+ /**
+ * Loads this {@link FileConfiguration} from the specified location.
+ *
+ * All the values contained within this configuration will be removed,
+ * leaving only settings and defaults, and the new values will be loaded
+ * from the given file.
+ *
+ * If the file cannot be loaded for any reason, an exception will be
+ * thrown.
+ *
+ * @param file File to load from.
+ * @throws FileNotFoundException Thrown when the given file cannot be
+ * opened.
+ * @throws IOException Thrown when the given file cannot be read.
+ * @throws InvalidConfigurationException Thrown when the given file is not
+ * a valid Configuration.
+ * @throws IllegalArgumentException Thrown when file is null.
+ */
+ public void load(@NotNull String file) throws FileNotFoundException, IOException, InvalidConfigurationException {
+ Validate.notNull(file, "File cannot be null");
+
+ load(new File(file));
+ }
+
+ /**
+ * Loads this {@link FileConfiguration} from the specified string, as
+ * opposed to from file.
+ *
+ * All the values contained within this configuration will be removed,
+ * leaving only settings and defaults, and the new values will be loaded
+ * from the given string.
+ *
+ * If the string is invalid in any way, an exception will be thrown.
+ *
+ * @param contents Contents of a Configuration to load.
+ * @throws InvalidConfigurationException Thrown if the specified string is
+ * invalid.
+ * @throws IllegalArgumentException Thrown if contents is null.
+ */
+ public abstract void loadFromString(@NotNull String contents) throws InvalidConfigurationException;
+
+ /**
+ * @return empty string
+ *
+ * @deprecated This method only exists for backwards compatibility. It will
+ * do nothing and should not be used! Please use
+ * {@link FileConfigurationOptions#getHeader()} instead.
+ */
+ @NotNull
+ @Deprecated
+ protected String buildHeader() {
+ return "";
+ }
+
+ @NotNull
+ @Override
+ public FileConfigurationOptions options() {
+ if (options == null) {
+ options = new FileConfigurationOptions(this);
+ }
+
+ return (FileConfigurationOptions) options;
+ }
+}
diff --git a/src/main/java/org/bukkit/configuration/file/FileConfigurationOptions.java b/src/main/java/org/bukkit/configuration/file/FileConfigurationOptions.java
new file mode 100644
index 0000000..c71f8a7
--- /dev/null
+++ b/src/main/java/org/bukkit/configuration/file/FileConfigurationOptions.java
@@ -0,0 +1,203 @@
+package org.bukkit.configuration.file;
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import org.bukkit.configuration.MemoryConfiguration;
+import org.bukkit.configuration.MemoryConfigurationOptions;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+/**
+ * Various settings for controlling the input and output of a {@link
+ * FileConfiguration}
+ */
+public class FileConfigurationOptions extends MemoryConfigurationOptions {
+ private List header = Collections.emptyList();
+ private List footer = Collections.emptyList();
+ private boolean parseComments = true;
+
+ protected FileConfigurationOptions(@NotNull MemoryConfiguration configuration) {
+ super(configuration);
+ }
+
+ @NotNull
+ @Override
+ public FileConfiguration configuration() {
+ return (FileConfiguration) super.configuration();
+ }
+
+ @NotNull
+ @Override
+ public FileConfigurationOptions copyDefaults(boolean value) {
+ super.copyDefaults(value);
+ return this;
+ }
+
+ @NotNull
+ @Override
+ public FileConfigurationOptions pathSeparator(char value) {
+ super.pathSeparator(value);
+ return this;
+ }
+
+ /**
+ * Gets the header that will be applied to the top of the saved output.
+ *
+ * This header will be commented out and applied directly at the top of
+ * the generated output of the {@link FileConfiguration}. It is not
+ * required to include a newline at the end of the header as it will
+ * automatically be applied, but you may include one if you wish for extra
+ * spacing.
+ *
+ * If no comments exist, an empty list will be returned. A null entry
+ * represents an empty line and an empty String represents an empty comment
+ * line.
+ *
+ * @return Unmodifiable header, every entry represents one line.
+ */
+ @NotNull
+ public List getHeader() {
+ return header;
+ }
+
+ /**
+ * @return The string header.
+ *
+ * @deprecated use getHeader() instead.
+ */
+ @NotNull
+ @Deprecated
+ public String header() {
+ StringBuilder stringHeader = new StringBuilder();
+ for (String line : header) {
+ stringHeader.append(line == null ? "\n" : line + "\n");
+ }
+ return stringHeader.toString();
+ }
+
+ /**
+ * Sets the header that will be applied to the top of the saved output.
+ *
+ * This header will be commented out and applied directly at the top of
+ * the generated output of the {@link FileConfiguration}. It is not
+ * required to include a newline at the end of the header as it will
+ * automatically be applied, but you may include one if you wish for extra
+ * spacing.
+ *
+ * If no comments exist, an empty list will be returned. A null entry
+ * represents an empty line and an empty String represents an empty comment
+ * line.
+ *
+ * @param value New header, every entry represents one line.
+ * @return This object, for chaining
+ */
+ @NotNull
+ public FileConfigurationOptions setHeader(@Nullable List value) {
+ this.header = (value == null) ? Collections.emptyList() : Collections.unmodifiableList(value);
+ return this;
+ }
+
+ /**
+ * @param value The string header.
+ * @return This object, for chaining.
+ *
+ * @deprecated use setHeader() instead
+ */
+ @NotNull
+ @Deprecated
+ public FileConfigurationOptions header(@Nullable String value) {
+ this.header = (value == null) ? Collections.emptyList() : Collections.unmodifiableList(Arrays.asList(value.split("\\n")));
+ return this;
+ }
+
+ /**
+ * Gets the footer that will be applied to the bottom of the saved output.
+ *
+ * This footer will be commented out and applied directly at the bottom of
+ * the generated output of the {@link FileConfiguration}. It is not required
+ * to include a newline at the beginning of the footer as it will
+ * automatically be applied, but you may include one if you wish for extra
+ * spacing.
+ *
+ * If no comments exist, an empty list will be returned. A null entry
+ * represents an empty line and an empty String represents an empty comment
+ * line.
+ *
+ * @return Unmodifiable footer, every entry represents one line.
+ */
+ @NotNull
+ public List getFooter() {
+ return footer;
+ }
+
+ /**
+ * Sets the footer that will be applied to the bottom of the saved output.
+ *
+ * This footer will be commented out and applied directly at the bottom of
+ * the generated output of the {@link FileConfiguration}. It is not required
+ * to include a newline at the beginning of the footer as it will
+ * automatically be applied, but you may include one if you wish for extra
+ * spacing.
+ *
+ * If no comments exist, an empty list will be returned. A null entry
+ * represents an empty line and an empty String represents an empty comment
+ * line.
+ *
+ * @param value New footer, every entry represents one line.
+ * @return This object, for chaining
+ */
+ @NotNull
+ public FileConfigurationOptions setFooter(@Nullable List value) {
+ this.footer = (value == null) ? Collections.emptyList() : Collections.unmodifiableList(value);
+ return this;
+ }
+
+ /**
+ * Gets whether or not comments should be loaded and saved.
+ *
+ * Defaults to true.
+ *
+ * @return Whether or not comments are parsed.
+ */
+ public boolean parseComments() {
+ return parseComments;
+ }
+
+ /**
+ * Sets whether or not comments should be loaded and saved.
+ *
+ * Defaults to true.
+ *
+ * @param value Whether or not comments are parsed.
+ * @return This object, for chaining
+ */
+ @NotNull
+ public MemoryConfigurationOptions parseComments(boolean value) {
+ parseComments = value;
+ return this;
+ }
+
+ /**
+ * @return Whether or not comments are parsed.
+ *
+ * @deprecated Call {@link #parseComments()} instead.
+ */
+ @Deprecated
+ public boolean copyHeader() {
+ return parseComments;
+ }
+
+ /**
+ * @param value Should comments be parsed.
+ * @return This object, for chaining
+ *
+ * @deprecated Call {@link #parseComments(boolean)} instead.
+ */
+ @NotNull
+ @Deprecated
+ public FileConfigurationOptions copyHeader(boolean value) {
+ parseComments = value;
+ return this;
+ }
+}
diff --git a/src/main/java/org/bukkit/configuration/file/YamlConfiguration.java b/src/main/java/org/bukkit/configuration/file/YamlConfiguration.java
new file mode 100644
index 0000000..f0a154f
--- /dev/null
+++ b/src/main/java/org/bukkit/configuration/file/YamlConfiguration.java
@@ -0,0 +1,341 @@
+package org.bukkit.configuration.file;
+
+import java.io.ByteArrayInputStream;
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.io.Reader;
+import java.io.StringWriter;
+import java.nio.charset.StandardCharsets;
+import java.util.ArrayList;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+import java.util.logging.Level;
+import org.apache.commons.lang.Validate;
+import org.bukkit.configuration.Configuration;
+import org.bukkit.configuration.ConfigurationSection;
+import org.bukkit.configuration.InvalidConfigurationException;
+import org.bukkit.configuration.serialization.ConfigurationSerialization;
+import org.jetbrains.annotations.NotNull;
+import org.yaml.snakeyaml.DumperOptions;
+import org.yaml.snakeyaml.LoaderOptions;
+import org.yaml.snakeyaml.Yaml;
+import org.yaml.snakeyaml.comments.CommentLine;
+import org.yaml.snakeyaml.comments.CommentType;
+import org.yaml.snakeyaml.error.YAMLException;
+import org.yaml.snakeyaml.nodes.AnchorNode;
+import org.yaml.snakeyaml.nodes.MappingNode;
+import org.yaml.snakeyaml.nodes.Node;
+import org.yaml.snakeyaml.nodes.NodeTuple;
+import org.yaml.snakeyaml.nodes.ScalarNode;
+import org.yaml.snakeyaml.nodes.SequenceNode;
+import org.yaml.snakeyaml.nodes.Tag;
+import org.yaml.snakeyaml.reader.UnicodeReader;
+
+/**
+ * An implementation of {@link Configuration} which saves all files in Yaml.
+ * Note that this implementation is not synchronized.
+ */
+public class YamlConfiguration extends FileConfiguration {
+ /**
+ * @deprecated unused, not intended to be API
+ */
+ @Deprecated
+ protected static final String COMMENT_PREFIX = "# ";
+ /**
+ * @deprecated unused, not intended to be API
+ */
+ @Deprecated
+ protected static final String BLANK_CONFIG = "{}\n";
+ private final DumperOptions yamlDumperOptions;
+ private final LoaderOptions yamlLoaderOptions;
+ private final YamlConstructor constructor;
+ private final YamlRepresenter representer;
+ private final Yaml yaml;
+
+ public YamlConfiguration() {
+ constructor = new YamlConstructor();
+ representer = new YamlRepresenter();
+ representer.setDefaultFlowStyle(DumperOptions.FlowStyle.BLOCK);
+
+ yamlDumperOptions = new DumperOptions();
+ yamlDumperOptions.setDefaultFlowStyle(DumperOptions.FlowStyle.BLOCK);
+ yamlLoaderOptions = new LoaderOptions();
+ yamlLoaderOptions.setMaxAliasesForCollections(Integer.MAX_VALUE); // SPIGOT-5881: Not ideal, but was default pre SnakeYAML 1.26
+
+ yaml = new BukkitYaml(constructor, representer, yamlDumperOptions, yamlLoaderOptions);
+ }
+
+ @NotNull
+ @Override
+ public String saveToString() {
+ yamlDumperOptions.setIndent(options().indent());
+ yamlDumperOptions.setWidth(options().width());
+ yamlDumperOptions.setProcessComments(options().parseComments());
+
+ MappingNode node = toNodeTree(this);
+
+ node.setBlockComments(getCommentLines(saveHeader(options().getHeader()), CommentType.BLOCK));
+ node.setEndComments(getCommentLines(options().getFooter(), CommentType.BLOCK));
+
+ StringWriter writer = new StringWriter();
+ if (node.getBlockComments().isEmpty() && node.getEndComments().isEmpty() && node.getValue().isEmpty()) {
+ writer.write("");
+ } else {
+ if (node.getValue().isEmpty()) {
+ node.setFlowStyle(DumperOptions.FlowStyle.FLOW);
+ }
+ yaml.serialize(node, writer);
+ }
+ return writer.toString();
+ }
+
+ @Override
+ public void loadFromString(@NotNull String contents) throws InvalidConfigurationException {
+ Validate.notNull(contents, "String cannot be null");
+ yamlLoaderOptions.setProcessComments(options().parseComments());
+
+ MappingNode node;
+ try (Reader reader = new UnicodeReader(new ByteArrayInputStream(contents.getBytes(StandardCharsets.UTF_8)))) {
+ node = (MappingNode) yaml.compose(reader);
+ } catch (YAMLException | IOException e) {
+ throw new InvalidConfigurationException(e);
+ } catch (ClassCastException e) {
+ throw new InvalidConfigurationException("Top level is not a Map.");
+ }
+
+ this.map.clear();
+
+ if (node != null) {
+ adjustNodeComments(node);
+ options().setHeader(loadHeader(getCommentLines(node.getBlockComments())));
+ options().setFooter(getCommentLines(node.getEndComments()));
+ fromNodeTree(node, this);
+ }
+ }
+
+ /**
+ * This method splits the header on the last empty line, and sets the
+ * comments below this line as comments for the first key on the map object.
+ *
+ * @param node The root node of the yaml object
+ */
+ private void adjustNodeComments(final MappingNode node) {
+ if (node.getBlockComments() == null && !node.getValue().isEmpty()) {
+ Node firstNode = node.getValue().get(0).getKeyNode();
+ List lines = firstNode.getBlockComments();
+ if (lines != null) {
+ int index = -1;
+ for (int i = 0; i < lines.size(); i++) {
+ if (lines.get(i).getCommentType() == CommentType.BLANK_LINE) {
+ index = i;
+ }
+ }
+ if (index != -1) {
+ node.setBlockComments(lines.subList(0, index + 1));
+ firstNode.setBlockComments(lines.subList(index + 1, lines.size()));
+ }
+ }
+ }
+ }
+
+ private void fromNodeTree(@NotNull MappingNode input, @NotNull ConfigurationSection section) {
+ constructor.flattenMapping(input);
+ for (NodeTuple nodeTuple : input.getValue()) {
+ Node key = nodeTuple.getKeyNode();
+ String keyString = String.valueOf(constructor.construct(key));
+ Node value = nodeTuple.getValueNode();
+
+ while (value instanceof AnchorNode) {
+ value = ((AnchorNode) value).getRealNode();
+ }
+
+ if (value instanceof MappingNode && !hasSerializedTypeKey((MappingNode) value)) {
+ fromNodeTree((MappingNode) value, section.createSection(keyString));
+ } else {
+ section.set(keyString, constructor.construct(value));
+ }
+
+ section.setComments(keyString, getCommentLines(key.getBlockComments()));
+ if (value instanceof MappingNode || value instanceof SequenceNode) {
+ section.setInlineComments(keyString, getCommentLines(key.getInLineComments()));
+ } else {
+ section.setInlineComments(keyString, getCommentLines(value.getInLineComments()));
+ }
+ }
+ }
+
+ private boolean hasSerializedTypeKey(MappingNode node) {
+ for (NodeTuple nodeTuple : node.getValue()) {
+ Node keyNode = nodeTuple.getKeyNode();
+ if (!(keyNode instanceof ScalarNode)) continue;
+ String key = ((ScalarNode) keyNode).getValue();
+ if (key.equals(ConfigurationSerialization.SERIALIZED_TYPE_KEY)) {
+ return true;
+ }
+ }
+ return false;
+ }
+
+ private MappingNode toNodeTree(@NotNull ConfigurationSection section) {
+ List nodeTuples = new ArrayList<>();
+ for (Map.Entry entry : section.getValues(false).entrySet()) {
+ Node key = representer.represent(entry.getKey());
+ Node value;
+ if (entry.getValue() instanceof ConfigurationSection) {
+ value = toNodeTree((ConfigurationSection) entry.getValue());
+ } else {
+ value = representer.represent(entry.getValue());
+ }
+ key.setBlockComments(getCommentLines(section.getComments(entry.getKey()), CommentType.BLOCK));
+ if (value instanceof MappingNode || value instanceof SequenceNode) {
+ key.setInLineComments(getCommentLines(section.getInlineComments(entry.getKey()), CommentType.IN_LINE));
+ } else {
+ value.setInLineComments(getCommentLines(section.getInlineComments(entry.getKey()), CommentType.IN_LINE));
+ }
+
+ nodeTuples.add(new NodeTuple(key, value));
+ }
+
+ return new MappingNode(Tag.MAP, nodeTuples, DumperOptions.FlowStyle.BLOCK);
+ }
+
+ private List getCommentLines(List comments) {
+ List lines = new ArrayList<>();
+ if (comments != null) {
+ for (CommentLine comment : comments) {
+ if (comment.getCommentType() == CommentType.BLANK_LINE) {
+ lines.add(null);
+ } else {
+ String line = comment.getValue();
+ line = line.startsWith(" ") ? line.substring(1) : line;
+ lines.add(line);
+ }
+ }
+ }
+ return lines;
+ }
+
+ private List getCommentLines(List comments, CommentType commentType) {
+ List lines = new ArrayList();
+ for (String comment : comments) {
+ if (comment == null) {
+ lines.add(new CommentLine(null, null, "", CommentType.BLANK_LINE));
+ } else {
+ String line = comment;
+ line = line.isEmpty() ? line : " " + line;
+ lines.add(new CommentLine(null, null, line, commentType));
+ }
+ }
+ return lines;
+ }
+
+ /**
+ * Removes the empty line at the end of the header that separates the header
+ * from further comments. Also removes all empty header starts (backwards
+ * compat).
+ *
+ * @param header The list of heading comments
+ * @return The modified list
+ */
+ private List loadHeader(List header) {
+ LinkedList list = new LinkedList<>(header);
+
+ if (!list.isEmpty()) {
+ list.removeLast();
+ }
+
+ while (!list.isEmpty() && list.peek() == null) {
+ list.remove();
+ }
+
+ return list;
+ }
+
+ /**
+ * Adds the empty line at the end of the header that separates the header
+ * from further comments.
+ *
+ * @param header The list of heading comments
+ * @return The modified list
+ */
+ private List saveHeader(List header) {
+ LinkedList list = new LinkedList<>(header);
+
+ if (!list.isEmpty()) {
+ list.add(null);
+ }
+
+ return list;
+ }
+
+ @NotNull
+ @Override
+ public YamlConfigurationOptions options() {
+ if (options == null) {
+ options = new YamlConfigurationOptions(this);
+ }
+
+ return (YamlConfigurationOptions) options;
+ }
+
+ /**
+ * Creates a new {@link YamlConfiguration}, loading from the given file.
+ *
+ * Any errors loading the Configuration will be logged and then ignored.
+ * If the specified input is not a valid config, a blank config will be
+ * returned.
+ *
+ * The encoding used may follow the system dependent default.
+ *
+ * @param file Input file
+ * @return Resulting configuration
+ * @throws IllegalArgumentException Thrown if file is null
+ */
+ @NotNull
+ public static YamlConfiguration loadConfiguration(@NotNull File file) {
+ Validate.notNull(file, "File cannot be null");
+
+ YamlConfiguration config = new YamlConfiguration();
+
+ try {
+ config.load(file);
+ } catch (FileNotFoundException ex) {
+ } catch (IOException ex) {
+ ex.printStackTrace();
+ } catch (InvalidConfigurationException ex) {
+ ex.printStackTrace();
+ }
+
+ return config;
+ }
+
+ /**
+ * Creates a new {@link YamlConfiguration}, loading from the given reader.
+ *
+ * Any errors loading the Configuration will be logged and then ignored.
+ * If the specified input is not a valid config, a blank config will be
+ * returned.
+ *
+ * @param reader input
+ * @return resulting configuration
+ * @throws IllegalArgumentException Thrown if stream is null
+ */
+ @NotNull
+ public static YamlConfiguration loadConfiguration(@NotNull Reader reader) {
+ Validate.notNull(reader, "Stream cannot be null");
+
+ YamlConfiguration config = new YamlConfiguration();
+
+ try {
+ config.load(reader);
+ } catch (IOException ex) {
+ ex.printStackTrace();
+ } catch (InvalidConfigurationException ex) {
+ ex.printStackTrace();
+ }
+
+ return config;
+ }
+}
diff --git a/src/main/java/org/bukkit/configuration/file/YamlConfigurationOptions.java b/src/main/java/org/bukkit/configuration/file/YamlConfigurationOptions.java
new file mode 100644
index 0000000..7d244fa
--- /dev/null
+++ b/src/main/java/org/bukkit/configuration/file/YamlConfigurationOptions.java
@@ -0,0 +1,125 @@
+package org.bukkit.configuration.file;
+
+import java.util.List;
+import org.apache.commons.lang.Validate;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+/**
+ * Various settings for controlling the input and output of a {@link
+ * YamlConfiguration}
+ */
+public class YamlConfigurationOptions extends FileConfigurationOptions {
+ private int indent = 2;
+ private int width = 80;
+
+ protected YamlConfigurationOptions(@NotNull YamlConfiguration configuration) {
+ super(configuration);
+ }
+
+ @NotNull
+ @Override
+ public YamlConfiguration configuration() {
+ return (YamlConfiguration) super.configuration();
+ }
+
+ @NotNull
+ @Override
+ public YamlConfigurationOptions copyDefaults(boolean value) {
+ super.copyDefaults(value);
+ return this;
+ }
+
+ @NotNull
+ @Override
+ public YamlConfigurationOptions pathSeparator(char value) {
+ super.pathSeparator(value);
+ return this;
+ }
+
+ @NotNull
+ @Override
+ public YamlConfigurationOptions setHeader(@Nullable List value) {
+ super.setHeader(value);
+ return this;
+ }
+
+ @NotNull
+ @Override
+ @Deprecated
+ public YamlConfigurationOptions header(@Nullable String value) {
+ super.header(value);
+ return this;
+ }
+
+ @NotNull
+ @Override
+ public YamlConfigurationOptions setFooter(@Nullable List value) {
+ super.setFooter(value);
+ return this;
+ }
+
+ @NotNull
+ @Override
+ public YamlConfigurationOptions parseComments(boolean value) {
+ super.parseComments(value);
+ return this;
+ }
+
+ @NotNull
+ @Override
+ @Deprecated
+ public YamlConfigurationOptions copyHeader(boolean value) {
+ super.copyHeader(value);
+ return this;
+ }
+
+ /**
+ * Gets how much spaces should be used to indent each line.
+ *
+ * The minimum value this may be is 2, and the maximum is 9.
+ *
+ * @return How much to indent by
+ */
+ public int indent() {
+ return indent;
+ }
+
+ /**
+ * Sets how much spaces should be used to indent each line.
+ *
+ * The minimum value this may be is 2, and the maximum is 9.
+ *
+ * @param value New indent
+ * @return This object, for chaining
+ */
+ @NotNull
+ public YamlConfigurationOptions indent(int value) {
+ Validate.isTrue(value >= 2, "Indent must be at least 2 characters");
+ Validate.isTrue(value <= 9, "Indent cannot be greater than 9 characters");
+
+ this.indent = value;
+ return this;
+ }
+
+ /**
+ * Gets how long a line can be, before it gets split.
+ *
+ * @return How the max line width
+ */
+ public int width() {
+ return width;
+ }
+
+ /**
+ * Sets how long a line can be, before it gets split.
+ *
+ * @param value New width
+ * @return This object, for chaining
+ */
+ @NotNull
+ public YamlConfigurationOptions width(int value) {
+ this.width = value;
+ return this;
+ }
+}
diff --git a/src/main/java/org/bukkit/configuration/file/YamlConstructor.java b/src/main/java/org/bukkit/configuration/file/YamlConstructor.java
new file mode 100644
index 0000000..0925994
--- /dev/null
+++ b/src/main/java/org/bukkit/configuration/file/YamlConstructor.java
@@ -0,0 +1,62 @@
+package org.bukkit.configuration.file;
+
+import java.util.LinkedHashMap;
+import java.util.Map;
+import org.bukkit.configuration.serialization.ConfigurationSerialization;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import org.yaml.snakeyaml.constructor.SafeConstructor;
+import org.yaml.snakeyaml.error.YAMLException;
+import org.yaml.snakeyaml.nodes.MappingNode;
+import org.yaml.snakeyaml.nodes.Node;
+import org.yaml.snakeyaml.nodes.Tag;
+
+public class YamlConstructor extends SafeConstructor {
+
+ public YamlConstructor() {
+ this.yamlConstructors.put(Tag.MAP, new ConstructCustomObject());
+ }
+
+ @Override
+ public void flattenMapping(@NotNull final MappingNode node) {
+ super.flattenMapping(node);
+ }
+
+ @Nullable
+ public Object construct(@NotNull Node node) {
+ return constructObject(node);
+ }
+
+ private class ConstructCustomObject extends ConstructYamlMap {
+
+ @Nullable
+ @Override
+ public Object construct(@NotNull Node node) {
+ if (node.isTwoStepsConstruction()) {
+ throw new YAMLException("Unexpected referential mapping structure. Node: " + node);
+ }
+
+ Map raw = (Map) super.construct(node);
+
+ if (raw.containsKey(ConfigurationSerialization.SERIALIZED_TYPE_KEY)) {
+ Map typed = new LinkedHashMap(raw.size());
+ for (Map.Entry entry : raw.entrySet()) {
+ typed.put(entry.getKey().toString(), entry.getValue());
+ }
+
+ try {
+ return ConfigurationSerialization.deserializeObject(typed);
+ } catch (IllegalArgumentException ex) {
+ throw new YAMLException("Could not deserialize object", ex);
+ }
+ }
+
+ return raw;
+ }
+
+ @Override
+ public void construct2ndStep(@NotNull Node node, @NotNull Object object) {
+ throw new YAMLException("Unexpected referential mapping structure. Node: " + node);
+ }
+ }
+}
diff --git a/src/main/java/org/bukkit/configuration/file/YamlRepresenter.java b/src/main/java/org/bukkit/configuration/file/YamlRepresenter.java
new file mode 100644
index 0000000..3569c19
--- /dev/null
+++ b/src/main/java/org/bukkit/configuration/file/YamlRepresenter.java
@@ -0,0 +1,46 @@
+package org.bukkit.configuration.file;
+
+import java.util.LinkedHashMap;
+import java.util.Map;
+import org.bukkit.configuration.ConfigurationSection;
+import org.bukkit.configuration.serialization.ConfigurationSerializable;
+import org.bukkit.configuration.serialization.ConfigurationSerialization;
+import org.jetbrains.annotations.NotNull;
+import org.yaml.snakeyaml.nodes.Node;
+import org.yaml.snakeyaml.representer.Representer;
+
+public class YamlRepresenter extends Representer {
+
+ public YamlRepresenter() {
+ super();
+ this.multiRepresenters.put(ConfigurationSection.class, new RepresentConfigurationSection());
+ this.multiRepresenters.put(ConfigurationSerializable.class, new RepresentConfigurationSerializable());
+ // SPIGOT-6234: We could just switch YamlConstructor to extend Constructor rather than SafeConstructor, however there is a very small risk of issues with plugins treating config as untrusted input
+ // So instead we will just allow future plugins to have their enums extend ConfigurationSerializable
+ this.multiRepresenters.remove(Enum.class);
+ }
+
+ // SPIGOT-6949: Used by configuration sections that are nested within lists or maps.
+ private class RepresentConfigurationSection extends RepresentMap {
+
+ @NotNull
+ @Override
+ public Node representData(@NotNull Object data) {
+ return super.representData(((ConfigurationSection) data).getValues(false));
+ }
+ }
+
+ private class RepresentConfigurationSerializable extends RepresentMap {
+
+ @NotNull
+ @Override
+ public Node representData(@NotNull Object data) {
+ ConfigurationSerializable serializable = (ConfigurationSerializable) data;
+ Map values = new LinkedHashMap();
+ values.put(ConfigurationSerialization.SERIALIZED_TYPE_KEY, ConfigurationSerialization.getAlias(serializable.getClass()));
+ values.putAll(serializable.serialize());
+
+ return super.representData(values);
+ }
+ }
+}
diff --git a/src/main/java/org/bukkit/configuration/serialization/ConfigurationSerializable.java b/src/main/java/org/bukkit/configuration/serialization/ConfigurationSerializable.java
new file mode 100644
index 0000000..177944d
--- /dev/null
+++ b/src/main/java/org/bukkit/configuration/serialization/ConfigurationSerializable.java
@@ -0,0 +1,37 @@
+package org.bukkit.configuration.serialization;
+
+import java.util.Map;
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * Represents an object that may be serialized.
+ *
+ * These objects MUST implement one of the following, in addition to the
+ * methods as defined by this interface:
+ *
+ *
A static method "deserialize" that accepts a single {@link Map}<
+ * {@link String}, {@link Object}> and returns the class.
+ *
A static method "valueOf" that accepts a single {@link Map}<{@link
+ * String}, {@link Object}> and returns the class.
+ *
A constructor that accepts a single {@link Map}<{@link String},
+ * {@link Object}>.
+ *
+ * In addition to implementing this interface, you must register the class
+ * with {@link ConfigurationSerialization#registerClass(Class)}.
+ *
+ * @see DelegateDeserialization
+ * @see SerializableAs
+ */
+public interface ConfigurationSerializable {
+
+ /**
+ * Creates a Map representation of this class.
+ *
+ * This class must provide a method to restore this class, as defined in
+ * the {@link ConfigurationSerializable} interface javadocs.
+ *
+ * @return Map containing the current state of this class
+ */
+ @NotNull
+ public Map serialize();
+}
diff --git a/src/main/java/org/bukkit/configuration/serialization/ConfigurationSerialization.java b/src/main/java/org/bukkit/configuration/serialization/ConfigurationSerialization.java
new file mode 100644
index 0000000..ddd570d
--- /dev/null
+++ b/src/main/java/org/bukkit/configuration/serialization/ConfigurationSerialization.java
@@ -0,0 +1,276 @@
+package org.bukkit.configuration.serialization;
+
+import java.lang.reflect.Constructor;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.lang.reflect.Modifier;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+import org.apache.commons.lang.Validate;
+import org.bukkit.configuration.Configuration;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+/**
+ * Utility class for storing and retrieving classes for {@link Configuration}.
+ */
+public class ConfigurationSerialization {
+ public static final String SERIALIZED_TYPE_KEY = "==";
+ private final Class clazz;
+ private static Map> aliases = new HashMap>();
+
+ protected ConfigurationSerialization(@NotNull Class clazz) {
+ this.clazz = clazz;
+ }
+
+ @Nullable
+ protected Method getMethod(@NotNull String name, boolean isStatic) {
+ try {
+ Method method = clazz.getDeclaredMethod(name, Map.class);
+
+ if (!ConfigurationSerializable.class.isAssignableFrom(method.getReturnType())) {
+ return null;
+ }
+ if (Modifier.isStatic(method.getModifiers()) != isStatic) {
+ return null;
+ }
+
+ return method;
+ } catch (NoSuchMethodException ex) {
+ return null;
+ } catch (SecurityException ex) {
+ return null;
+ }
+ }
+
+ @Nullable
+ protected Constructor getConstructor() {
+ try {
+ return clazz.getConstructor(Map.class);
+ } catch (NoSuchMethodException ex) {
+ return null;
+ } catch (SecurityException ex) {
+ return null;
+ }
+ }
+
+ @Nullable
+ protected ConfigurationSerializable deserializeViaMethod(@NotNull Method method, @NotNull Map args) {
+ try {
+ ConfigurationSerializable result = (ConfigurationSerializable) method.invoke(null, args);
+
+ if (result == null) {
+ Logger.getLogger(ConfigurationSerialization.class.getName()).log(Level.SEVERE, "Could not call method '" + method.toString() + "' of " + clazz + " for deserialization: method returned null");
+ } else {
+ return result;
+ }
+ } catch (Throwable ex) {
+ Logger.getLogger(ConfigurationSerialization.class.getName()).log(
+ Level.SEVERE,
+ "Could not call method '" + method.toString() + "' of " + clazz + " for deserialization",
+ ex instanceof InvocationTargetException ? ex.getCause() : ex);
+ }
+
+ return null;
+ }
+
+ @Nullable
+ protected ConfigurationSerializable deserializeViaCtor(@NotNull Constructor ctor, @NotNull Map args) {
+ try {
+ return ctor.newInstance(args);
+ } catch (Throwable ex) {
+ Logger.getLogger(ConfigurationSerialization.class.getName()).log(
+ Level.SEVERE,
+ "Could not call constructor '" + ctor.toString() + "' of " + clazz + " for deserialization",
+ ex instanceof InvocationTargetException ? ex.getCause() : ex);
+ }
+
+ return null;
+ }
+
+ @Nullable
+ public ConfigurationSerializable deserialize(@NotNull Map args) {
+ Validate.notNull(args, "Args must not be null");
+
+ ConfigurationSerializable result = null;
+ Method method = null;
+
+ if (result == null) {
+ method = getMethod("deserialize", true);
+
+ if (method != null) {
+ result = deserializeViaMethod(method, args);
+ }
+ }
+
+ if (result == null) {
+ method = getMethod("valueOf", true);
+
+ if (method != null) {
+ result = deserializeViaMethod(method, args);
+ }
+ }
+
+ if (result == null) {
+ Constructor constructor = getConstructor();
+
+ if (constructor != null) {
+ result = deserializeViaCtor(constructor, args);
+ }
+ }
+
+ return result;
+ }
+
+ /**
+ * Attempts to deserialize the given arguments into a new instance of the
+ * given class.
+ *
+ * The class must implement {@link ConfigurationSerializable}, including
+ * the extra methods as specified in the javadoc of
+ * ConfigurationSerializable.
+ *
+ * If a new instance could not be made, an example being the class not
+ * fully implementing the interface, null will be returned.
+ *
+ * @param args Arguments for deserialization
+ * @param clazz Class to deserialize into
+ * @return New instance of the specified class
+ */
+ @Nullable
+ public static ConfigurationSerializable deserializeObject(@NotNull Map args, @NotNull Class clazz) {
+ return new ConfigurationSerialization(clazz).deserialize(args);
+ }
+
+ /**
+ * Attempts to deserialize the given arguments into a new instance of the
+ * given class.
+ *
+ * The class must implement {@link ConfigurationSerializable}, including
+ * the extra methods as specified in the javadoc of
+ * ConfigurationSerializable.
+ *
+ * If a new instance could not be made, an example being the class not
+ * fully implementing the interface, null will be returned.
+ *
+ * @param args Arguments for deserialization
+ * @return New instance of the specified class
+ */
+ @Nullable
+ public static ConfigurationSerializable deserializeObject(@NotNull Map args) {
+ Class clazz = null;
+
+ if (args.containsKey(SERIALIZED_TYPE_KEY)) {
+ try {
+ String alias = (String) args.get(SERIALIZED_TYPE_KEY);
+
+ if (alias == null) {
+ throw new IllegalArgumentException("Cannot have null alias");
+ }
+ clazz = getClassByAlias(alias);
+ if (clazz == null) {
+ throw new IllegalArgumentException("Specified class does not exist ('" + alias + "')");
+ }
+ } catch (ClassCastException ex) {
+ ex.fillInStackTrace();
+ throw ex;
+ }
+ } else {
+ throw new IllegalArgumentException("Args doesn't contain type key ('" + SERIALIZED_TYPE_KEY + "')");
+ }
+
+ return new ConfigurationSerialization(clazz).deserialize(args);
+ }
+
+ /**
+ * Registers the given {@link ConfigurationSerializable} class by its
+ * alias
+ *
+ * @param clazz Class to register
+ */
+ public static void registerClass(@NotNull Class clazz) {
+ DelegateDeserialization delegate = clazz.getAnnotation(DelegateDeserialization.class);
+
+ if (delegate == null) {
+ registerClass(clazz, getAlias(clazz));
+ registerClass(clazz, clazz.getName());
+ }
+ }
+
+ /**
+ * Registers the given alias to the specified {@link
+ * ConfigurationSerializable} class
+ *
+ * @param clazz Class to register
+ * @param alias Alias to register as
+ * @see SerializableAs
+ */
+ public static void registerClass(@NotNull Class clazz, @NotNull String alias) {
+ aliases.put(alias, clazz);
+ }
+
+ /**
+ * Unregisters the specified alias to a {@link ConfigurationSerializable}
+ *
+ * @param alias Alias to unregister
+ */
+ public static void unregisterClass(@NotNull String alias) {
+ aliases.remove(alias);
+ }
+
+ /**
+ * Unregisters any aliases for the specified {@link
+ * ConfigurationSerializable} class
+ *
+ * @param clazz Class to unregister
+ */
+ public static void unregisterClass(@NotNull Class clazz) {
+ while (aliases.values().remove(clazz)) {
+ ;
+ }
+ }
+
+ /**
+ * Attempts to get a registered {@link ConfigurationSerializable} class by
+ * its alias
+ *
+ * @param alias Alias of the serializable
+ * @return Registered class, or null if not found
+ */
+ @Nullable
+ public static Class getClassByAlias(@NotNull String alias) {
+ return aliases.get(alias);
+ }
+
+ /**
+ * Gets the correct alias for the given {@link ConfigurationSerializable}
+ * class
+ *
+ * @param clazz Class to get alias for
+ * @return Alias to use for the class
+ */
+ @NotNull
+ public static String getAlias(@NotNull Class clazz) {
+ DelegateDeserialization delegate = clazz.getAnnotation(DelegateDeserialization.class);
+
+ if (delegate != null) {
+ if ((delegate.value() == null) || (delegate.value() == clazz)) {
+ delegate = null;
+ } else {
+ return getAlias(delegate.value());
+ }
+ }
+
+ if (delegate == null) {
+ SerializableAs alias = clazz.getAnnotation(SerializableAs.class);
+
+ if ((alias != null) && (alias.value() != null)) {
+ return alias.value();
+ }
+ }
+
+ return clazz.getName();
+ }
+}
diff --git a/src/main/java/org/bukkit/configuration/serialization/DelegateDeserialization.java b/src/main/java/org/bukkit/configuration/serialization/DelegateDeserialization.java
new file mode 100644
index 0000000..1383961
--- /dev/null
+++ b/src/main/java/org/bukkit/configuration/serialization/DelegateDeserialization.java
@@ -0,0 +1,24 @@
+package org.bukkit.configuration.serialization;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * Applies to a {@link ConfigurationSerializable} that will delegate all
+ * deserialization to another {@link ConfigurationSerializable}.
+ */
+@Retention(RetentionPolicy.RUNTIME)
+@Target(ElementType.TYPE)
+public @interface DelegateDeserialization {
+ /**
+ * Which class should be used as a delegate for this classes
+ * deserialization
+ *
+ * @return Delegate class
+ */
+ @NotNull
+ public Class value();
+}
diff --git a/src/main/java/org/bukkit/configuration/serialization/SerializableAs.java b/src/main/java/org/bukkit/configuration/serialization/SerializableAs.java
new file mode 100644
index 0000000..725685e
--- /dev/null
+++ b/src/main/java/org/bukkit/configuration/serialization/SerializableAs.java
@@ -0,0 +1,36 @@
+package org.bukkit.configuration.serialization;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * Represents an "alias" that a {@link ConfigurationSerializable} may be
+ * stored as.
+ * If this is not present on a {@link ConfigurationSerializable} class, it
+ * will use the fully qualified name of the class.
+ *
+ * This value will be stored in the configuration so that the configuration
+ * deserialization can determine what type it is.
+ *
+ * Using this annotation on any other class than a {@link
+ * ConfigurationSerializable} will have no effect.
+ *
+ * @see ConfigurationSerialization#registerClass(Class, String)
+ */
+@Retention(RetentionPolicy.RUNTIME)
+@Target(ElementType.TYPE)
+public @interface SerializableAs {
+ /**
+ * This is the name your class will be stored and retrieved as.
+ *
+ * This name MUST be unique. We recommend using names such as
+ * "MyPluginThing" instead of "Thing".
+ *
+ * @return Name to serialize the class as.
+ */
+ @NotNull
+ public String value();
+}
diff --git a/src/main/java/org/bukkit/util/NumberConversions.java b/src/main/java/org/bukkit/util/NumberConversions.java
new file mode 100644
index 0000000..a3ce71b
--- /dev/null
+++ b/src/main/java/org/bukkit/util/NumberConversions.java
@@ -0,0 +1,124 @@
+package org.bukkit.util;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+public final class NumberConversions {
+ private NumberConversions() {}
+
+ public static int floor(double num) {
+ final int floor = (int) num;
+ return floor == num ? floor : floor - (int) (Double.doubleToRawLongBits(num) >>> 63);
+ }
+
+ public static int ceil(final double num) {
+ final int floor = (int) num;
+ return floor == num ? floor : floor + (int) (~Double.doubleToRawLongBits(num) >>> 63);
+ }
+
+ public static int round(double num) {
+ return floor(num + 0.5d);
+ }
+
+ public static double square(double num) {
+ return num * num;
+ }
+
+ public static int toInt(@Nullable Object object) {
+ if (object instanceof Number) {
+ return ((Number) object).intValue();
+ }
+
+ try {
+ return Integer.parseInt(object.toString());
+ } catch (NumberFormatException e) {
+ } catch (NullPointerException e) {
+ }
+ return 0;
+ }
+
+ public static float toFloat(@Nullable Object object) {
+ if (object instanceof Number) {
+ return ((Number) object).floatValue();
+ }
+
+ try {
+ return Float.parseFloat(object.toString());
+ } catch (NumberFormatException e) {
+ } catch (NullPointerException e) {
+ }
+ return 0;
+ }
+
+ public static double toDouble(@Nullable Object object) {
+ if (object instanceof Number) {
+ return ((Number) object).doubleValue();
+ }
+
+ try {
+ return Double.parseDouble(object.toString());
+ } catch (NumberFormatException e) {
+ } catch (NullPointerException e) {
+ }
+ return 0;
+ }
+
+ public static long toLong(@Nullable Object object) {
+ if (object instanceof Number) {
+ return ((Number) object).longValue();
+ }
+
+ try {
+ return Long.parseLong(object.toString());
+ } catch (NumberFormatException e) {
+ } catch (NullPointerException e) {
+ }
+ return 0;
+ }
+
+ public static short toShort(@Nullable Object object) {
+ if (object instanceof Number) {
+ return ((Number) object).shortValue();
+ }
+
+ try {
+ return Short.parseShort(object.toString());
+ } catch (NumberFormatException e) {
+ } catch (NullPointerException e) {
+ }
+ return 0;
+ }
+
+ public static byte toByte(@Nullable Object object) {
+ if (object instanceof Number) {
+ return ((Number) object).byteValue();
+ }
+
+ try {
+ return Byte.parseByte(object.toString());
+ } catch (NumberFormatException e) {
+ } catch (NullPointerException e) {
+ }
+ return 0;
+ }
+
+ public static boolean isFinite(double d) {
+ return Math.abs(d) <= Double.MAX_VALUE;
+ }
+
+ public static boolean isFinite(float f) {
+ return Math.abs(f) <= Float.MAX_VALUE;
+ }
+
+ public static void checkFinite(double d, @NotNull String message) {
+ if (!isFinite(d)) {
+ throw new IllegalArgumentException(message);
+ }
+ }
+
+ public static void checkFinite(float d, @NotNull String message) {
+ if (!isFinite(d)) {
+ throw new IllegalArgumentException(message);
+ }
+ }
+}
diff --git a/src/main/java/org/json/JSONArray.java b/src/main/java/org/json/JSONArray.java
new file mode 100644
index 0000000..1ae70b1
--- /dev/null
+++ b/src/main/java/org/json/JSONArray.java
@@ -0,0 +1,1517 @@
+package org.json;
+
+/*
+ Copyright (c) 2002 JSON.org
+
+ Permission is hereby granted, free of charge, to any person obtaining a copy
+ of this software and associated documentation files (the "Software"), to deal
+ in the Software without restriction, including without limitation the rights
+ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ copies of the Software, and to permit persons to whom the Software is
+ furnished to do so, subject to the following conditions:
+
+ The above copyright notice and this permission notice shall be included in all
+ copies or substantial portions of the Software.
+
+ The Software shall be used for Good, not Evil.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ SOFTWARE.
+ */
+
+import java.io.IOException;
+import java.io.StringWriter;
+import java.io.Writer;
+import java.lang.reflect.Array;
+import java.math.BigDecimal;
+import java.math.BigInteger;
+import java.util.*;
+
+
+/**
+ * A JSONArray is an ordered sequence of values. Its external text form is a
+ * string wrapped in square brackets with commas separating the values. The
+ * internal form is an object having get and opt
+ * methods for accessing the values by index, and put methods for
+ * adding or replacing values. The values can be any of these types:
+ * Boolean, JSONArray, JSONObject,
+ * Number, String, or the
+ * JSONObject.NULL object.
+ *
+ * The constructor can convert a JSON text into a Java object. The
+ * toString method converts to JSON text.
+ *
+ * A get method returns a value if one can be found, and throws an
+ * exception if one cannot be found. An opt method returns a
+ * default value instead of throwing an exception, and so is useful for
+ * obtaining optional values.
+ *
+ * The generic get() and opt() methods return an
+ * object which you can cast or query for type. There are also typed
+ * get and opt methods that do type checking and type
+ * coercion for you.
+ *
+ * The texts produced by the toString methods strictly conform to
+ * JSON syntax rules. The constructors are more forgiving in the texts they will
+ * accept:
+ *
+ *
An extra , (comma) may appear just
+ * before the closing bracket.
+ *
The null value will be inserted when there is ,
+ * (comma) elision.
+ *
Strings may be quoted with ' (single
+ * quote).
+ *
Strings do not need to be quoted at all if they do not begin with a quote
+ * or single quote, and if they do not contain leading or trailing spaces, and
+ * if they do not contain any of these characters:
+ * { } [ ] / \ : , # and if they do not look like numbers and
+ * if they are not the reserved words true, false, or
+ * null.