+ *
+ * @version 3.3.3
+ */
+@SuppressWarnings({"unused", "WeakerAccess"}) @NoArgsConstructor public class PlotAPI {
+
+ /**
+ * Get all plots.
+ *
+ * @return all plots
+ * @see PlotSquared#getPlots()
+ */
+ public Set getAllPlots() {
+ return PlotSquared.get().getPlots();
+ }
+
+ /**
+ * Return all plots for a player.
+ *
+ * @param player Player, whose plots to search for
+ * @return all plots that a player owns
+ */
+ public Set getPlayerPlots(PlotPlayer player) {
+ return PlotSquared.get().getPlots(player);
+ }
+
+ /**
+ * Add a plot world.
+ *
+ * @param plotArea Plot World Object
+ * @see PlotSquared#addPlotArea(PlotArea)
+ */
+ public void addPlotArea(PlotArea plotArea) {
+ PlotSquared.get().addPlotArea(plotArea);
+ }
+
+ /**
+ * Returns the PlotSquared configurations file.
+ *
+ * @return main configuration
+ * @see PlotSquared#config
+ */
+ public YamlConfiguration getConfig() {
+ return PlotSquared.get().config;
+ }
+
+ /**
+ * Get the PlotSquared storage file.
+ *
+ * @return storage configuration
+ * @see PlotSquared#storage
+ */
+ public YamlConfiguration getStorage() {
+ return PlotSquared.get().storage;
+ }
+
+ /**
+ * Get the main class for this plugin. Only use this if you really need it.
+ *
+ * @return PlotSquared PlotSquared Main Class
+ * @see PlotSquared
+ */
+ public PlotSquared getMain() {
+ return PlotSquared.get();
+ }
+
+ /**
+ * ChunkManager class contains several useful methods.
+ *
+ *
Chunk deletion
+ *
Moving or copying regions
+ *
Plot swapping
+ *
Entity Tracking
+ *
Region Regeneration
+ *
+ *
+ * @return ChunkManager
+ * @see ChunkManager
+ */
+ public ChunkManager getChunkManager() {
+ return ChunkManager.manager;
+ }
+
+ /**
+ * Get the block/biome set queue
+ *
+ * @return GlobalBlockQueue.IMP
+ */
+ public GlobalBlockQueue getBlockQueue() {
+ return GlobalBlockQueue.IMP;
+ }
+
+ /**
+ * UUIDWrapper class has basic methods for getting UUIDS. It's recommended
+ * to use the UUIDHandler class instead.
+ *
+ * @return UUIDWrapper
+ * @see UUIDWrapper
+ */
+ public UUIDWrapper getUUIDWrapper() {
+ return UUIDHandler.getUUIDWrapper();
+ }
+
+ /**
+ * SchematicHandler class contains methods related to pasting, reading
+ * and writing schematics.
+ *
+ * @return SchematicHandler
+ * @see SchematicHandler
+ */
+ public SchematicHandler getSchematicHandler() {
+ return SchematicHandler.manager;
+ }
+
+ /**
+ * Get a list of PlotAreas in the world.
+ *
+ * @param world The world to check for plot areas
+ * @return A set of PlotAreas
+ */
+ public Set getPlotAreas(String world) {
+ if (world == null) {
+ return Collections.emptySet();
+ }
+ return PlotSquared.get().getPlotAreas(world);
+ }
+
+ /**
+ * Send a message to the console. The message supports color codes.
+ *
+ * @param message the message
+ * @see MainUtil#sendConsoleMessage(C, String...)
+ */
+ public void sendConsoleMessage(String message) {
+ PlotSquared.log(message);
+ }
+
+ /**
+ * Send a message to the console.
+ *
+ * @param caption the message
+ * @see #sendConsoleMessage(String)
+ * @see C
+ */
+ public void sendConsoleMessage(C caption) {
+ sendConsoleMessage(caption.s());
+ }
+
+ /**
+ * Registers a flag for use in plots.
+ *
+ * @param flag the flag to register
+ */
+ public void addFlag(Flag flag) {
+ Flags.registerFlag(flag);
+ }
+
+ /**
+ * Gets the PlotSquared class.
+ *
+ * @return PlotSquared Class
+ * @see PlotSquared
+ */
+ public PlotSquared getPlotSquared() {
+ return PlotSquared.get();
+ }
+
+ /**
+ * Get the PlotPlayer for a UUID.
+ *
+ *
Please note that PlotSquared can be configured to provide
+ * different UUIDs than bukkit
+ *
+ * @param uuid the uuid of the player to wrap
+ * @return a {@code PlotPlayer}
+ * @see PlotPlayer#wrap(Object)
+ */
+ public PlotPlayer wrapPlayer(UUID uuid) {
+ return PlotPlayer.wrap(uuid);
+ }
+
+ /**
+ * Get the PlotPlayer for a username.
+ *
+ * @param player the player to wrap
+ * @return a {@code PlotPlayer}
+ * @see PlotPlayer#wrap(Object)
+ */
+ public PlotPlayer wrapPlayer(String player) {
+ return PlotPlayer.wrap(player);
+ }
+}
diff --git a/Bukkit/src/main/java/com/github/intellectualsites/plotsquared/commands/Argument.java b/Bukkit/src/main/java/com/github/intellectualsites/plotsquared/commands/Argument.java
new file mode 100644
index 000000000..dd5221a3a
--- /dev/null
+++ b/Bukkit/src/main/java/com/github/intellectualsites/plotsquared/commands/Argument.java
@@ -0,0 +1,68 @@
+package com.github.intellectualsites.plotsquared.commands;
+
+import com.github.intellectualsites.plotsquared.plot.object.PlotId;
+
+public abstract class Argument {
+
+ public static final Argument Integer = new Argument("int", 16) {
+ @Override public Integer parse(String in) {
+ Integer value = null;
+ try {
+ value = java.lang.Integer.parseInt(in);
+ } catch (Exception ignored) {
+ }
+ return value;
+ }
+ };
+ public static final Argument Boolean = new Argument("boolean", true) {
+ @Override public Boolean parse(String in) {
+ Boolean value = null;
+ if (in.equalsIgnoreCase("true") || in.equalsIgnoreCase("Yes") || in
+ .equalsIgnoreCase("1")) {
+ value = true;
+ } else if (in.equalsIgnoreCase("false") || in.equalsIgnoreCase("No") || in
+ .equalsIgnoreCase("0")) {
+ value = false;
+ }
+ return value;
+ }
+ };
+ public static final Argument String = new Argument("String", "Example") {
+ @Override public String parse(String in) {
+ return in;
+ }
+ };
+ public static final Argument PlayerName =
+ new Argument("PlayerName", "Dinnerbone") {
+ @Override public String parse(String in) {
+ return in.length() <= 16 ? in : null;
+ }
+ };
+ public static final Argument PlotID =
+ new Argument("PlotID", new PlotId(-6, 3)) {
+ @Override public PlotId parse(String in) {
+ return PlotId.fromString(in);
+ }
+ };
+ private final String name;
+ private final T example;
+
+ public Argument(String name, T example) {
+ this.name = name;
+ this.example = example;
+ }
+
+ public abstract T parse(String in);
+
+ @Override public final String toString() {
+ return this.getName();
+ }
+
+ public final String getName() {
+ return this.name;
+ }
+
+ public final T getExample() {
+ return this.example;
+ }
+}
diff --git a/Bukkit/src/main/java/com/github/intellectualsites/plotsquared/commands/Command.java b/Bukkit/src/main/java/com/github/intellectualsites/plotsquared/commands/Command.java
new file mode 100644
index 000000000..6bac09a26
--- /dev/null
+++ b/Bukkit/src/main/java/com/github/intellectualsites/plotsquared/commands/Command.java
@@ -0,0 +1,596 @@
+package com.github.intellectualsites.plotsquared.commands;
+
+import com.github.intellectualsites.plotsquared.configuration.file.YamlConfiguration;
+import com.github.intellectualsites.plotsquared.plot.PlotSquared;
+import com.github.intellectualsites.plotsquared.plot.commands.CommandCategory;
+import com.github.intellectualsites.plotsquared.plot.commands.MainCommand;
+import com.github.intellectualsites.plotsquared.plot.commands.RequiredType;
+import com.github.intellectualsites.plotsquared.plot.config.C;
+import com.github.intellectualsites.plotsquared.plot.object.PlotMessage;
+import com.github.intellectualsites.plotsquared.plot.object.PlotPlayer;
+import com.github.intellectualsites.plotsquared.plot.object.RunnableVal2;
+import com.github.intellectualsites.plotsquared.plot.object.RunnableVal3;
+import com.github.intellectualsites.plotsquared.plot.util.*;
+
+import java.io.IOException;
+import java.lang.annotation.Annotation;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.util.*;
+
+public abstract class Command {
+
+ // May be none
+ private final ArrayList allCommands = new ArrayList<>();
+ private final ArrayList dynamicCommands = new ArrayList<>();
+ private final HashMap staticCommands = new HashMap<>();
+
+ // Parent command (may be null)
+ private final Command parent;
+ private final boolean isStatic;
+ // The command ID
+ private String id;
+ private List aliases;
+ private RequiredType required;
+ private String usage;
+ private String description;
+ private String perm;
+ private boolean confirmation;
+ private CommandCategory category;
+ private Argument[] arguments;
+
+ public Command(Command parent, boolean isStatic, String id, String perm, RequiredType required,
+ CommandCategory cat) {
+ this.parent = parent;
+ this.isStatic = isStatic;
+ this.id = id;
+ this.perm = perm;
+ this.required = required;
+ this.category = cat;
+ this.aliases = Arrays.asList(id);
+ if (this.parent != null) {
+ this.parent.register(this);
+ }
+ }
+
+ public Command(Command parent, boolean isStatic) {
+ this.parent = parent;
+ this.isStatic = isStatic;
+ Annotation cdAnnotation = getClass().getAnnotation(CommandDeclaration.class);
+ if (cdAnnotation != null) {
+ CommandDeclaration declaration = (CommandDeclaration) cdAnnotation;
+ init(declaration);
+ }
+ for (final Method method : getClass().getDeclaredMethods()) {
+ if (method.isAnnotationPresent(CommandDeclaration.class)) {
+ Class[] types = method.getParameterTypes();
+ // final PlotPlayer player, String[] args, RunnableVal3 confirm, RunnableVal2
+ // whenDone
+ if (types.length == 5 && types[0] == Command.class && types[1] == PlotPlayer.class
+ && types[2] == String[].class && types[3] == RunnableVal3.class
+ && types[4] == RunnableVal2.class) {
+ Command tmp = new Command(this, true) {
+ @Override public void execute(PlotPlayer player, String[] args,
+ RunnableVal3 confirm,
+ RunnableVal2 whenDone) {
+ try {
+ method.invoke(Command.this, this, player, args, confirm, whenDone);
+ } catch (IllegalAccessException | InvocationTargetException e) {
+ e.printStackTrace();
+ }
+ }
+ };
+ tmp.init(method.getAnnotation(CommandDeclaration.class));
+ }
+ }
+ }
+ }
+
+ public Command getParent() {
+ return this.parent;
+ }
+
+ public String getId() {
+ return this.id;
+ }
+
+ public String getFullId() {
+ if (this.parent != null && this.parent.getParent() != null) {
+ return this.parent.getFullId() + "." + this.id;
+ }
+ return this.id;
+ }
+
+ public List getCommands(PlotPlayer player) {
+ List commands = new ArrayList<>();
+ for (Command cmd : this.allCommands) {
+ if (cmd.canExecute(player, false)) {
+ commands.add(cmd);
+ }
+ }
+ return commands;
+ }
+
+ public List getCommands(CommandCategory cat, PlotPlayer player) {
+ List commands = getCommands(player);
+ if (cat != null) {
+ Iterator iterator = commands.iterator();
+ while (iterator.hasNext()) {
+ if (iterator.next().category != cat) {
+ iterator.remove();
+ }
+ }
+ }
+ return commands;
+ }
+
+ public List getCommands() {
+ return this.allCommands;
+ }
+
+ public boolean hasConfirmation(PlotPlayer player) {
+ return this.confirmation && !player.hasPermission(getPermission() + ".confirm.bypass");
+ }
+
+ public List getAliases() {
+ return this.aliases;
+ }
+
+ public String getDescription() {
+ return this.description;
+ }
+
+ public RequiredType getRequiredType() {
+ return this.required;
+ }
+
+ public Argument[] getRequiredArguments() {
+ return this.arguments;
+ }
+
+ public void setRequiredArguments(Argument[] arguments) {
+ this.arguments = arguments;
+ }
+
+ public void init(CommandDeclaration declaration) {
+ this.id = declaration.command();
+ this.perm = declaration.permission();
+ this.required = declaration.requiredType();
+ this.category = declaration.category();
+ HashMap options = new HashMap<>();
+ List aliasOptions = new ArrayList<>();
+ aliasOptions.add(this.id);
+ aliasOptions.addAll(Arrays.asList(declaration.aliases()));
+ options.put("aliases", aliasOptions);
+ options.put("description", declaration.description());
+ options.put("usage", declaration.usage());
+ options.put("confirmation", declaration.confirmation());
+ boolean set = false;
+ YamlConfiguration commands =
+ PlotSquared.get() == null ? new YamlConfiguration() : PlotSquared.get().commands;
+ for (Map.Entry entry : options.entrySet()) {
+ String key = this.getFullId() + "." + entry.getKey();
+ if (!commands.contains(key)) {
+ commands.set(key, entry.getValue());
+ set = true;
+ }
+ }
+ if (set && PlotSquared.get() != null) {
+ try {
+ commands.save(PlotSquared.get().commandsFile);
+ } catch (IOException e) {
+ e.printStackTrace();
+
+ }
+ }
+ this.aliases = commands.getStringList(this.getFullId() + ".aliases");
+ this.description = commands.getString(this.getFullId() + ".description");
+ this.usage = commands.getString(this.getFullId() + ".usage");
+ this.confirmation = commands.getBoolean(this.getFullId() + ".confirmation");
+ if (this.parent != null) {
+ this.parent.register(this);
+ }
+ }
+
+ public void register(Command command) {
+ if (command.isStatic) {
+ for (String alias : command.aliases) {
+ this.staticCommands.put(alias.toLowerCase(), command);
+ }
+ } else {
+ this.dynamicCommands.add(command);
+ }
+ this.allCommands.add(command);
+ }
+
+ public String getPermission() {
+ if (this.perm != null && !this.perm.isEmpty()) {
+ return this.perm;
+ }
+ if (this.parent == null) {
+ return "plots.use";
+ }
+ return "plots." + getFullId();
+ }
+
+ public void paginate(PlotPlayer player, List c, int size, int page,
+ RunnableVal3 add, String baseCommand, String header) {
+ // Calculate pages & index
+ if (page < 0) {
+ page = 0;
+ }
+ int totalPages = (int) Math.ceil(c.size() / size);
+ if (page > totalPages) {
+ page = totalPages;
+ }
+ int max = page * size + size;
+ if (max > c.size()) {
+ max = c.size();
+ }
+ // Send the header
+ header = header.replaceAll("%cur", page + 1 + "").replaceAll("%max", totalPages + 1 + "")
+ .replaceAll("%amount%", c.size() + "").replaceAll("%word%", "all");
+ MainUtil.sendMessage(player, header);
+ // Send the page content
+ List subList = c.subList(page * size, max);
+ int i = page * size;
+ for (T obj : subList) {
+ i++;
+ PlotMessage msg = new PlotMessage();
+ add.run(i, obj, msg);
+ msg.send(player);
+ }
+ // Send the footer
+ if (page < totalPages && page > 0) { // Back | Next
+ new PlotMessage().text("<-").color("$1").command(baseCommand + " " + page).text(" | ")
+ .color("$3").text("->").color("$1").command(baseCommand + " " + (page + 2))
+ .text(C.CLICKABLE.s()).color("$2").send(player);
+ return;
+ }
+ if (page == 0 && totalPages != 0) { // Next
+ new PlotMessage().text("<-").color("$3").text(" | ").color("$3").text("->").color("$1")
+ .command(baseCommand + " " + (0 + 2)).text(C.CLICKABLE.s()).color("$2")
+ .send(player);
+ return;
+ }
+ if (page == totalPages && totalPages != 0) { // Back
+ new PlotMessage().text("<-").color("$1").command(baseCommand + " " + page).text(" | ")
+ .color("$3").text("->").color("$3").text(C.CLICKABLE.s()).color("$2").send(player);
+ }
+ }
+
+ /**
+ * @param player Caller
+ * @param args Arguments
+ * @param confirm Instance, Success, Failure
+ * @return
+ */
+ public void execute(PlotPlayer player, String[] args,
+ RunnableVal3 confirm,
+ RunnableVal2 whenDone) throws CommandException {
+ if (args.length == 0 || args[0] == null) {
+ if (this.parent == null) {
+ MainCommand.getInstance().help.displayHelp(player, null, 0);
+ } else {
+ C.COMMAND_SYNTAX.send(player, getUsage());
+ }
+ return;
+ }
+ if (this.allCommands == null || this.allCommands.isEmpty()) {
+ player.sendMessage(
+ "Not Implemented: https://github.com/IntellectualSites/PlotSquared/issues/new");
+ return;
+ }
+ Command cmd = getCommand(args[0]);
+ if (cmd == null) {
+ if (this.parent != null) {
+ C.COMMAND_SYNTAX.send(player, getUsage());
+ return;
+ }
+ // Help command
+ try {
+ if (args.length == 0 || MathMan.isInteger(args[0])
+ || CommandCategory.valueOf(args[0].toUpperCase()) != null) {
+ // This will default certain syntax to the help command
+ // e.g. /plot, /plot 1, /plot claiming
+ MainCommand.getInstance().help.execute(player, args, null, null);
+ return;
+ }
+ } catch (IllegalArgumentException ignored) {
+ }
+ // Command recommendation
+ MainUtil.sendMessage(player, C.NOT_VALID_SUBCOMMAND);
+ List commands = getCommands(player);
+ if (commands.isEmpty()) {
+ MainUtil
+ .sendMessage(player, C.DID_YOU_MEAN, MainCommand.getInstance().help.getUsage());
+ return;
+ }
+ HashSet setargs = new HashSet<>(args.length);
+ for (String arg : args) {
+ setargs.add(arg.toLowerCase());
+ }
+ String[] allargs = setargs.toArray(new String[setargs.size()]);
+ int best = 0;
+ for (Command current : commands) {
+ int match = getMatch(allargs, current);
+ if (match > best) {
+ cmd = current;
+ }
+ }
+ if (cmd == null) {
+ cmd = new StringComparison<>(args[0], this.allCommands).getMatchObject();
+ }
+ MainUtil.sendMessage(player, C.DID_YOU_MEAN, cmd.getUsage());
+ return;
+ }
+ String[] newArgs = Arrays.copyOfRange(args, 1, args.length);
+ if (!cmd.checkArgs(player, newArgs) || !cmd.canExecute(player, true)) {
+ return;
+ }
+ try {
+ cmd.execute(player, newArgs, confirm, whenDone);
+ } catch (CommandException e) {
+ e.perform(player);
+ }
+ }
+
+ public boolean checkArgs(PlotPlayer player, String[] args) {
+ Argument[] reqArgs = getRequiredArguments();
+ if (reqArgs != null && reqArgs.length > 0) {
+ boolean failed = args.length < reqArgs.length;
+ String[] baseSplit = getCommandString().split(" ");
+ String[] fullSplit = getUsage().split(" ");
+ String base = getCommandString();
+ if (fullSplit.length - baseSplit.length < reqArgs.length) {
+ String[] tmp = new String[baseSplit.length + reqArgs.length];
+ System.arraycopy(fullSplit, 0, tmp, 0, fullSplit.length);
+ fullSplit = tmp;
+ }
+ for (int i = 0; i < reqArgs.length; i++) {
+ fullSplit[i + baseSplit.length] = reqArgs[i].getExample().toString();
+ failed = failed || reqArgs[i].parse(args[i]) == null;
+ }
+ if (failed) {
+ C.COMMAND_SYNTAX.send(player, StringMan.join(fullSplit, " "));
+ return false;
+ }
+ }
+ return true;
+ }
+
+ public int getMatch(String[] args, Command cmd) {
+ int count = 0;
+ String perm = cmd.getPermission();
+ HashSet desc = new HashSet<>();
+ for (String alias : cmd.getAliases()) {
+ if (alias.startsWith(args[0])) {
+ count += 5;
+ }
+ }
+ Collections.addAll(desc, cmd.getDescription().split(" "));
+ for (String arg : args) {
+ if (perm.startsWith(arg)) {
+ count++;
+ }
+ if (desc.contains(arg)) {
+ count++;
+ }
+ }
+ String[] usage = cmd.getUsage().split(" ");
+ for (int i = 0; i < Math.min(4, usage.length); i++) {
+ int require;
+ if (usage[i].startsWith("<")) {
+ require = 1;
+ } else {
+ require = 0;
+ }
+ String[] split = usage[i].split("\\|| |\\>|\\<|\\[|\\]|\\{|\\}|\\_|\\/");
+ for (String aSplit : split) {
+ for (String arg : args) {
+ if (StringMan.isEqualIgnoreCase(arg, aSplit)) {
+ count += 5 - i + require;
+ }
+ }
+ }
+ }
+ count += StringMan.intersection(desc, args);
+ return count;
+ }
+
+ public Command getCommand(String arg) {
+ Command cmd = this.staticCommands.get(arg.toLowerCase());
+ if (cmd == null) {
+ for (Command command : this.dynamicCommands) {
+ if (command.matches(arg)) {
+ return command;
+ }
+ }
+ }
+ return cmd;
+ }
+
+ public Command getCommand(Class clazz) {
+ for (Command cmd : this.allCommands) {
+ if (cmd.getClass() == clazz) {
+ return cmd;
+ }
+ }
+ return null;
+ }
+
+ public Command getCommandById(String id) {
+ Command exact = this.staticCommands.get(id);
+ if (exact != null) {
+ return exact;
+ }
+ for (Command cmd : this.allCommands) {
+ if (cmd.getId().equals(id)) {
+ return cmd;
+ }
+ }
+ return null;
+ }
+
+ public boolean canExecute(PlotPlayer player, boolean message) {
+ if (player == null) {
+ return true;
+ }
+ if (!this.required.allows(player)) {
+ if (message) {
+ MainUtil.sendMessage(player,
+ this.required == RequiredType.PLAYER ? C.IS_CONSOLE : C.NOT_CONSOLE);
+ }
+ } else if (!Permissions.hasPermission(player, getPermission())) {
+ if (message) {
+ C.NO_PERMISSION.send(player, getPermission());
+ }
+ } else {
+ return true;
+ }
+ return false;
+ }
+
+ public boolean matches(String arg) {
+ arg = arg.toLowerCase();
+ return StringMan.isEqual(arg, this.id) || this.aliases.contains(arg);
+ }
+
+ public String getCommandString() {
+ String base;
+ if (this.parent == null) {
+ return "/" + toString();
+ } else {
+ return this.parent.getCommandString() + " " + toString();
+ }
+ }
+
+ public String getUsage() {
+ if (this.usage != null && !this.usage.isEmpty()) {
+ if (this.usage.startsWith("/")) {
+ return this.usage;
+ }
+ return getCommandString() + " " + this.usage;
+ }
+ if (this.allCommands.isEmpty()) {
+ return getCommandString();
+ }
+ StringBuilder args = new StringBuilder("[");
+ String prefix = "";
+ for (Command cmd : this.allCommands) {
+ args.append(prefix).append(cmd.isStatic ? cmd.toString() : "<" + cmd + ">");
+ prefix = "|";
+ }
+ return getCommandString() + " " + args + "]";
+ }
+
+ public Collection tabOf(PlotPlayer player, String[] input, boolean space,
+ String... args) {
+ if (!space) {
+ return null;
+ }
+ List result = new ArrayList<>();
+ int index = input.length - (space ? 0 : 1);
+ for (String arg : args) {
+ arg = arg.replace(getCommandString() + " ", "");
+ String[] split = arg.split(" ");
+ if (split.length <= index) {
+ continue;
+ }
+ arg = StringMan.join(Arrays.copyOfRange(split, index, split.length), " ");
+ Command cmd = new Command(null, false, arg, getPermission(), getRequiredType(), null) {
+ };
+ result.add(cmd);
+ }
+ return result;
+ }
+
+ public Collection tab(PlotPlayer player, String[] args, boolean space) {
+ switch (args.length) {
+ case 0:
+ return this.allCommands;
+ case 1:
+ String arg = args[0].toLowerCase();
+ if (space) {
+ Command cmd = getCommand(arg);
+ if (cmd != null && cmd.canExecute(player, false)) {
+ return cmd.tab(player, Arrays.copyOfRange(args, 1, args.length), space);
+ } else {
+ return null;
+ }
+ } else {
+ Set commands = new HashSet();
+ for (Map.Entry entry : this.staticCommands.entrySet()) {
+ if (entry.getKey().startsWith(arg) && entry.getValue()
+ .canExecute(player, false)) {
+ commands.add(entry.getValue());
+ }
+ }
+ return commands;
+ }
+ default:
+ Command cmd = getCommand(args[0]);
+ if (cmd != null) {
+ return cmd.tab(player, Arrays.copyOfRange(args, 1, args.length), space);
+ } else {
+ return null;
+ }
+ }
+ }
+
+ @Override public String toString() {
+ return !this.aliases.isEmpty() ? this.aliases.get(0) : this.id;
+ }
+
+ @Override public boolean equals(Object obj) {
+ if (this == obj) {
+ return true;
+ }
+ if (getClass() != obj.getClass()) {
+ return false;
+ }
+ Command other = (Command) obj;
+ if (this.hashCode() != other.hashCode()) {
+ return false;
+ }
+ return this.getFullId().equals(other.getFullId());
+ }
+
+ @Override public int hashCode() {
+ return this.getFullId().hashCode();
+ }
+
+ public void checkTrue(boolean mustBeTrue, C message, Object... args) {
+ if (!mustBeTrue) {
+ throw new CommandException(message, args);
+ }
+ }
+
+ public T check(T object, C message, Object... args) {
+ if (object == null) {
+ throw new CommandException(message, args);
+ }
+ return object;
+ }
+
+ public enum CommandResult {
+ FAILURE, SUCCESS
+ }
+
+
+ public static class CommandException extends RuntimeException {
+ private final Object[] args;
+ private final C message;
+
+ public CommandException(C message, Object... args) {
+ this.message = message;
+ this.args = args;
+ }
+
+ public void perform(PlotPlayer player) {
+ if (player != null && message != null) {
+ message.send(player, args);
+ }
+ }
+ }
+}
diff --git a/Bukkit/src/main/java/com/github/intellectualsites/plotsquared/commands/CommandCaller.java b/Bukkit/src/main/java/com/github/intellectualsites/plotsquared/commands/CommandCaller.java
new file mode 100644
index 000000000..3b5ee295e
--- /dev/null
+++ b/Bukkit/src/main/java/com/github/intellectualsites/plotsquared/commands/CommandCaller.java
@@ -0,0 +1,24 @@
+package com.github.intellectualsites.plotsquared.commands;
+
+import com.github.intellectualsites.plotsquared.plot.commands.RequiredType;
+
+public interface CommandCaller {
+
+ /**
+ * Send the player a message.
+ *
+ * @param message the message to send
+ */
+ void sendMessage(String message);
+
+ /**
+ * Check the player's permissions. Will be cached if permission caching is enabled.
+ *
+ * @param permission the name of the permission
+ */
+ boolean hasPermission(String permission);
+
+ boolean isPermissionSet(String permission);
+
+ RequiredType getSuperCaller();
+}
diff --git a/Bukkit/src/main/java/com/github/intellectualsites/plotsquared/commands/CommandDeclaration.java b/Bukkit/src/main/java/com/github/intellectualsites/plotsquared/commands/CommandDeclaration.java
new file mode 100644
index 000000000..851a03174
--- /dev/null
+++ b/Bukkit/src/main/java/com/github/intellectualsites/plotsquared/commands/CommandDeclaration.java
@@ -0,0 +1,29 @@
+package com.github.intellectualsites.plotsquared.commands;
+
+import com.github.intellectualsites.plotsquared.plot.commands.CommandCategory;
+import com.github.intellectualsites.plotsquared.plot.commands.RequiredType;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Target({ElementType.TYPE, ElementType.METHOD}) @Retention(RetentionPolicy.RUNTIME)
+public @interface CommandDeclaration {
+
+ String command();
+
+ String[] aliases() default {};
+
+ String permission() default "";
+
+ String usage() default "";
+
+ String description() default "";
+
+ RequiredType requiredType() default RequiredType.NONE;
+
+ CommandCategory category() default CommandCategory.INFO;
+
+ boolean confirmation() default false;
+}
diff --git a/Bukkit/src/main/java/com/github/intellectualsites/plotsquared/configuration/Configuration.java b/Bukkit/src/main/java/com/github/intellectualsites/plotsquared/configuration/Configuration.java
new file mode 100644
index 000000000..9d694c1ec
--- /dev/null
+++ b/Bukkit/src/main/java/com/github/intellectualsites/plotsquared/configuration/Configuration.java
@@ -0,0 +1,87 @@
+package com.github.intellectualsites.plotsquared.configuration;
+
+import javax.annotation.Nonnull;
+import java.util.Map;
+
+/**
+ * Represents a source of configurable options and settings.
+ */
+public interface Configuration extends ConfigurationSection {
+ /**
+ * Sets the default value of 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.
+ *
+ * @param path Path of the value to set.
+ * @param value Value to set the default to.
+ * @throws IllegalArgumentException Thrown if path is null.
+ */
+ @Override void addDefault(@Nonnull String path, 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->Values to add to defaults.
+ * @throws IllegalArgumentException Thrown if defaults is null.
+ */
+ void addDefaults(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 check this, you should set the default source with {@link
+ * #setDefaults(Configuration)}.
+ *
+ * @param defaults A configuration holding a list of defaults to copy.
+ * @throws IllegalArgumentException Thrown if defaults is null or this.
+ */
+ void addDefaults(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.
+ */
+ Configuration getDefaults();
+
+ /**
+ * 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.
+ */
+ void setDefaults(Configuration defaults);
+
+ /**
+ * Gets the {@link ConfigurationOptions} for this {@link Configuration}.
+ *
+ *
All setters through this method are chainable.
+ *
+ * @return Options for this configuration
+ */
+ ConfigurationOptions options();
+}
diff --git a/Bukkit/src/main/java/com/github/intellectualsites/plotsquared/configuration/ConfigurationOptions.java b/Bukkit/src/main/java/com/github/intellectualsites/plotsquared/configuration/ConfigurationOptions.java
new file mode 100644
index 000000000..f86016031
--- /dev/null
+++ b/Bukkit/src/main/java/com/github/intellectualsites/plotsquared/configuration/ConfigurationOptions.java
@@ -0,0 +1,90 @@
+package com.github.intellectualsites.plotsquared.configuration;
+
+/**
+ * Various settings for controlling the input and output of a {@link
+ * Configuration}.
+ */
+class ConfigurationOptions {
+ private final Configuration configuration;
+ private char pathSeparator = '.';
+ private boolean copyDefaults = false;
+
+ protected ConfigurationOptions(Configuration configuration) {
+ this.configuration = configuration;
+ }
+
+ /**
+ * Returns the {@link Configuration} that this object is responsible for.
+ *
+ * @return Parent configuration
+ */
+ 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
+ */
+ 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
+ */
+ public ConfigurationOptions pathSeparator(char value) {
+ 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(String)} will always
+ * return the same value as {@link
+ * ConfigurationSection#isSet(String)}. The default value is
+ * false.
+ *
+ * @return Whether or not defaults are directly copied
+ */
+ 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(String)} will always
+ * return the same value as {@link
+ * ConfigurationSection#isSet(String)}. The default value is
+ * false.
+ *
+ * @param value Whether or not defaults are directly copied
+ * @return This object, for chaining
+ */
+ public ConfigurationOptions copyDefaults(boolean value) {
+ copyDefaults = value;
+ return this;
+ }
+}
diff --git a/Bukkit/src/main/java/com/github/intellectualsites/plotsquared/configuration/ConfigurationSection.java b/Bukkit/src/main/java/com/github/intellectualsites/plotsquared/configuration/ConfigurationSection.java
new file mode 100644
index 000000000..9e15a9030
--- /dev/null
+++ b/Bukkit/src/main/java/com/github/intellectualsites/plotsquared/configuration/ConfigurationSection.java
@@ -0,0 +1,649 @@
+package com.github.intellectualsites.plotsquared.configuration;
+
+import javax.annotation.Nonnull;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+/**
+ * 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.
+ */
+ 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.
+ */
+ 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 {@code null}.
+ */
+ boolean contains(@Nonnull String path);
+
+ /**
+ * 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 {@code null}.
+ */
+ boolean isSet(@Nonnull 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 {@code 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
+ */
+ 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
+ */
+ 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 {@code null}.
+ *
+ * @return Root configuration containing this section.
+ */
+ Configuration getRoot();
+
+ /**
+ * Gets the parent {@link ConfigurationSection} that directly contains
+ * this {@link ConfigurationSection}.
+ *
+ *
For any {@link Configuration} themselves, this will return
+ * {@code 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 {@code null}.
+ *
+ * @return Parent section containing this section.
+ */
+ 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 {@code null}.
+ *
+ * @param path Path of the Object to get.
+ * @return Requested Object.
+ */
+ Object get(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 defaultValue The default value to return if the path is not found.
+ * @return Requested Object.
+ */
+ Object getOrDefault(@Nonnull String path, Object defaultValue);
+
+ /**
+ * Sets the specified path to the given value.
+ *
+ *
If value is {@code 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 javadoc for details. No implementations should allow
+ * you to store {@link Configuration}s or {@link ConfigurationSection}s,
+ * please use {@link #createSection(String)} for that.
+ *
+ * @param path Path of the object to set.
+ * @param value New value to set the path to.
+ */
+ void set(String path, 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
+ */
+ ConfigurationSection createSection(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
+ */
+ ConfigurationSection createSection(String path, 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 {@code null}.
+ *
+ * @param path Path of the String to get.
+ * @return Requested String.
+ */
+ String getString(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.
+ */
+ String getString(String path, 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
+ * defaultvalue is a String and return appropriately.
+ *
+ * @param path Path of the String to check.
+ * @return Whether or not the specified path is a String.
+ */
+ boolean isString(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.
+ */
+ int getInt(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.
+ */
+ int getInt(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.
+ */
+ boolean isInt(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.
+ */
+ boolean getBoolean(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 defaultValue The default value to return if the path is not found or is
+ * not a boolean.
+ * @return Requested boolean.
+ */
+ boolean getBoolean(String path, boolean defaultValue);
+
+ /**
+ * 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.
+ */
+ boolean isBoolean(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.
+ */
+ double getDouble(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 defaultValue The default value to return if the path is not found or is
+ * not a double.
+ * @return Requested double.
+ */
+ double getDouble(String path, double defaultValue);
+
+ /**
+ * 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.
+ */
+ boolean isDouble(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.
+ */
+ long getLong(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.
+ */
+ long getLong(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.
+ */
+ boolean isLong(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.
+ */
+ List getList(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.
+ */
+ List getList(String path, 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.
+ */
+ boolean isList(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.
+ */
+ List getStringList(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.
+ */
+ List getIntegerList(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.
+ */
+ List getBooleanList(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.
+ */
+ List getDoubleList(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.
+ */
+ List getFloatList(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.
+ */
+ List getLongList(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.
+ */
+ List getByteList(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.
+ */
+ List getCharacterList(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.
+ */
+ List getShortList(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.
+ */
+ List> getMapList(String path);
+
+ /**
+ * Gets the requested ConfigurationSection by path.
+ *
+ *
If the ConfigurationSection does not exist but a default value has
+ * been specified, this will return the default value. If the
+ * ConfigurationSection does not exist and no default value was specified,
+ * this will return {@code null}.
+ *
+ * @param path Path of the ConfigurationSection to get.
+ * @return Requested ConfigurationSection.
+ */
+ ConfigurationSection getConfigurationSection(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.
+ */
+ boolean isConfigurationSection(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 {@code null}.
+ *
+ * @return Equivalent section in root configuration
+ */
+ 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 {@code null}, the value will be removed from the
+ * default Configuration source.
+ *
+ *
If the value as returned by {@link #getDefaultSection()} is
+ * {@code 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 {@code null}
+ */
+ void addDefault(@Nonnull String path, Object value);
+}
diff --git a/Bukkit/src/main/java/com/github/intellectualsites/plotsquared/configuration/InvalidConfigurationException.java b/Bukkit/src/main/java/com/github/intellectualsites/plotsquared/configuration/InvalidConfigurationException.java
new file mode 100644
index 000000000..e9c099ed1
--- /dev/null
+++ b/Bukkit/src/main/java/com/github/intellectualsites/plotsquared/configuration/InvalidConfigurationException.java
@@ -0,0 +1,45 @@
+package com.github.intellectualsites.plotsquared.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/Bukkit/src/main/java/com/github/intellectualsites/plotsquared/configuration/MemoryConfiguration.java b/Bukkit/src/main/java/com/github/intellectualsites/plotsquared/configuration/MemoryConfiguration.java
new file mode 100644
index 000000000..d1677c54d
--- /dev/null
+++ b/Bukkit/src/main/java/com/github/intellectualsites/plotsquared/configuration/MemoryConfiguration.java
@@ -0,0 +1,73 @@
+package com.github.intellectualsites.plotsquared.configuration;
+
+import javax.annotation.Nonnull;
+import java.util.Map;
+
+/**
+ * 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(Configuration defaults) {
+ this.defaults = defaults;
+ }
+
+ @Override public void addDefault(@Nonnull String path, Object value) {
+ if (this.defaults == null) {
+ this.defaults = new MemoryConfiguration();
+ }
+
+ this.defaults.set(path, value);
+ }
+
+ @Override public void addDefaults(Map defaults) {
+ for (Map.Entry entry : defaults.entrySet()) {
+ addDefault(entry.getKey(), entry.getValue());
+ }
+ }
+
+ @Override public void addDefaults(Configuration defaults) {
+ addDefaults(defaults.getValues(true));
+ }
+
+ @Override public Configuration getDefaults() {
+ return this.defaults;
+ }
+
+ @Override public void setDefaults(Configuration defaults) {
+ if (defaults == null) {
+ throw new NullPointerException("Defaults may not be null");
+ }
+
+ this.defaults = defaults;
+ }
+
+ @Override public ConfigurationSection getParent() {
+ return null;
+ }
+
+ @Override public MemoryConfigurationOptions options() {
+ if (this.options == null) {
+ this.options = new MemoryConfigurationOptions(this);
+ }
+
+ return this.options;
+ }
+}
diff --git a/Bukkit/src/main/java/com/github/intellectualsites/plotsquared/configuration/MemoryConfigurationOptions.java b/Bukkit/src/main/java/com/github/intellectualsites/plotsquared/configuration/MemoryConfigurationOptions.java
new file mode 100644
index 000000000..971ea1e70
--- /dev/null
+++ b/Bukkit/src/main/java/com/github/intellectualsites/plotsquared/configuration/MemoryConfigurationOptions.java
@@ -0,0 +1,25 @@
+package com.github.intellectualsites.plotsquared.configuration;
+
+/**
+ * Various settings for controlling the input and output of a {@link
+ * MemoryConfiguration}.
+ */
+public class MemoryConfigurationOptions extends ConfigurationOptions {
+ protected MemoryConfigurationOptions(MemoryConfiguration configuration) {
+ super(configuration);
+ }
+
+ @Override public MemoryConfiguration configuration() {
+ return (MemoryConfiguration) super.configuration();
+ }
+
+ @Override public MemoryConfigurationOptions copyDefaults(boolean value) {
+ super.copyDefaults(value);
+ return this;
+ }
+
+ @Override public MemoryConfigurationOptions pathSeparator(char value) {
+ super.pathSeparator(value);
+ return this;
+ }
+}
diff --git a/Bukkit/src/main/java/com/github/intellectualsites/plotsquared/configuration/MemorySection.java b/Bukkit/src/main/java/com/github/intellectualsites/plotsquared/configuration/MemorySection.java
new file mode 100644
index 000000000..26f6760c8
--- /dev/null
+++ b/Bukkit/src/main/java/com/github/intellectualsites/plotsquared/configuration/MemorySection.java
@@ -0,0 +1,771 @@
+package com.github.intellectualsites.plotsquared.configuration;
+
+import javax.annotation.Nonnull;
+import java.util.*;
+
+/**
+ * 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(ConfigurationSection parent, String path) {
+ this.path = path;
+ this.parent = parent;
+ this.root = parent.getRoot();
+
+ if (this.root == null) {
+ throw new NullPointerException("Path may not be orphaned");
+ }
+
+ this.fullPath = createPath(parent, path);
+ }
+
+ public static double toDouble(Object obj, double def) {
+ if (obj instanceof Number) {
+ return ((Number) obj).doubleValue();
+ }
+ if (obj instanceof String) {
+ try {
+ return Double.parseDouble((String) obj);
+ } catch (NumberFormatException ignored) {
+ }
+ } else if (obj instanceof List) {
+ List val = (List) obj;
+ if (!val.isEmpty()) {
+ return toDouble(val.get(0), def);
+ }
+ }
+ return def;
+ }
+
+ public static int toInt(Object obj, int def) {
+ if (obj instanceof Number) {
+ return ((Number) obj).intValue();
+ }
+ if (obj instanceof String) {
+ try {
+ return Integer.parseInt((String) obj);
+ } catch (NumberFormatException ignored) {
+ }
+ } else if (obj instanceof List) {
+ List val = (List) obj;
+ if (!val.isEmpty()) {
+ return toInt(val.get(0), def);
+ }
+ }
+ return def;
+ }
+
+ public static long toLong(Object obj, long def) {
+ if (obj instanceof Number) {
+ return ((Number) obj).longValue();
+ }
+ if (obj instanceof String) {
+ try {
+ return Long.parseLong((String) obj);
+ } catch (NumberFormatException ignored) {
+ }
+ } else if (obj instanceof List) {
+ List val = (List) obj;
+ if (!val.isEmpty()) {
+ return toLong(val.get(0), def);
+ }
+ }
+ return def;
+ }
+
+ /**
+ * 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.
+ */
+ public static String createPath(ConfigurationSection section, String key) {
+ return createPath(section, key, 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.
+ */
+ public static String createPath(ConfigurationSection section, String key,
+ ConfigurationSection relativeTo) {
+ 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.isEmpty()) {
+ if (builder.length() > 0) {
+ builder.append(separator);
+ }
+
+ builder.append(key);
+ }
+
+ return builder.toString();
+ }
+
+ @Override 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 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(@Nonnull String path) {
+ return get(path) != null;
+ }
+
+ @Override public boolean isSet(@Nonnull String path) {
+ Configuration root = getRoot();
+ if (root == null) {
+ return false;
+ }
+ if (root.options().copyDefaults()) {
+ return contains(path);
+ }
+ return getOrDefault(path, null) != null;
+ }
+
+ @Override public String getCurrentPath() {
+ return this.fullPath;
+ }
+
+ @Override public String getName() {
+ return this.path;
+ }
+
+ @Override public Configuration getRoot() {
+ return this.root;
+ }
+
+ @Override public ConfigurationSection getParent() {
+ return this.parent;
+ }
+
+ @Override public void addDefault(@Nonnull String path, Object value) {
+ 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 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(String path, Object value) {
+ Configuration root = getRoot();
+ if (root == null) {
+ throw new IllegalStateException("Cannot use section without a root");
+ }
+
+ char separator = root.options().pathSeparator();
+ // i1 is the leading (higher) index
+ // i2 is the trailing (lower) index
+ int i1 = -1;
+ int 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) {
+ if (value == null) {
+ this.map.remove(key);
+ } else {
+ this.map.put(key, value);
+ }
+ } else {
+ section.set(key, value);
+ }
+ }
+
+ @Override public Object get(String path) {
+ return getOrDefault(path, getDefault(path));
+ }
+
+ @Override public Object getOrDefault(@Nonnull String path, Object defaultValue) {
+ if (path.isEmpty()) {
+ return this;
+ }
+
+ Configuration root = getRoot();
+ if (root == null) {
+ throw new IllegalStateException("Cannot access section without a root");
+ }
+
+ char separator = root.options().pathSeparator();
+ // i1 is the leading (higher) index
+ // i2 is the trailing (lower) index
+ int i1 = -1;
+ int i2;
+ ConfigurationSection section = this;
+ while ((i1 = path.indexOf(separator, i2 = i1 + 1)) != -1) {
+ section = section.getConfigurationSection(path.substring(i2, i1));
+ if (section == null) {
+ return defaultValue;
+ }
+ }
+
+ String key = path.substring(i2);
+ if (section == this) {
+ Object result = this.map.get(key);
+ if (result == null) {
+ return defaultValue;
+ } else {
+ return result;
+ }
+ }
+ return section.getOrDefault(key, defaultValue);
+ }
+
+ @Override public ConfigurationSection createSection(String path) {
+ Configuration root = getRoot();
+ if (root == null) {
+ throw new IllegalStateException("Cannot create section without a root");
+ }
+
+ char separator = root.options().pathSeparator();
+ // i1 is the leading (higher) index
+ // i2 is the trailing (lower) index
+ int i1 = -1;
+ int 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);
+ this.map.put(key, result);
+ return result;
+ }
+ return section.createSection(key);
+ }
+
+ @Override public ConfigurationSection createSection(String path, 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 public String getString(String path) {
+ Object def = getDefault(path);
+ return getString(path, def != null ? def.toString() : null);
+ }
+
+ @Override public String getString(String path, String def) {
+ Object val = getOrDefault(path, def);
+ if (val != null) {
+ return val.toString();
+ } else {
+ return def;
+ }
+ }
+
+ @Override public boolean isString(String path) {
+ Object val = get(path);
+ return val instanceof String;
+ }
+
+ @Override public int getInt(String path) {
+ Object def = getDefault(path);
+ return getInt(path, toInt(def, 0));
+ }
+
+ @Override public int getInt(String path, int def) {
+ Object val = getOrDefault(path, def);
+ return toInt(val, def);
+ }
+
+ @Override public boolean isInt(String path) {
+ Object val = get(path);
+ return val instanceof Integer;
+ }
+
+ @Override public boolean getBoolean(String path) {
+ Object def = getDefault(path);
+ if (def instanceof Boolean) {
+ return getBoolean(path, (Boolean) def);
+ } else {
+ return getBoolean(path, false);
+ }
+ }
+
+ @Override public boolean getBoolean(String path, boolean defaultValue) {
+ Object val = getOrDefault(path, defaultValue);
+ if (val instanceof Boolean) {
+ return (Boolean) val;
+ } else {
+ return defaultValue;
+ }
+ }
+
+ @Override public boolean isBoolean(String path) {
+ Object val = get(path);
+ return val instanceof Boolean;
+ }
+
+ @Override public double getDouble(String path) {
+ Object def = getDefault(path);
+ return getDouble(path, toDouble(def, 0));
+ }
+
+ @Override public double getDouble(String path, double defaultValue) {
+ Object val = getOrDefault(path, defaultValue);
+ return toDouble(val, defaultValue);
+ }
+
+ @Override public boolean isDouble(String path) {
+ Object val = get(path);
+ return val instanceof Double;
+ }
+
+ @Override public long getLong(String path) {
+ Object def = getDefault(path);
+ return getLong(path, toLong(def, 0));
+ }
+
+ @Override public long getLong(String path, long def) {
+ Object val = getOrDefault(path, def);
+ return toLong(val, def);
+ }
+
+ @Override public boolean isLong(String path) {
+ Object val = get(path);
+ return val instanceof Long;
+ }
+
+ // Java
+ @Override public List getList(String path) {
+ Object def = getDefault(path);
+ return getList(path, def instanceof List ? (List) def : null);
+ }
+
+ @Override public List getList(String path, List def) {
+ Object val = getOrDefault(path, def);
+ return (List) ((val instanceof List) ? val : def);
+ }
+
+ @Override public boolean isList(String path) {
+ Object val = get(path);
+ return val instanceof List;
+ }
+
+ @Override public List getStringList(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 public List getIntegerList(String path) {
+ List list = getList(path);
+
+ 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 (NumberFormatException ignored) {
+ }
+ } else if (object instanceof Character) {
+ result.add((int) (Character) object);
+ } else if (object instanceof Number) {
+ result.add(((Number) object).intValue());
+ }
+ }
+
+ return result;
+ }
+
+ @Override public List getBooleanList(String path) {
+ List list = getList(path);
+
+ 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 public List getDoubleList(String path) {
+ List list = getList(path);
+
+ 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 (NumberFormatException ignored) {
+ }
+ } else if (object instanceof Character) {
+ result.add((double) (Character) object);
+ } else if (object instanceof Number) {
+ result.add(((Number) object).doubleValue());
+ }
+ }
+
+ return result;
+ }
+
+ @Override public List getFloatList(String path) {
+ List list = getList(path);
+
+ 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 (NumberFormatException ignored) {
+ }
+ } else if (object instanceof Character) {
+ result.add((float) (Character) object);
+ } else if (object instanceof Number) {
+ result.add(((Number) object).floatValue());
+ }
+ }
+
+ return result;
+ }
+
+ @Override public List getLongList(String path) {
+ List list = getList(path);
+
+ 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 (NumberFormatException ignored) {
+ }
+ } else if (object instanceof Character) {
+ result.add((long) (Character) object);
+ } else if (object instanceof Number) {
+ result.add(((Number) object).longValue());
+ }
+ }
+
+ return result;
+ }
+
+ @Override public List getByteList(String path) {
+ List list = getList(path);
+
+ 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 (NumberFormatException ignored) {
+ }
+ } else if (object instanceof Character) {
+ result.add((byte) ((Character) object).charValue());
+ } else if (object instanceof Number) {
+ result.add(((Number) object).byteValue());
+ }
+ }
+
+ return result;
+ }
+
+ @Override public List getCharacterList(String path) {
+ List list = getList(path);
+
+ 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 public List getShortList(String path) {
+ List list = getList(path);
+
+ 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 (NumberFormatException ignored) {
+ }
+ } else if (object instanceof Character) {
+ result.add((short) ((Character) object).charValue());
+ } else if (object instanceof Number) {
+ result.add(((Number) object).shortValue());
+ }
+ }
+
+ return result;
+ }
+
+ @Override public List> getMapList(String path) {
+ List list = getList(path);
+ List> result = new ArrayList<>();
+
+ for (Object object : list) {
+ if (object instanceof Map) {
+ result.add((Map) object);
+ }
+ }
+
+ return result;
+ }
+
+ @Override public ConfigurationSection getConfigurationSection(String path) {
+ Object val = getOrDefault(path, null);
+ if (val != null) {
+ return (val instanceof ConfigurationSection) ? (ConfigurationSection) val : null;
+ }
+
+ val = getOrDefault(path, getDefault(path));
+ return (val instanceof ConfigurationSection) ? createSection(path) : null;
+ }
+
+ @Override public boolean isConfigurationSection(String path) {
+ Object val = get(path);
+ return val instanceof ConfigurationSection;
+ }
+
+ protected boolean isPrimitiveWrapper(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);
+ }
+
+ protected Object getDefault(String path) {
+ Configuration root = getRoot();
+ Configuration defaults = root == null ? null : root.getDefaults();
+ return (defaults == null) ? null : defaults.get(createPath(this, path));
+ }
+
+ protected void mapChildrenKeys(Set output, 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() instanceof ConfigurationSection)) {
+ ConfigurationSection subsection = (ConfigurationSection) entry.getValue();
+ mapChildrenKeys(output, subsection, deep);
+ }
+ }
+ } else {
+ Set keys = section.getKeys(deep);
+
+ for (String key : keys) {
+ output.add(createPath(section, key, this));
+ }
+ }
+ }
+
+ protected void mapChildrenValues(Map output, ConfigurationSection section,
+ boolean deep) {
+ if (section instanceof MemorySection) {
+ MemorySection sec = (MemorySection) section;
+
+ for (Map.Entry entry : sec.map.entrySet()) {
+ output.put(createPath(section, entry.getKey(), this), entry.getValue());
+
+ if (entry.getValue() instanceof ConfigurationSection) {
+ if (deep) {
+ mapChildrenValues(output, (ConfigurationSection) entry.getValue(), deep);
+ }
+ }
+ }
+ } else {
+ Map values = section.getValues(deep);
+
+ for (Map.Entry entry : values.entrySet()) {
+ output.put(createPath(section, entry.getKey(), this), entry.getValue());
+ }
+ }
+ }
+
+ @Override public String toString() {
+ Configuration root = getRoot();
+ if (root == null) {
+ return getClass().getSimpleName() + "[path='" + getCurrentPath() + "', root='" + null
+ + "']";
+ } else {
+ return getClass().getSimpleName() + "[path='" + getCurrentPath() + "', root='" + root
+ .getClass().getSimpleName() + "']";
+ }
+ }
+}
diff --git a/Bukkit/src/main/java/com/github/intellectualsites/plotsquared/configuration/file/FileConfiguration.java b/Bukkit/src/main/java/com/github/intellectualsites/plotsquared/configuration/file/FileConfiguration.java
new file mode 100644
index 000000000..bc0b375e9
--- /dev/null
+++ b/Bukkit/src/main/java/com/github/intellectualsites/plotsquared/configuration/file/FileConfiguration.java
@@ -0,0 +1,158 @@
+package com.github.intellectualsites.plotsquared.configuration.file;
+
+import com.github.intellectualsites.plotsquared.configuration.Configuration;
+import com.github.intellectualsites.plotsquared.configuration.InvalidConfigurationException;
+import com.github.intellectualsites.plotsquared.configuration.MemoryConfiguration;
+
+import javax.annotation.Nonnull;
+import java.io.*;
+import java.nio.charset.StandardCharsets;
+
+/**
+ * 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.
+ */
+ FileConfiguration() {
+ }
+
+ /**
+ * Creates an empty {@link FileConfiguration} using the specified {@link
+ * Configuration} as a source for all default values.
+ *
+ * @param defaults Default value provider
+ */
+ public FileConfiguration(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.
+ */
+ public void save(File file) throws IOException {
+ File parent = file.getParentFile();
+ if (parent != null) {
+ parent.mkdirs();
+ }
+
+ String data = saveToString();
+
+ try (Writer writer = new OutputStreamWriter(new FileOutputStream(file),
+ StandardCharsets.UTF_8)) {
+ writer.write(data);
+ }
+ }
+
+ /**
+ * Saves this {@link FileConfiguration} to a string, and returns it.
+ *
+ * @return String containing this configuration.
+ */
+ 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(@Nonnull File file) throws IOException, InvalidConfigurationException {
+
+ FileInputStream stream = new FileInputStream(file);
+
+ load(new InputStreamReader(stream, StandardCharsets.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
+ */
+ public void load(Reader reader) throws IOException, InvalidConfigurationException {
+
+ StringBuilder builder = new StringBuilder();
+
+ try (BufferedReader input = reader instanceof BufferedReader ?
+ (BufferedReader) reader :
+ new BufferedReader(reader)) {
+ String line;
+
+ while ((line = input.readLine()) != null) {
+ builder.append(line);
+ builder.append('\n');
+ }
+ }
+
+ loadFromString(builder.toString());
+ }
+
+ /**
+ * 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.
+ */
+ public abstract void loadFromString(String contents) throws InvalidConfigurationException;
+
+ /**
+ * Compiles the header for this {@link FileConfiguration} and returns the
+ * result.
+ *
+ *
This will use the header from {@link #options()} -> {@link
+ * FileConfigurationOptions#header()}, respecting the rules of {@link
+ * FileConfigurationOptions#copyHeader()} if set.
+ *
+ * @return Compiled header
+ */
+ protected abstract String buildHeader();
+
+ @Override public FileConfigurationOptions options() {
+ if (this.options == null) {
+ this.options = new FileConfigurationOptions(this);
+ }
+
+ return (FileConfigurationOptions) this.options;
+ }
+}
diff --git a/Bukkit/src/main/java/com/github/intellectualsites/plotsquared/configuration/file/FileConfigurationOptions.java b/Bukkit/src/main/java/com/github/intellectualsites/plotsquared/configuration/file/FileConfigurationOptions.java
new file mode 100644
index 000000000..a216d0566
--- /dev/null
+++ b/Bukkit/src/main/java/com/github/intellectualsites/plotsquared/configuration/file/FileConfigurationOptions.java
@@ -0,0 +1,115 @@
+package com.github.intellectualsites.plotsquared.configuration.file;
+
+import com.github.intellectualsites.plotsquared.configuration.Configuration;
+import com.github.intellectualsites.plotsquared.configuration.MemoryConfiguration;
+import com.github.intellectualsites.plotsquared.configuration.MemoryConfigurationOptions;
+
+/**
+ * Various settings for controlling the input and output of a {@link
+ * FileConfiguration}.
+ */
+public class FileConfigurationOptions extends MemoryConfigurationOptions {
+ private String header = null;
+ private boolean copyHeader = true;
+
+ protected FileConfigurationOptions(MemoryConfiguration configuration) {
+ super(configuration);
+ }
+
+ @Override public FileConfiguration configuration() {
+ return (FileConfiguration) super.configuration();
+ }
+
+ @Override public FileConfigurationOptions copyDefaults(boolean value) {
+ super.copyDefaults(value);
+ return this;
+ }
+
+ @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.
+ *
+ *
{@code null} is a valid value which will indicate that no header]
+ * is to be applied. The default value is {@code null}.
+ *
+ * @return Header
+ */
+ public String header() {
+ return header;
+ }
+
+ /**
+ * 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.
+ *
+ *
{@code null} is a valid value which will indicate that no header
+ * is to be applied.
+ *
+ * @param value New header
+ * @return This object, for chaining
+ */
+ public FileConfigurationOptions header(String value) {
+ header = value;
+ return this;
+ }
+
+ /**
+ * Gets whether or not the header should be copied from a default source.
+ *
+ *
If this is true, if a default {@link FileConfiguration} is passed to
+ * {@link FileConfiguration#setDefaults(Configuration)}
+ * then upon saving it will use the header from that config, instead of
+ * the one provided here.
+ *
+ *
If no default is set on the configuration, or the default is not of
+ * type FileConfiguration, or that config has no header ({@link #header()}
+ * returns null) then the header specified in this configuration will be
+ * used.
+ *
+ *
Defaults to true.
+ *
+ * @return Whether or not to copy the header
+ */
+ public boolean copyHeader() {
+ return copyHeader;
+ }
+
+ /**
+ * Sets whether or not the header should be copied from a default source.
+ *
+ *
If this is true, if a default {@link FileConfiguration} is passed to
+ * {@link FileConfiguration#setDefaults(Configuration)}
+ * then upon saving it will use the header from that config, instead of
+ * the one provided here.
+ *
+ *
If no default is set on the configuration, or the default is not of
+ * type FileConfiguration, or that config has no header ({@link #header()}
+ * returns null) then the header specified in this configuration will be
+ * used.
+ *
+ *
Defaults to true.
+ *
+ * @param value Whether or not to copy the header
+ * @return This object, for chaining
+ */
+ public FileConfigurationOptions copyHeader(boolean value) {
+ copyHeader = value;
+
+ return this;
+ }
+}
diff --git a/Bukkit/src/main/java/com/github/intellectualsites/plotsquared/configuration/file/YamlConfiguration.java b/Bukkit/src/main/java/com/github/intellectualsites/plotsquared/configuration/file/YamlConfiguration.java
new file mode 100644
index 000000000..1e694f05a
--- /dev/null
+++ b/Bukkit/src/main/java/com/github/intellectualsites/plotsquared/configuration/file/YamlConfiguration.java
@@ -0,0 +1,189 @@
+package com.github.intellectualsites.plotsquared.configuration.file;
+
+import com.github.intellectualsites.plotsquared.configuration.Configuration;
+import com.github.intellectualsites.plotsquared.configuration.ConfigurationSection;
+import com.github.intellectualsites.plotsquared.configuration.InvalidConfigurationException;
+import com.github.intellectualsites.plotsquared.plot.PlotSquared;
+import org.yaml.snakeyaml.DumperOptions;
+import org.yaml.snakeyaml.Yaml;
+import org.yaml.snakeyaml.error.YAMLException;
+import org.yaml.snakeyaml.representer.Representer;
+
+import java.io.File;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.StandardCopyOption;
+import java.util.Map;
+
+/**
+ * An implementation of {@link Configuration} which saves all files in Yaml.
+ * Note that this implementation is not synchronized.
+ */
+public class YamlConfiguration extends FileConfiguration {
+ private static final String COMMENT_PREFIX = "# ";
+ private static final String BLANK_CONFIG = "{}\n";
+ private final DumperOptions yamlOptions = new DumperOptions();
+ private final Representer yamlRepresenter = new YamlRepresenter();
+ private final Yaml yaml = new Yaml(new YamlConstructor(), yamlRepresenter, yamlOptions);
+
+ /**
+ * 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
+ */
+ public static YamlConfiguration loadConfiguration(File file) {
+ YamlConfiguration config = new YamlConfiguration();
+
+ try {
+ config.load(file);
+ } catch (InvalidConfigurationException | IOException ex) {
+ try {
+ File dest = new File(file.getAbsolutePath() + "_broken");
+ int i = 0;
+ while (dest.exists()) {
+ dest = new File(file.getAbsolutePath() + "_broken_" + i++);
+ }
+ Files.copy(file.toPath(), dest.toPath(), StandardCopyOption.REPLACE_EXISTING);
+ PlotSquared.debug("&dCould not read: &7" + file);
+ PlotSquared.debug("&dRenamed to: &7" + dest.getName());
+ PlotSquared.debug("&c============ Full stacktrace ============");
+ ex.printStackTrace();
+ PlotSquared.debug("&c=========================================");
+ } catch (IOException e) {
+ e.printStackTrace();
+ }
+ }
+
+ return config;
+ }
+
+ @Override public String saveToString() {
+ yamlOptions.setIndent(options().indent());
+ yamlOptions.setDefaultFlowStyle(DumperOptions.FlowStyle.BLOCK);
+ yamlRepresenter.setDefaultFlowStyle(DumperOptions.FlowStyle.BLOCK);
+
+ String header = buildHeader();
+ String dump = yaml.dump(getValues(false));
+
+ if (dump.equals(BLANK_CONFIG)) {
+ dump = "";
+ }
+
+ return header + dump;
+ }
+
+ @Override public void loadFromString(String contents) throws InvalidConfigurationException {
+
+ Map input;
+ try {
+ input = yaml.load(contents);
+ } catch (YAMLException e) {
+ throw new InvalidConfigurationException(e);
+ } catch (ClassCastException ignored) {
+ throw new InvalidConfigurationException("Top level is not a Map.");
+ }
+
+ String header = parseHeader(contents);
+ if (!header.isEmpty()) {
+ options().header(header);
+ }
+
+ if (input != null) {
+ convertMapsToSections(input, this);
+ }
+ }
+
+ protected void convertMapsToSections(Map input, ConfigurationSection section) {
+ for (Map.Entry entry : input.entrySet()) {
+ String key = entry.getKey().toString();
+ Object value = entry.getValue();
+
+ if (value instanceof Map) {
+ convertMapsToSections((Map) value, section.createSection(key));
+ } else {
+ section.set(key, value);
+ }
+ }
+ }
+
+ protected String parseHeader(String input) {
+ String[] lines = input.split("\r?\n", -1);
+ StringBuilder result = new StringBuilder();
+ boolean readingHeader = true;
+ boolean foundHeader = false;
+
+ for (int i = 0; (i < lines.length) && readingHeader; i++) {
+ String line = lines[i];
+
+ if (line.startsWith(COMMENT_PREFIX)) {
+ if (i > 0) {
+ result.append('\n');
+ }
+
+ if (line.length() > COMMENT_PREFIX.length()) {
+ result.append(line.substring(COMMENT_PREFIX.length()));
+ }
+
+ foundHeader = true;
+ } else if (foundHeader && line.isEmpty()) {
+ result.append('\n');
+ } else if (foundHeader) {
+ readingHeader = false;
+ }
+ }
+
+ return result.toString();
+ }
+
+ @Override protected String buildHeader() {
+ String header = options().header();
+
+ if (options().copyHeader()) {
+ Configuration def = getDefaults();
+
+ if (def instanceof FileConfiguration) {
+ FileConfiguration fileDefaults = (FileConfiguration) def;
+ String defaultsHeader = fileDefaults.buildHeader();
+
+ if ((defaultsHeader != null) && !defaultsHeader.isEmpty()) {
+ return defaultsHeader;
+ }
+ }
+ }
+
+ if (header == null) {
+ return "";
+ }
+
+ StringBuilder builder = new StringBuilder();
+ String[] lines = header.split("\r?\n", -1);
+ boolean startedHeader = false;
+
+ for (int i = lines.length - 1; i >= 0; i--) {
+ builder.insert(0, '\n');
+
+ if (startedHeader || !lines[i].isEmpty()) {
+ builder.insert(0, lines[i]);
+ builder.insert(0, COMMENT_PREFIX);
+ startedHeader = true;
+ }
+ }
+
+ return builder.toString();
+ }
+
+ @Override public YamlConfigurationOptions options() {
+ if (options == null) {
+ options = new YamlConfigurationOptions(this);
+ }
+
+ return (YamlConfigurationOptions) options;
+ }
+}
diff --git a/Bukkit/src/main/java/com/github/intellectualsites/plotsquared/configuration/file/YamlConfigurationOptions.java b/Bukkit/src/main/java/com/github/intellectualsites/plotsquared/configuration/file/YamlConfigurationOptions.java
new file mode 100644
index 000000000..730527652
--- /dev/null
+++ b/Bukkit/src/main/java/com/github/intellectualsites/plotsquared/configuration/file/YamlConfigurationOptions.java
@@ -0,0 +1,68 @@
+package com.github.intellectualsites.plotsquared.configuration.file;
+
+/**
+ * Various settings for controlling the input and output of a {@link
+ * YamlConfiguration}.
+ */
+public class YamlConfigurationOptions extends FileConfigurationOptions {
+ private int indent = 2;
+
+ YamlConfigurationOptions(YamlConfiguration configuration) {
+ super(configuration);
+ }
+
+ @Override public YamlConfiguration configuration() {
+ return (YamlConfiguration) super.configuration();
+ }
+
+ @Override public YamlConfigurationOptions copyDefaults(boolean value) {
+ super.copyDefaults(value);
+ return this;
+ }
+
+ @Override public YamlConfigurationOptions pathSeparator(char value) {
+ super.pathSeparator(value);
+ return this;
+ }
+
+ @Override public YamlConfigurationOptions header(String value) {
+ super.header(value);
+ return this;
+ }
+
+ @Override 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
+ */
+ 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
+ */
+ public YamlConfigurationOptions indent(int value) {
+ if (value < 2) {
+ throw new IllegalArgumentException("Indent must be at least 2 characters");
+ }
+ if (value > 9) {
+ throw new IllegalArgumentException("Indent cannot be greater than 9 characters");
+ }
+
+ indent = value;
+ return this;
+ }
+}
diff --git a/Bukkit/src/main/java/com/github/intellectualsites/plotsquared/configuration/file/YamlConstructor.java b/Bukkit/src/main/java/com/github/intellectualsites/plotsquared/configuration/file/YamlConstructor.java
new file mode 100644
index 000000000..cdc5eb821
--- /dev/null
+++ b/Bukkit/src/main/java/com/github/intellectualsites/plotsquared/configuration/file/YamlConstructor.java
@@ -0,0 +1,46 @@
+package com.github.intellectualsites.plotsquared.configuration.file;
+
+import com.github.intellectualsites.plotsquared.configuration.serialization.ConfigurationSerialization;
+import org.yaml.snakeyaml.constructor.SafeConstructor;
+import org.yaml.snakeyaml.error.YAMLException;
+import org.yaml.snakeyaml.nodes.Node;
+import org.yaml.snakeyaml.nodes.Tag;
+
+import java.util.LinkedHashMap;
+import java.util.Map;
+
+class YamlConstructor extends SafeConstructor {
+
+ YamlConstructor() {
+ yamlConstructors.put(Tag.MAP, new ConstructCustomObject());
+ }
+
+ private class ConstructCustomObject extends ConstructYamlMap {
+ @Override public Object construct(final Node node) {
+ if (node.isTwoStepsConstruction()) {
+ throw new YAMLException("Unexpected referential mapping structure. Node: " + node);
+ }
+
+ final Map raw = (Map) super.construct(node);
+
+ if (raw.containsKey(ConfigurationSerialization.SERIALIZED_TYPE_KEY)) {
+ final Map typed = new LinkedHashMap<>(raw.size());
+ for (final Map.Entry entry : raw.entrySet()) {
+ typed.put(entry.getKey().toString(), entry.getValue());
+ }
+
+ try {
+ return ConfigurationSerialization.deserializeObject(typed);
+ } catch (final IllegalArgumentException ex) {
+ throw new YAMLException("Could not deserialize object", ex);
+ }
+ }
+
+ return raw;
+ }
+
+ @Override public void construct2ndStep(final Node node, final Object object) {
+ throw new YAMLException("Unexpected referential mapping structure. Node: " + node);
+ }
+ }
+}
diff --git a/Bukkit/src/main/java/com/github/intellectualsites/plotsquared/configuration/file/YamlRepresenter.java b/Bukkit/src/main/java/com/github/intellectualsites/plotsquared/configuration/file/YamlRepresenter.java
new file mode 100644
index 000000000..ebe1aebee
--- /dev/null
+++ b/Bukkit/src/main/java/com/github/intellectualsites/plotsquared/configuration/file/YamlRepresenter.java
@@ -0,0 +1,40 @@
+package com.github.intellectualsites.plotsquared.configuration.file;
+
+import com.github.intellectualsites.plotsquared.configuration.ConfigurationSection;
+import com.github.intellectualsites.plotsquared.configuration.serialization.ConfigurationSerializable;
+import com.github.intellectualsites.plotsquared.configuration.serialization.ConfigurationSerialization;
+import org.yaml.snakeyaml.nodes.Node;
+import org.yaml.snakeyaml.representer.Representer;
+
+import java.util.LinkedHashMap;
+import java.util.Map;
+
+class YamlRepresenter extends Representer {
+
+ YamlRepresenter() {
+ this.multiRepresenters.put(ConfigurationSection.class, new RepresentConfigurationSection());
+ this.multiRepresenters
+ .put(ConfigurationSerializable.class, new RepresentConfigurationSerializable());
+ }
+
+ private class RepresentConfigurationSection extends RepresentMap {
+
+ @Override public Node representData(Object data) {
+ return super.representData(((ConfigurationSection) data).getValues(false));
+ }
+ }
+
+
+ private class RepresentConfigurationSerializable extends RepresentMap {
+
+ @Override public Node representData(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/Bukkit/src/main/java/com/github/intellectualsites/plotsquared/configuration/serialization/ConfigurationSerializable.java b/Bukkit/src/main/java/com/github/intellectualsites/plotsquared/configuration/serialization/ConfigurationSerializable.java
new file mode 100644
index 000000000..f83e7a468
--- /dev/null
+++ b/Bukkit/src/main/java/com/github/intellectualsites/plotsquared/configuration/serialization/ConfigurationSerializable.java
@@ -0,0 +1,34 @@
+package com.github.intellectualsites.plotsquared.configuration.serialization;
+
+import java.util.Map;
+
+/**
+ * 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 javadoc.
+ *
+ * @return Map containing the current state of this class
+ */
+ Map serialize();
+}
diff --git a/Bukkit/src/main/java/com/github/intellectualsites/plotsquared/configuration/serialization/ConfigurationSerialization.java b/Bukkit/src/main/java/com/github/intellectualsites/plotsquared/configuration/serialization/ConfigurationSerialization.java
new file mode 100644
index 000000000..0783b4af5
--- /dev/null
+++ b/Bukkit/src/main/java/com/github/intellectualsites/plotsquared/configuration/serialization/ConfigurationSerialization.java
@@ -0,0 +1,262 @@
+package com.github.intellectualsites.plotsquared.configuration.serialization;
+
+import com.github.intellectualsites.plotsquared.configuration.Configuration;
+
+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;
+
+/**
+ * Utility class for storing and retrieving classes for {@link Configuration}.
+ */
+public class ConfigurationSerialization {
+
+ public static final String SERIALIZED_TYPE_KEY = "==";
+ private static final Map> aliases =
+ new HashMap<>();
+ private final Class clazz;
+
+ protected ConfigurationSerialization(Class clazz) {
+ this.clazz = clazz;
+ }
+
+ /**
+ * 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
+ */
+ public static ConfigurationSerializable deserializeObject(Map args,
+ 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
+ */
+ public static ConfigurationSerializable deserializeObject(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(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(Class clazz,
+ String alias) {
+ aliases.put(alias, clazz);
+ }
+
+ /**
+ * Unregisters the specified alias to a {@link ConfigurationSerializable}
+ *
+ * @param alias Alias to unregister
+ */
+ public static void unregisterClass(String alias) {
+ aliases.remove(alias);
+ }
+
+ /**
+ * Unregisters any aliases for the specified {@link
+ * ConfigurationSerializable} class.
+ *
+ * @param clazz Class to unregister
+ */
+ public static void unregisterClass(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
+ */
+ public static Class getClassByAlias(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
+ */
+ public static String getAlias(Class clazz) {
+ DelegateDeserialization delegate = clazz.getAnnotation(DelegateDeserialization.class);
+
+ if (delegate != null) {
+ if (delegate.value() == clazz) {
+ delegate = null;
+ } else {
+ return getAlias(delegate.value());
+ }
+ }
+
+ SerializableAs alias = clazz.getAnnotation(SerializableAs.class);
+
+ if (alias != null) {
+ return alias.value();
+ }
+
+ return clazz.getName();
+ }
+
+ protected Method getMethod(String name, boolean isStatic) {
+ try {
+ Method method = this.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 | SecurityException ignored) {
+ return null;
+ }
+ }
+
+ protected Constructor getConstructor() {
+ try {
+ return this.clazz.getConstructor(Map.class);
+ } catch (NoSuchMethodException | SecurityException ignored) {
+ return null;
+ }
+ }
+
+ protected ConfigurationSerializable deserializeViaMethod(Method method, 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 " + this.clazz
+ + " for deserialization: method returned null");
+ } else {
+ return result;
+ }
+ } catch (IllegalAccessException | InvocationTargetException | IllegalArgumentException ex) {
+ Logger.getLogger(ConfigurationSerialization.class.getName()).log(Level.SEVERE,
+ "Could not call method '" + method.toString() + "' of " + this.clazz
+ + " for deserialization",
+ ex instanceof InvocationTargetException ? ex.getCause() : ex);
+ }
+
+ return null;
+ }
+
+ protected ConfigurationSerializable deserializeViaCtor(
+ Constructor ctor, Map args) {
+ try {
+ return ctor.newInstance(args);
+ } catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException | InstantiationException ex) {
+ Logger.getLogger(ConfigurationSerialization.class.getName()).log(Level.SEVERE,
+ "Could not call constructor '" + ctor.toString() + "' of " + this.clazz
+ + " for deserialization",
+ ex instanceof InvocationTargetException ? ex.getCause() : ex);
+ }
+
+ return null;
+ }
+
+ public ConfigurationSerializable deserialize(Map args) {
+ if (args == null) {
+ throw new NullPointerException("Args must not be null");
+ }
+ ConfigurationSerializable result = null;
+ Method 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;
+ }
+}
diff --git a/Bukkit/src/main/java/com/github/intellectualsites/plotsquared/configuration/serialization/DelegateDeserialization.java b/Bukkit/src/main/java/com/github/intellectualsites/plotsquared/configuration/serialization/DelegateDeserialization.java
new file mode 100644
index 000000000..8a071cb2e
--- /dev/null
+++ b/Bukkit/src/main/java/com/github/intellectualsites/plotsquared/configuration/serialization/DelegateDeserialization.java
@@ -0,0 +1,21 @@
+package com.github.intellectualsites.plotsquared.configuration.serialization;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * 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
+ */
+ Class value();
+}
diff --git a/Bukkit/src/main/java/com/github/intellectualsites/plotsquared/configuration/serialization/SerializableAs.java b/Bukkit/src/main/java/com/github/intellectualsites/plotsquared/configuration/serialization/SerializableAs.java
new file mode 100644
index 000000000..79b50998c
--- /dev/null
+++ b/Bukkit/src/main/java/com/github/intellectualsites/plotsquared/configuration/serialization/SerializableAs.java
@@ -0,0 +1,32 @@
+package com.github.intellectualsites.plotsquared.configuration.serialization;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * 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.
+ */
+ String value();
+}
diff --git a/Bukkit/src/main/java/com/github/intellectualsites/plotsquared/json/JSONArray.java b/Bukkit/src/main/java/com/github/intellectualsites/plotsquared/json/JSONArray.java
new file mode 100644
index 000000000..62ee01329
--- /dev/null
+++ b/Bukkit/src/main/java/com/github/intellectualsites/plotsquared/json/JSONArray.java
@@ -0,0 +1,815 @@
+package com.github.intellectualsites.plotsquared.json;
+
+import java.io.IOException;
+import java.io.StringWriter;
+import java.io.Writer;
+import java.lang.reflect.Array;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Map;
+
+/**
+ * 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 {@code get} and {@code opt} methods for
+ * accessing the values by index, and {@code put} methods for adding or replacing values. The values can be any of
+ * these types: {@code Boolean}, {@code JSONArray}, {@code JSONObject}, {@code Number},
+ * {@code String}, or the {@code JSONObject.NULL object}.
+ *
+ *
The constructor can convert a JSON text into a Java object. The {@code toString} method converts to JSON text.
+ *
+ *
A {@code get} method returns a value if one can be found, and throws an exception if one cannot be found. An
+ * {@code opt} method returns a default value instead of throwing an exception, and so is useful for obtaining
+ * optional values.
+ *
+ *
The generic {@code get()} and {@code opt()} methods return an object which you can cast or query for type.
+ * There are also typed {@code get} and {@code opt} methods that do type checking and type coercion for you.
+ *
+ *
The texts produced by the {@code toString} methods strictly conform to JSON syntax rules. The constructors are
+ * more forgiving in the texts they will accept:
An extra {@code ,} (comma) may appear
+ * just before the closing bracket.
The {@code null} value will be inserted when there is {@code ,}
+ * (comma) elision.
Strings may be quoted with {@code '} (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: {@code { }
+ * [ ] / \ : , #} and if they do not look like numbers and if they are not the reserved words {@code true},
+ * {@code false}, or {@code null}.
+ *
+ * @author JSON.org
+ * @version 2014-05-03
+ */
+public class JSONArray {
+ /**
+ * The arrayList where the JSONArray's properties are kept.
+ */
+ private final ArrayList