frames = new ArrayList<>();
+
+ @Nonnull
+ public SoundSample addSound(@Nonnull Sound sound, float volume, float pitch) {
+ frames.add(new SoundFrame(sound, volume, pitch));
+ return this;
+ }
+
+ @Nonnull
+ public SoundSample addSound(@Nonnull Sound sound, float volume) {
+ frames.add(new SoundFrame(sound, volume));
+ return this;
+ }
+
+ @Nonnull
+ public SoundSample addSound(@Nonnull SoundSample sound) {
+ frames.addAll(sound.frames);
+ return this;
+ }
+
+ public void play(@Nonnull Player player) {
+ play(player, player.getLocation());
+ }
+
+ public void play(@Nonnull Player player, @Nonnull Location location) {
+ for (SoundFrame frame : frames) {
+ frame.play(player, location);
+ }
+ }
+
+ public void playIfPlayer(@Nonnull Object target) {
+ if (target instanceof Player)
+ play((Player) target);
+ }
+
+ public void broadcast() {
+ Bukkit.getOnlinePlayers().forEach(this::play);
+ }
+
+ public void broadcast(@Nonnull Location location) {
+ Bukkit.getOnlinePlayers().forEach(player -> play(player, location));
+ }
+
+}
diff --git a/plugin/src/main/java/net/codingarea/commons/bukkit/utils/bstats/JsonObjectBuilder.java b/plugin/src/main/java/net/codingarea/commons/bukkit/utils/bstats/JsonObjectBuilder.java
new file mode 100644
index 000000000..172e2e4ff
--- /dev/null
+++ b/plugin/src/main/java/net/codingarea/commons/bukkit/utils/bstats/JsonObjectBuilder.java
@@ -0,0 +1,210 @@
+package net.codingarea.commons.bukkit.utils.bstats;
+
+import java.util.Arrays;
+import java.util.stream.Collectors;
+
+/**
+ * An extremely simple JSON builder.
+ *
+ * While this class is neither feature-rich nor the most performant one, it's sufficient enough
+ * for its use-case.
+ */
+public class JsonObjectBuilder {
+
+ private StringBuilder builder = new StringBuilder();
+
+ private boolean hasAtLeastOneField = false;
+
+ public JsonObjectBuilder() {
+ builder.append("{");
+ }
+
+ /**
+ * Appends a null field to the JSON.
+ *
+ * @param key The key of the field.
+ * @return A reference to this object.
+ */
+ public JsonObjectBuilder appendNull(String key) {
+ appendFieldUnescaped(key, "null");
+ return this;
+ }
+
+ /**
+ * Appends a string field to the JSON.
+ *
+ * @param key The key of the field.
+ * @param value The value of the field.
+ * @return A reference to this object.
+ */
+ public JsonObjectBuilder appendField(String key, String value) {
+ if (value == null) {
+ throw new IllegalArgumentException("JSON value must not be null");
+ }
+ appendFieldUnescaped(key, "\"" + escape(value) + "\"");
+ return this;
+ }
+
+ /**
+ * Appends an integer field to the JSON.
+ *
+ * @param key The key of the field.
+ * @param value The value of the field.
+ * @return A reference to this object.
+ */
+ public JsonObjectBuilder appendField(String key, int value) {
+ appendFieldUnescaped(key, String.valueOf(value));
+ return this;
+ }
+
+ /**
+ * Appends an object to the JSON.
+ *
+ * @param key The key of the field.
+ * @param object The object.
+ * @return A reference to this object.
+ */
+ public JsonObjectBuilder appendField(String key, JsonObject object) {
+ if (object == null) {
+ throw new IllegalArgumentException("JSON object must not be null");
+ }
+ appendFieldUnescaped(key, object.toString());
+ return this;
+ }
+
+ /**
+ * Appends a string array to the JSON.
+ *
+ * @param key The key of the field.
+ * @param values The string array.
+ * @return A reference to this object.
+ */
+ public JsonObjectBuilder appendField(String key, String[] values) {
+ if (values == null) {
+ throw new IllegalArgumentException("JSON values must not be null");
+ }
+ String escapedValues =
+ Arrays.stream(values)
+ .map(value -> "\"" + escape(value) + "\"")
+ .collect(Collectors.joining(","));
+ appendFieldUnescaped(key, "[" + escapedValues + "]");
+ return this;
+ }
+
+ /**
+ * Appends an integer array to the JSON.
+ *
+ * @param key The key of the field.
+ * @param values The integer array.
+ * @return A reference to this object.
+ */
+ public JsonObjectBuilder appendField(String key, int[] values) {
+ if (values == null) {
+ throw new IllegalArgumentException("JSON values must not be null");
+ }
+ String escapedValues =
+ Arrays.stream(values).mapToObj(String::valueOf).collect(Collectors.joining(","));
+ appendFieldUnescaped(key, "[" + escapedValues + "]");
+ return this;
+ }
+
+ /**
+ * Appends an object array to the JSON.
+ *
+ * @param key The key of the field.
+ * @param values The integer array.
+ * @return A reference to this object.
+ */
+ public JsonObjectBuilder appendField(String key, JsonObject[] values) {
+ if (values == null) {
+ throw new IllegalArgumentException("JSON values must not be null");
+ }
+ String escapedValues =
+ Arrays.stream(values).map(JsonObject::toString).collect(Collectors.joining(","));
+ appendFieldUnescaped(key, "[" + escapedValues + "]");
+ return this;
+ }
+
+ /**
+ * Appends a field to the object.
+ *
+ * @param key The key of the field.
+ * @param escapedValue The escaped value of the field.
+ */
+ private void appendFieldUnescaped(String key, String escapedValue) {
+ if (builder == null) {
+ throw new IllegalStateException("JSON has already been built");
+ }
+ if (key == null) {
+ throw new IllegalArgumentException("JSON key must not be null");
+ }
+ if (hasAtLeastOneField) {
+ builder.append(",");
+ }
+ builder.append("\"").append(escape(key)).append("\":").append(escapedValue);
+ hasAtLeastOneField = true;
+ }
+
+ /**
+ * Builds the JSON string and invalidates this builder.
+ *
+ * @return The built JSON string.
+ */
+ public JsonObject build() {
+ if (builder == null) {
+ throw new IllegalStateException("JSON has already been built");
+ }
+ JsonObject object = new JsonObject(builder.append("}").toString());
+ builder = null;
+ return object;
+ }
+
+ /**
+ * Escapes the given string like stated in https://www.ietf.org/rfc/rfc4627.txt.
+ *
+ *
This method escapes only the necessary characters '"', '\'. and '\u0000' - '\u001F'.
+ * Compact escapes are not used (e.g., '\n' is escaped as "\u000a" and not as "\n").
+ *
+ * @param value The value to escape.
+ * @return The escaped value.
+ */
+ private static String escape(String value) {
+ final StringBuilder builder = new StringBuilder();
+ for (int i = 0; i < value.length(); i++) {
+ char c = value.charAt(i);
+ if (c == '"') {
+ builder.append("\\\"");
+ } else if (c == '\\') {
+ builder.append("\\\\");
+ } else if (c <= '\u000F') {
+ builder.append("\\u000").append(Integer.toHexString(c));
+ } else if (c <= '\u001F') {
+ builder.append("\\u00").append(Integer.toHexString(c));
+ } else {
+ builder.append(c);
+ }
+ }
+ return builder.toString();
+ }
+
+ /**
+ * A super simple representation of a JSON object.
+ *
+ *
This class only exists to make methods of the {@link JsonObjectBuilder} type-safe and not
+ * allow a raw string inputs for methods like {@link JsonObjectBuilder#appendField(String,
+ * JsonObject)}.
+ */
+ public static class JsonObject {
+
+ private final String value;
+
+ private JsonObject(String value) {
+ this.value = value;
+ }
+
+ @Override
+ public String toString() {
+ return value;
+ }
+ }
+}
diff --git a/plugin/src/main/java/net/codingarea/commons/bukkit/utils/bstats/Metrics.java b/plugin/src/main/java/net/codingarea/commons/bukkit/utils/bstats/Metrics.java
new file mode 100644
index 000000000..60574d3fc
--- /dev/null
+++ b/plugin/src/main/java/net/codingarea/commons/bukkit/utils/bstats/Metrics.java
@@ -0,0 +1,333 @@
+package net.codingarea.commons.bukkit.utils.bstats;
+
+import net.codingarea.commons.bukkit.utils.bstats.chart.CustomChart;
+import org.bukkit.Bukkit;
+import org.bukkit.configuration.file.YamlConfiguration;
+import org.bukkit.entity.Player;
+import org.bukkit.plugin.Plugin;
+import org.bukkit.plugin.java.JavaPlugin;
+
+import javax.net.ssl.HttpsURLConnection;
+import java.io.*;
+import java.lang.reflect.Method;
+import java.net.URL;
+import java.nio.charset.StandardCharsets;
+import java.util.*;
+import java.util.concurrent.Executors;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.TimeUnit;
+import java.util.function.BiConsumer;
+import java.util.function.Consumer;
+import java.util.function.Supplier;
+import java.util.logging.Level;
+import java.util.zip.GZIPOutputStream;
+
+public class Metrics {
+
+ private final Plugin plugin;
+ private final MetricsBase metricsBase;
+
+ /**
+ * Creates a new Metrics instance.
+ *
+ * @param plugin Your plugin instance.
+ * @param serviceId The id of the service. It can be found at What is my plugin id?
+ */
+ public Metrics(JavaPlugin plugin, int serviceId) {
+ this.plugin = plugin;
+
+ // Get the config file
+ File bStatsFolder = new File(plugin.getDataFolder().getParentFile(), "bStats");
+ File configFile = new File(bStatsFolder, "config.yml");
+ YamlConfiguration config = YamlConfiguration.loadConfiguration(configFile);
+ if (!config.isSet("serverUuid")) {
+ config.addDefault("enabled", true);
+ config.addDefault("serverUuid", UUID.randomUUID().toString());
+ config.addDefault("logFailedRequests", false);
+ config.addDefault("logSentData", false);
+ config.addDefault("logResponseStatusText", false);
+ // Inform the server owners about bStats
+ config
+ .options()
+ .header(
+ "bStats (https://bStats.org) collects some basic information for plugin authors, like how\n"
+ + "many people use their plugin and their total player count. It's recommended to keep bStats\n"
+ + "enabled, but if you're not comfortable with this, you can turn this setting off. There is no\n"
+ + "performance penalty associated with having metrics enabled, and data sent to bStats is fully\n"
+ + "anonymous.")
+ .copyDefaults(true);
+ try {
+ config.save(configFile);
+ } catch (IOException ignored) {
+ }
+ }
+
+ String serverUUID = config.getString("serverUuid");
+ boolean logErrors = config.getBoolean("logFailedRequests", false);
+ boolean logSentData = config.getBoolean("logSentData", false);
+ boolean logResponseStatusText = config.getBoolean("logResponseStatusText", false);
+ metricsBase =
+ new MetricsBase(
+ "bukkit",
+ serverUUID,
+ serviceId,
+ true,
+ this::appendPlatformData,
+ this::appendServiceData,
+ submitDataTask -> Bukkit.getScheduler().runTask(plugin, submitDataTask),
+ plugin::isEnabled,
+ (message, error) -> this.plugin.getLogger().log(Level.WARNING, message, error),
+ (message) -> this.plugin.getLogger().log(Level.INFO, message),
+ logErrors,
+ logSentData,
+ logResponseStatusText);
+ }
+
+ /**
+ * Adds a custom chart.
+ *
+ * @param chart The chart to add.
+ */
+ public void addCustomChart(CustomChart chart) {
+ metricsBase.addCustomChart(chart);
+ }
+
+ private void appendPlatformData(JsonObjectBuilder builder) {
+ builder.appendField("playerAmount", getPlayerAmount());
+ builder.appendField("onlineMode", Bukkit.getOnlineMode() ? 1 : 0);
+ builder.appendField("bukkitVersion", Bukkit.getVersion());
+ builder.appendField("bukkitName", Bukkit.getName());
+ builder.appendField("javaVersion", System.getProperty("java.version"));
+ builder.appendField("osName", System.getProperty("os.name"));
+ builder.appendField("osArch", System.getProperty("os.arch"));
+ builder.appendField("osVersion", System.getProperty("os.version"));
+ builder.appendField("coreCount", Runtime.getRuntime().availableProcessors());
+ }
+
+ private void appendServiceData(JsonObjectBuilder builder) {
+ builder.appendField("pluginVersion", plugin.getDescription().getVersion());
+ }
+
+ private int getPlayerAmount() {
+ try {
+ // Around MC 1.8 the return type was changed from an array to a collection,
+ // This fixes java.lang.NoSuchMethodError:
+ // org.bukkit.Bukkit.getOnlinePlayers()Ljava/util/Collection;
+ Method onlinePlayersMethod = Class.forName("org.bukkit.Server").getMethod("getOnlinePlayers");
+ return onlinePlayersMethod.getReturnType().equals(Collection.class)
+ ? ((Collection) onlinePlayersMethod.invoke(Bukkit.getServer())).size()
+ : ((Player[]) onlinePlayersMethod.invoke(Bukkit.getServer())).length;
+ } catch (Exception e) {
+ // Just use the new method if the reflection failed
+ return Bukkit.getOnlinePlayers().size();
+ }
+ }
+
+ public static class MetricsBase {
+
+ /** The version of the Metrics class. */
+ public static final String METRICS_VERSION = "2.2.1";
+
+ private static final ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(1, task -> new Thread(task, "bStats-Metrics"));
+ private static final String REPORT_URL = "https://bStats.org/api/v2/data/%s";
+
+ private final String platform;
+ private final String serverUuid;
+ private final int serviceId;
+ private final Consumer appendPlatformDataConsumer;
+ private final Consumer appendServiceDataConsumer;
+ private final Consumer submitTaskConsumer;
+ private final Supplier checkServiceEnabledSupplier;
+ private final BiConsumer errorLogger;
+ private final Consumer infoLogger;
+ private final boolean logErrors;
+ private final boolean logSentData;
+ private final boolean logResponseStatusText;
+ private final Set customCharts = new HashSet<>();
+ private final boolean enabled;
+
+ /**
+ * Creates a new MetricsBase class instance.
+ *
+ * @param platform The platform of the service.
+ * @param serviceId The id of the service.
+ * @param serverUuid The server uuid.
+ * @param enabled Whether or not data sending is enabled.
+ * @param appendPlatformDataConsumer A consumer that receives a {@code JsonObjectBuilder} and
+ * appends all platform-specific data.
+ * @param appendServiceDataConsumer A consumer that receives a {@code JsonObjectBuilder} and
+ * appends all service-specific data.
+ * @param submitTaskConsumer A consumer that takes a runnable with the submit task. This can be
+ * used to delegate the data collection to a another thread to prevent errors caused by
+ * concurrency. Can be {@code null}.
+ * @param checkServiceEnabledSupplier A supplier to check if the service is still enabled.
+ * @param errorLogger A consumer that accepts log message and an error.
+ * @param infoLogger A consumer that accepts info log messages.
+ * @param logErrors Whether or not errors should be logged.
+ * @param logSentData Whether or not the sent data should be logged.
+ * @param logResponseStatusText Whether or not the response status text should be logged.
+ */
+ public MetricsBase(
+ String platform,
+ String serverUuid,
+ int serviceId,
+ boolean enabled,
+ Consumer appendPlatformDataConsumer,
+ Consumer appendServiceDataConsumer,
+ Consumer submitTaskConsumer,
+ Supplier checkServiceEnabledSupplier,
+ BiConsumer errorLogger,
+ Consumer infoLogger,
+ boolean logErrors,
+ boolean logSentData,
+ boolean logResponseStatusText) {
+ this.platform = platform;
+ this.serverUuid = serverUuid;
+ this.serviceId = serviceId;
+ this.enabled = enabled;
+ this.appendPlatformDataConsumer = appendPlatformDataConsumer;
+ this.appendServiceDataConsumer = appendServiceDataConsumer;
+ this.submitTaskConsumer = submitTaskConsumer;
+ this.checkServiceEnabledSupplier = checkServiceEnabledSupplier;
+ this.errorLogger = errorLogger;
+ this.infoLogger = infoLogger;
+ this.logErrors = logErrors;
+ this.logSentData = logSentData;
+ this.logResponseStatusText = logResponseStatusText;
+ checkRelocation();
+ if (enabled) {
+ startSubmitting();
+ }
+ }
+
+ public void addCustomChart(CustomChart chart) {
+ this.customCharts.add(chart);
+ }
+
+ private void startSubmitting() {
+ final Runnable submitTask =
+ () -> {
+ if (!enabled || !checkServiceEnabledSupplier.get()) {
+ // Submitting data or service is disabled
+ scheduler.shutdown();
+ return;
+ }
+ if (submitTaskConsumer != null) {
+ submitTaskConsumer.accept(this::submitData);
+ } else {
+ this.submitData();
+ }
+ };
+ // Many servers tend to restart at a fixed time at xx:00 which causes an uneven distribution
+ // of requests on the
+ // bStats backend. To circumvent this problem, we introduce some randomness into the initial
+ // and second delay.
+ // WARNING: You must not modify and part of this Metrics class, including the submit delay or
+ // frequency!
+ // WARNING: Modifying this code will get your plugin banned on bStats. Just don't do it!
+ long initialDelay = (long) (1000 * 60 * (3 + Math.random() * 3));
+ long secondDelay = (long) (1000 * 60 * (Math.random() * 30));
+ scheduler.schedule(submitTask, initialDelay, TimeUnit.MILLISECONDS);
+ scheduler.scheduleAtFixedRate(
+ submitTask, initialDelay + secondDelay, 1000 * 60 * 30, TimeUnit.MILLISECONDS);
+ }
+
+ private void submitData() {
+ final JsonObjectBuilder baseJsonBuilder = new JsonObjectBuilder();
+ appendPlatformDataConsumer.accept(baseJsonBuilder);
+ final JsonObjectBuilder serviceJsonBuilder = new JsonObjectBuilder();
+ appendServiceDataConsumer.accept(serviceJsonBuilder);
+ JsonObjectBuilder.JsonObject[] chartData =
+ customCharts.stream()
+ .map(customChart -> customChart.getRequestJsonObject(errorLogger, logErrors))
+ .filter(Objects::nonNull)
+ .toArray(JsonObjectBuilder.JsonObject[]::new);
+ serviceJsonBuilder.appendField("id", serviceId);
+ serviceJsonBuilder.appendField("customCharts", chartData);
+ baseJsonBuilder.appendField("service", serviceJsonBuilder.build());
+ baseJsonBuilder.appendField("serverUUID", serverUuid);
+ baseJsonBuilder.appendField("metricsVersion", METRICS_VERSION);
+ JsonObjectBuilder.JsonObject data = baseJsonBuilder.build();
+ scheduler.execute(
+ () -> {
+ try {
+ sendData(data);
+ } catch (Exception e) {
+ if (logErrors) {
+ errorLogger.accept("Could not submit bStats metrics data", e);
+ }
+ }
+ });
+ }
+
+ private void sendData(JsonObjectBuilder.JsonObject data) throws Exception {
+ if (logSentData) {
+ infoLogger.accept("Sent bStats metrics data: " + data.toString());
+ }
+ String url = String.format(REPORT_URL, platform);
+ HttpsURLConnection connection = (HttpsURLConnection) new URL(url).openConnection();
+ // Compress the data to save bandwidth
+ byte[] compressedData = compress(data.toString());
+ connection.setRequestMethod("POST");
+ connection.addRequestProperty("Accept", "application/json");
+ connection.addRequestProperty("Connection", "close");
+ connection.addRequestProperty("Content-Encoding", "gzip");
+ connection.addRequestProperty("Content-Length", String.valueOf(compressedData.length));
+ connection.setRequestProperty("Content-Type", "application/json");
+ connection.setRequestProperty("User-Agent", "Metrics-Service/1");
+ connection.setDoOutput(true);
+ try (DataOutputStream outputStream = new DataOutputStream(connection.getOutputStream())) {
+ outputStream.write(compressedData);
+ }
+ StringBuilder builder = new StringBuilder();
+ try (BufferedReader bufferedReader =
+ new BufferedReader(new InputStreamReader(connection.getInputStream()))) {
+ String line;
+ while ((line = bufferedReader.readLine()) != null) {
+ builder.append(line);
+ }
+ }
+ if (logResponseStatusText) {
+ infoLogger.accept("Sent data to bStats and received response: " + builder);
+ }
+ }
+
+ /** Checks that the class was properly relocated. */
+ private void checkRelocation() {
+ // You can use the property to disable the check in your test environment
+ if (System.getProperty("bstats.relocatecheck") == null
+ || !System.getProperty("bstats.relocatecheck").equals("false")) {
+ // Maven's Relocate is clever and changes strings, too. So we have to use this little
+ // "trick" ... :D
+ final String defaultPackage =
+ new String(new byte[] {'o', 'r', 'g', '.', 'b', 's', 't', 'a', 't', 's'});
+ final String examplePackage =
+ new String(new byte[] {'y', 'o', 'u', 'r', '.', 'p', 'a', 'c', 'k', 'a', 'g', 'e'});
+ // We want to make sure no one just copy & pastes the example and uses the wrong package
+ // names
+ if (MetricsBase.class.getPackage().getName().startsWith(defaultPackage)
+ || MetricsBase.class.getPackage().getName().startsWith(examplePackage)) {
+ throw new IllegalStateException("bStats Metrics class has not been relocated correctly!");
+ }
+ }
+ }
+
+ /**
+ * Gzips the given string.
+ *
+ * @param str The string to gzip.
+ * @return The gzipped string.
+ */
+ private static byte[] compress(final String str) throws IOException {
+ if (str == null) {
+ return null;
+ }
+ ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
+ try (GZIPOutputStream gzip = new GZIPOutputStream(outputStream)) {
+ gzip.write(str.getBytes(StandardCharsets.UTF_8));
+ }
+ return outputStream.toByteArray();
+ }
+ }
+
+}
diff --git a/plugin/src/main/java/net/codingarea/commons/bukkit/utils/bstats/chart/AdvancedBarChart.java b/plugin/src/main/java/net/codingarea/commons/bukkit/utils/bstats/chart/AdvancedBarChart.java
new file mode 100644
index 000000000..48063d475
--- /dev/null
+++ b/plugin/src/main/java/net/codingarea/commons/bukkit/utils/bstats/chart/AdvancedBarChart.java
@@ -0,0 +1,47 @@
+package net.codingarea.commons.bukkit.utils.bstats.chart;
+
+import net.codingarea.commons.bukkit.utils.bstats.JsonObjectBuilder;
+import net.codingarea.commons.bukkit.utils.bstats.JsonObjectBuilder.JsonObject;
+
+import java.util.Map;
+import java.util.concurrent.Callable;
+
+public class AdvancedBarChart extends CustomChart {
+
+ private final Callable> callable;
+
+ /**
+ * Class constructor.
+ *
+ * @param chartId The id of the chart.
+ * @param callable The callable which is used to request the chart data.
+ */
+ public AdvancedBarChart(String chartId, Callable> callable) {
+ super(chartId);
+ this.callable = callable;
+ }
+
+ @Override
+ protected JsonObject getChartData() throws Exception {
+ JsonObjectBuilder valuesBuilder = new JsonObjectBuilder();
+ Map map = callable.call();
+ if (map == null || map.isEmpty()) {
+ // Null = skip the chart
+ return null;
+ }
+ boolean allSkipped = true;
+ for (Map.Entry entry : map.entrySet()) {
+ if (entry.getValue().length == 0) {
+ // Skip this invalid
+ continue;
+ }
+ allSkipped = false;
+ valuesBuilder.appendField(entry.getKey(), entry.getValue());
+ }
+ if (allSkipped) {
+ // Null = skip the chart
+ return null;
+ }
+ return new JsonObjectBuilder().appendField("values", valuesBuilder.build()).build();
+ }
+}
diff --git a/plugin/src/main/java/net/codingarea/commons/bukkit/utils/bstats/chart/AdvancedPie.java b/plugin/src/main/java/net/codingarea/commons/bukkit/utils/bstats/chart/AdvancedPie.java
new file mode 100644
index 000000000..afdba71ee
--- /dev/null
+++ b/plugin/src/main/java/net/codingarea/commons/bukkit/utils/bstats/chart/AdvancedPie.java
@@ -0,0 +1,47 @@
+package net.codingarea.commons.bukkit.utils.bstats.chart;
+
+import net.codingarea.commons.bukkit.utils.bstats.JsonObjectBuilder;
+import net.codingarea.commons.bukkit.utils.bstats.JsonObjectBuilder.JsonObject;
+
+import java.util.Map;
+import java.util.concurrent.Callable;
+
+public class AdvancedPie extends CustomChart {
+
+ private final Callable> callable;
+
+ /**
+ * Class constructor.
+ *
+ * @param chartId The id of the chart.
+ * @param callable The callable which is used to request the chart data.
+ */
+ public AdvancedPie(String chartId, Callable> callable) {
+ super(chartId);
+ this.callable = callable;
+ }
+
+ @Override
+ protected JsonObject getChartData() throws Exception {
+ JsonObjectBuilder valuesBuilder = new JsonObjectBuilder();
+ Map map = callable.call();
+ if (map == null || map.isEmpty()) {
+ // Null = skip the chart
+ return null;
+ }
+ boolean allSkipped = true;
+ for (Map.Entry entry : map.entrySet()) {
+ if (entry.getValue() == 0) {
+ // Skip this invalid
+ continue;
+ }
+ allSkipped = false;
+ valuesBuilder.appendField(entry.getKey(), entry.getValue());
+ }
+ if (allSkipped) {
+ // Null = skip the chart
+ return null;
+ }
+ return new JsonObjectBuilder().appendField("values", valuesBuilder.build()).build();
+ }
+}
diff --git a/plugin/src/main/java/net/codingarea/commons/bukkit/utils/bstats/chart/CustomChart.java b/plugin/src/main/java/net/codingarea/commons/bukkit/utils/bstats/chart/CustomChart.java
new file mode 100644
index 000000000..3897be5c7
--- /dev/null
+++ b/plugin/src/main/java/net/codingarea/commons/bukkit/utils/bstats/chart/CustomChart.java
@@ -0,0 +1,40 @@
+package net.codingarea.commons.bukkit.utils.bstats.chart;
+
+import net.codingarea.commons.bukkit.utils.bstats.JsonObjectBuilder;
+import net.codingarea.commons.bukkit.utils.bstats.JsonObjectBuilder.JsonObject;
+
+import java.util.function.BiConsumer;
+
+public abstract class CustomChart {
+
+ private final String chartId;
+
+ protected CustomChart(String chartId) {
+ if (chartId == null) {
+ throw new IllegalArgumentException("chartId must not be null");
+ }
+ this.chartId = chartId;
+ }
+
+ public JsonObject getRequestJsonObject(
+ BiConsumer errorLogger, boolean logErrors) {
+ JsonObjectBuilder builder = new JsonObjectBuilder();
+ builder.appendField("chartId", chartId);
+ try {
+ JsonObject data = getChartData();
+ if (data == null) {
+ // If the data is null we don't send the chart.
+ return null;
+ }
+ builder.appendField("data", data);
+ } catch (Throwable t) {
+ if (logErrors) {
+ errorLogger.accept("Failed to get data for custom chart with id " + chartId, t);
+ }
+ return null;
+ }
+ return builder.build();
+ }
+
+ protected abstract JsonObject getChartData() throws Exception;
+}
diff --git a/plugin/src/main/java/net/codingarea/commons/bukkit/utils/bstats/chart/DrilldownPie.java b/plugin/src/main/java/net/codingarea/commons/bukkit/utils/bstats/chart/DrilldownPie.java
new file mode 100644
index 000000000..d0cb2ff19
--- /dev/null
+++ b/plugin/src/main/java/net/codingarea/commons/bukkit/utils/bstats/chart/DrilldownPie.java
@@ -0,0 +1,51 @@
+package net.codingarea.commons.bukkit.utils.bstats.chart;
+
+import net.codingarea.commons.bukkit.utils.bstats.JsonObjectBuilder;
+import net.codingarea.commons.bukkit.utils.bstats.JsonObjectBuilder.JsonObject;
+
+import java.util.Map;
+import java.util.concurrent.Callable;
+
+public class DrilldownPie extends CustomChart {
+
+ private final Callable>> callable;
+
+ /**
+ * Class constructor.
+ *
+ * @param chartId The id of the chart.
+ * @param callable The callable which is used to request the chart data.
+ */
+ public DrilldownPie(String chartId, Callable>> callable) {
+ super(chartId);
+ this.callable = callable;
+ }
+
+ @Override
+ public JsonObject getChartData() throws Exception {
+ JsonObjectBuilder valuesBuilder = new JsonObjectBuilder();
+ Map> map = callable.call();
+ if (map == null || map.isEmpty()) {
+ // Null = skip the chart
+ return null;
+ }
+ boolean reallyAllSkipped = true;
+ for (Map.Entry> entryValues : map.entrySet()) {
+ JsonObjectBuilder valueBuilder = new JsonObjectBuilder();
+ boolean allSkipped = true;
+ for (Map.Entry valueEntry : map.get(entryValues.getKey()).entrySet()) {
+ valueBuilder.appendField(valueEntry.getKey(), valueEntry.getValue());
+ allSkipped = false;
+ }
+ if (!allSkipped) {
+ reallyAllSkipped = false;
+ valuesBuilder.appendField(entryValues.getKey(), valueBuilder.build());
+ }
+ }
+ if (reallyAllSkipped) {
+ // Null = skip the chart
+ return null;
+ }
+ return new JsonObjectBuilder().appendField("values", valuesBuilder.build()).build();
+ }
+}
diff --git a/plugin/src/main/java/net/codingarea/commons/bukkit/utils/bstats/chart/MultiLineChart.java b/plugin/src/main/java/net/codingarea/commons/bukkit/utils/bstats/chart/MultiLineChart.java
new file mode 100644
index 000000000..0d62864af
--- /dev/null
+++ b/plugin/src/main/java/net/codingarea/commons/bukkit/utils/bstats/chart/MultiLineChart.java
@@ -0,0 +1,47 @@
+package net.codingarea.commons.bukkit.utils.bstats.chart;
+
+import net.codingarea.commons.bukkit.utils.bstats.JsonObjectBuilder;
+import net.codingarea.commons.bukkit.utils.bstats.JsonObjectBuilder.JsonObject;
+
+import java.util.Map;
+import java.util.concurrent.Callable;
+
+public class MultiLineChart extends CustomChart {
+
+ private final Callable> callable;
+
+ /**
+ * Class constructor.
+ *
+ * @param chartId The id of the chart.
+ * @param callable The callable which is used to request the chart data.
+ */
+ public MultiLineChart(String chartId, Callable> callable) {
+ super(chartId);
+ this.callable = callable;
+ }
+
+ @Override
+ protected JsonObject getChartData() throws Exception {
+ JsonObjectBuilder valuesBuilder = new JsonObjectBuilder();
+ Map map = callable.call();
+ if (map == null || map.isEmpty()) {
+ // Null = skip the chart
+ return null;
+ }
+ boolean allSkipped = true;
+ for (Map.Entry entry : map.entrySet()) {
+ if (entry.getValue() == 0) {
+ // Skip this invalid
+ continue;
+ }
+ allSkipped = false;
+ valuesBuilder.appendField(entry.getKey(), entry.getValue());
+ }
+ if (allSkipped) {
+ // Null = skip the chart
+ return null;
+ }
+ return new JsonObjectBuilder().appendField("values", valuesBuilder.build()).build();
+ }
+}
diff --git a/plugin/src/main/java/net/codingarea/commons/bukkit/utils/bstats/chart/SimpleBarChart.java b/plugin/src/main/java/net/codingarea/commons/bukkit/utils/bstats/chart/SimpleBarChart.java
new file mode 100644
index 000000000..aa7d49220
--- /dev/null
+++ b/plugin/src/main/java/net/codingarea/commons/bukkit/utils/bstats/chart/SimpleBarChart.java
@@ -0,0 +1,37 @@
+package net.codingarea.commons.bukkit.utils.bstats.chart;
+
+import net.codingarea.commons.bukkit.utils.bstats.JsonObjectBuilder;
+import net.codingarea.commons.bukkit.utils.bstats.JsonObjectBuilder.JsonObject;
+
+import java.util.Map;
+import java.util.concurrent.Callable;
+
+public class SimpleBarChart extends CustomChart {
+
+ private final Callable> callable;
+
+ /**
+ * Class constructor.
+ *
+ * @param chartId The id of the chart.
+ * @param callable The callable which is used to request the chart data.
+ */
+ public SimpleBarChart(String chartId, Callable> callable) {
+ super(chartId);
+ this.callable = callable;
+ }
+
+ @Override
+ protected JsonObject getChartData() throws Exception {
+ JsonObjectBuilder valuesBuilder = new JsonObjectBuilder();
+ Map map = callable.call();
+ if (map == null || map.isEmpty()) {
+ // Null = skip the chart
+ return null;
+ }
+ for (Map.Entry entry : map.entrySet()) {
+ valuesBuilder.appendField(entry.getKey(), new int[]{entry.getValue()});
+ }
+ return new JsonObjectBuilder().appendField("values", valuesBuilder.build()).build();
+ }
+}
diff --git a/plugin/src/main/java/net/codingarea/commons/bukkit/utils/bstats/chart/SimplePie.java b/plugin/src/main/java/net/codingarea/commons/bukkit/utils/bstats/chart/SimplePie.java
new file mode 100644
index 000000000..e42f4a5c7
--- /dev/null
+++ b/plugin/src/main/java/net/codingarea/commons/bukkit/utils/bstats/chart/SimplePie.java
@@ -0,0 +1,32 @@
+package net.codingarea.commons.bukkit.utils.bstats.chart;
+
+import net.codingarea.commons.bukkit.utils.bstats.JsonObjectBuilder;
+import net.codingarea.commons.bukkit.utils.bstats.JsonObjectBuilder.JsonObject;
+
+import java.util.concurrent.Callable;
+
+public class SimplePie extends CustomChart {
+
+ private final Callable callable;
+
+ /**
+ * Class constructor.
+ *
+ * @param chartId The id of the chart.
+ * @param callable The callable which is used to request the chart data.
+ */
+ public SimplePie(String chartId, Callable callable) {
+ super(chartId);
+ this.callable = callable;
+ }
+
+ @Override
+ protected JsonObject getChartData() throws Exception {
+ String value = callable.call();
+ if (value == null || value.isEmpty()) {
+ // Null = skip the chart
+ return null;
+ }
+ return new JsonObjectBuilder().appendField("value", value).build();
+ }
+}
diff --git a/plugin/src/main/java/net/codingarea/commons/bukkit/utils/bstats/chart/SingleLineChart.java b/plugin/src/main/java/net/codingarea/commons/bukkit/utils/bstats/chart/SingleLineChart.java
new file mode 100644
index 000000000..8e4d91259
--- /dev/null
+++ b/plugin/src/main/java/net/codingarea/commons/bukkit/utils/bstats/chart/SingleLineChart.java
@@ -0,0 +1,32 @@
+package net.codingarea.commons.bukkit.utils.bstats.chart;
+
+import net.codingarea.commons.bukkit.utils.bstats.JsonObjectBuilder;
+import net.codingarea.commons.bukkit.utils.bstats.JsonObjectBuilder.JsonObject;
+
+import java.util.concurrent.Callable;
+
+public class SingleLineChart extends CustomChart {
+
+ private final Callable callable;
+
+ /**
+ * Class constructor.
+ *
+ * @param chartId The id of the chart.
+ * @param callable The callable which is used to request the chart data.
+ */
+ public SingleLineChart(String chartId, Callable callable) {
+ super(chartId);
+ this.callable = callable;
+ }
+
+ @Override
+ protected JsonObject getChartData() throws Exception {
+ int value = callable.call();
+ if (value == 0) {
+ // Null = skip the chart
+ return null;
+ }
+ return new JsonObjectBuilder().appendField("value", value).build();
+ }
+}
diff --git a/plugin/src/main/java/net/codingarea/commons/bukkit/utils/item/BannerPattern.java b/plugin/src/main/java/net/codingarea/commons/bukkit/utils/item/BannerPattern.java
new file mode 100644
index 000000000..4901ae38d
--- /dev/null
+++ b/plugin/src/main/java/net/codingarea/commons/bukkit/utils/item/BannerPattern.java
@@ -0,0 +1,64 @@
+package net.codingarea.commons.bukkit.utils.item;
+
+import org.bukkit.block.banner.PatternType;
+
+import javax.annotation.Nonnull;
+
+public enum BannerPattern {
+
+ BASE_DEXTER_CANTON(PatternType.SQUARE_BOTTOM_LEFT),
+ BASE_SINISTER_CANTON(PatternType.SQUARE_BOTTOM_RIGHT),
+ CHIEF_DEXTER_CANTON(PatternType.SQUARE_TOP_LEFT),
+ CHIEF_SINISTER_CANTON(PatternType.SQUARE_TOP_RIGHT),
+ BASE(PatternType.STRIPE_BOTTOM),
+ CHIEF(PatternType.STRIPE_TOP),
+ PALE_DEXTER(PatternType.STRIPE_LEFT),
+ PALE_SINISTER(PatternType.STRIPE_RIGHT),
+ PALE(PatternType.STRIPE_CENTER),
+ FESS(PatternType.STRIPE_MIDDLE),
+ BEND(PatternType.STRIPE_DOWNRIGHT),
+ BEND_SINISTER(PatternType.STRIPE_DOWNLEFT),
+ PALY(PatternType.SMALL_STRIPES),
+ SALTIRE(PatternType.CROSS),
+ CROSS(PatternType.STRAIGHT_CROSS),
+ CHEVRON(PatternType.TRIANGLE_BOTTOM),
+ INVERTED_CHEVRON(PatternType.TRIANGLE_TOP),
+ BASE_INDENTED(PatternType.TRIANGLES_BOTTOM),
+ CHIEF_INDENTED(PatternType.TRIANGLES_TOP),
+ PER_BEND_SINISTER(PatternType.DIAGONAL_LEFT),
+ PER_BEND_SINISTER_INVERTED(PatternType.DIAGONAL_RIGHT),
+ PER_BEND_INVERTED(PatternType.DIAGONAL_UP_LEFT),
+ PER_BEND(PatternType.DIAGONAL_UP_RIGHT),
+ ROUNDEL(PatternType.CIRCLE),
+ LOZENGE(PatternType.STRIPE_MIDDLE),
+ PER_PALE(PatternType.HALF_VERTICAL),
+ PER_FESS(PatternType.HALF_HORIZONTAL),
+ PER_PALE_INVERTED(PatternType.HALF_VERTICAL_RIGHT),
+ PER_FESS_INVERTED(PatternType.HALF_HORIZONTAL_BOTTOM),
+ BORDURE(PatternType.BORDER),
+ BORDURE_INDENTED(PatternType.CURLY_BORDER),
+ GRADIENT(PatternType.GRADIENT),
+ BASE_GRADIENT(PatternType.GRADIENT_UP),
+ FIELD_MASONED(PatternType.BRICKS),
+ CREEPER_CHARGE(PatternType.CREEPER),
+ SKULL_CHARGE(PatternType.SKULL),
+ FLOWER_CHARGE(PatternType.FLOWER),
+ MOJANG(PatternType.MOJANG);
+
+ private final PatternType patternType;
+
+ BannerPattern(@Nonnull PatternType patternType) {
+ this.patternType = patternType;
+ }
+
+ @Nonnull
+ public PatternType getPatternType() {
+ return patternType;
+ }
+
+ @Nonnull
+ public String getIdentifier() {
+ return patternType.getKeyOrThrow().getKey();
+ }
+
+}
diff --git a/plugin/src/main/java/net/codingarea/commons/bukkit/utils/item/ItemBuilder.java b/plugin/src/main/java/net/codingarea/commons/bukkit/utils/item/ItemBuilder.java
new file mode 100644
index 000000000..339bbaba2
--- /dev/null
+++ b/plugin/src/main/java/net/codingarea/commons/bukkit/utils/item/ItemBuilder.java
@@ -0,0 +1,424 @@
+package net.codingarea.commons.bukkit.utils.item;
+
+import org.bukkit.Color;
+import org.bukkit.DyeColor;
+import org.bukkit.Material;
+import org.bukkit.block.banner.Pattern;
+import org.bukkit.block.banner.PatternType;
+import org.bukkit.enchantments.Enchantment;
+import org.bukkit.inventory.ItemFlag;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.inventory.meta.*;
+import org.bukkit.potion.PotionEffect;
+
+import javax.annotation.CheckReturnValue;
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.List;
+
+public class ItemBuilder {
+
+ public static final ItemStack FILL_ITEM = new ItemBuilder(Material.GRAY_STAINED_GLASS_PANE).setName("§0").build(),
+ FILL_ITEM_2 = new ItemBuilder(Material.BLACK_STAINED_GLASS_PANE).setName("§0").build(),
+ BLOCKED_ITEM = new ItemBuilder(Material.BARRIER, "§cBlocked").build(),
+ AIR = new ItemStack(Material.AIR);
+
+ protected ItemStack item;
+ protected ItemMeta meta;
+
+ public ItemBuilder(@Nonnull ItemStack item) {
+ this(item, item.getItemMeta());
+ }
+
+ public ItemBuilder(@Nonnull ItemStack item, @Nullable ItemMeta meta) {
+ this.item = item;
+ this.meta = meta;
+ }
+
+ public ItemBuilder(@Nonnull Material material) {
+ this(new ItemStack(material));
+ }
+
+ public ItemBuilder(@Nonnull Material material, @Nonnull String name) {
+ this(material);
+ setName(name);
+ }
+
+ public ItemBuilder(@Nonnull Material material, @Nonnull String name, @Nonnull String... lore) {
+ this(material);
+ setName(name);
+ setLore(lore);
+ }
+
+ public ItemBuilder(@Nonnull Material material, @Nonnull String name, int amount) {
+ this(material);
+ setName(name);
+ setAmount(amount);
+ }
+
+ @Nonnull
+ public ItemMeta getMeta() {
+ return getCastedMeta();
+ }
+
+ @Nonnull
+ @SuppressWarnings("unchecked")
+ public final M getCastedMeta() {
+ return (M) (meta == null ? meta = item.getItemMeta() : meta);
+ }
+
+ @Nonnull
+ public ItemBuilder setLore(@Nonnull List lore) {
+ getMeta().setLore(lore);
+ return this;
+ }
+
+ @Nonnull
+ public ItemBuilder setLore(@Nonnull String... lore) {
+ return setLore(Arrays.asList(lore));
+ }
+
+ @Nonnull
+ public ItemBuilder appendLore(@Nonnull String... lore) {
+ return appendLore(Arrays.asList(lore));
+ }
+
+ @Nonnull
+ public ItemBuilder appendLore(@Nonnull Collection lore) {
+ List newLore = getMeta().getLore();
+ if (newLore == null) newLore = new ArrayList<>();
+ newLore.addAll(lore);
+ setLore(newLore);
+ return this;
+ }
+
+ @Nonnull
+ public ItemBuilder lore(@Nonnull String... lore) {
+ return setLore(lore);
+ }
+
+ @Nonnull
+ public ItemBuilder setName(@Nullable String name) {
+ getMeta().setDisplayName(name);
+ return this;
+ }
+
+ @Nonnull
+ public ItemBuilder setName(@Nullable Object name) {
+ return setName(name == null ? null : name.toString());
+ }
+
+ @Nonnull
+ public ItemBuilder setName(@Nonnull String... content) {
+ if (content.length > 0) setName(content[0]);
+ if (content.length > 1) setLore(Arrays.copyOfRange(content, 1, content.length));
+ return this;
+ }
+
+ @Nonnull
+ public ItemBuilder appendName(@Nullable Object sequence) {
+ String name = getMeta().getDisplayName();
+ return setName(name + sequence);
+ }
+
+ @Nonnull
+ public ItemBuilder name(@Nullable Object name) {
+ return setName(name);
+ }
+
+ @Nonnull
+ public ItemBuilder name(@Nonnull String... content) {
+ return setName(content);
+ }
+
+ @Nonnull
+ public ItemBuilder addEnchantment(@Nonnull Enchantment enchantment, int level) {
+ getMeta().addEnchant(enchantment, level, true);
+ return this;
+ }
+
+ @Nonnull
+ public ItemBuilder enchant(@Nonnull Enchantment enchantment, int level) {
+ return addEnchantment(enchantment, level);
+ }
+
+ @Nonnull
+ public ItemBuilder addFlag(@Nonnull ItemFlag... flags) {
+ getMeta().addItemFlags(flags);
+ return this;
+ }
+
+ @Nonnull
+ public ItemBuilder flag(@Nonnull ItemFlag... flags) {
+ return addFlag(flags);
+ }
+
+ @Nonnull
+ public ItemBuilder removeFlag(@Nonnull ItemFlag... flags) {
+ getMeta().removeItemFlags(flags);
+ return this;
+ }
+
+ @Nonnull
+ public ItemBuilder hideAttributes() {
+ return addFlag(ItemFlag.values());
+ }
+
+ @Nonnull
+ public ItemBuilder showAttributes() {
+ return removeFlag(ItemFlag.values());
+ }
+
+ @Nonnull
+ public ItemBuilder setUnbreakable(boolean unbreakable) {
+ getMeta().setUnbreakable(unbreakable);
+ return this;
+ }
+
+ @Nonnull
+ public ItemBuilder unbreakable() {
+ return setUnbreakable(true);
+ }
+
+ @Nonnull
+ public ItemBuilder breakable() {
+ return setUnbreakable(false);
+ }
+
+ @Nonnull
+ public ItemBuilder setAmount(int amount) {
+ item.setAmount(Math.min(Math.max(amount, 0), 64));
+ return this;
+ }
+
+ @Nonnull
+ public ItemBuilder amount(int amount) {
+ return setAmount(amount);
+ }
+
+ @Nonnull
+ public ItemBuilder setDamage(int damage) {
+ this.getCastedMeta().setDamage(damage);
+ return this;
+ }
+
+ @Nonnull
+ public ItemBuilder damage(int damage) {
+ return setDamage(damage);
+ }
+
+ @Nonnull
+ public ItemBuilder setType(@Nonnull Material material) {
+ item.setType(material);
+ meta = item.getItemMeta();
+ return this;
+ }
+
+ @Nonnull
+ public String getName() {
+ return getMeta().getDisplayName();
+ }
+
+ @Nonnull
+ public List getLore() {
+ List lore = getMeta().getLore();
+ return lore == null ? new ArrayList<>() : lore;
+ }
+
+ @Nonnull
+ public Material getType() {
+ return item.getType();
+ }
+
+ public int getAmount() {
+ return item.getAmount();
+ }
+
+ public int getDamage() {
+ return this.getCastedMeta().getDamage();
+ }
+
+ @Nonnull
+ public ItemStack build() {
+ item.setItemMeta(getMeta()); // Call to getter to prevent null value
+ return item;
+ }
+
+ @Nonnull
+ public ItemStack toItem() {
+ return build();
+ }
+
+ @Override
+ public ItemBuilder clone() {
+ return new ItemBuilder(item.clone(), getMeta().clone());
+ }
+
+ public static class BannerBuilder extends ItemBuilder {
+
+ public BannerBuilder(@Nonnull Material material) {
+ super(material);
+ }
+
+ public BannerBuilder(@Nonnull Material material, @Nonnull String name) {
+ super(material, name);
+ }
+
+ public BannerBuilder(@Nonnull Material material, @Nonnull String name, @Nonnull String... lore) {
+ super(material, name, lore);
+ }
+
+ public BannerBuilder(@Nonnull Material material, @Nonnull String name, int amount) {
+ super(material, name, amount);
+ }
+
+ public BannerBuilder(@Nonnull ItemStack item) {
+ super(item);
+ }
+
+ @Nonnull
+ public BannerBuilder addPattern(@Nonnull BannerPattern pattern, @Nonnull DyeColor color) {
+ return addPattern(pattern.getPatternType(), color);
+ }
+
+ @Nonnull
+ public BannerBuilder addPattern(@Nonnull PatternType pattern, @Nonnull DyeColor color) {
+ getMeta().addPattern(new Pattern(color, pattern));
+ return this;
+ }
+
+ @Nonnull
+ @Override
+ public BannerMeta getMeta() {
+ return getCastedMeta();
+ }
+
+ }
+
+ public static class SkullBuilder extends ItemBuilder {
+
+ public SkullBuilder() {
+ super(Material.PLAYER_HEAD);
+ }
+
+ public SkullBuilder(@Nonnull String owner) {
+ super(Material.PLAYER_HEAD);
+ setOwner(owner);
+ }
+
+ public SkullBuilder(@Nonnull String owner, @Nonnull String name, @Nonnull String... lore) {
+ super(Material.PLAYER_HEAD, name, lore);
+ setOwner(owner);
+ }
+
+ public SkullBuilder setOwner(@Nonnull String owner) {
+ getMeta().setOwner(owner);
+ return this;
+ }
+
+ @Nonnull
+ @Override
+ public SkullMeta getMeta() {
+ return getCastedMeta();
+ }
+
+ }
+
+ public static class PotionBuilder extends ItemBuilder {
+
+ @Nonnull
+ @CheckReturnValue
+ public static ItemBuilder createWaterBottle() {
+ return new PotionBuilder(Material.POTION).setColor(Color.BLUE).hideAttributes();
+ }
+
+ public PotionBuilder(@Nonnull Material material) {
+ super(material);
+ }
+
+ public PotionBuilder(@Nonnull Material material, @Nonnull String name) {
+ super(material, name);
+ }
+
+ public PotionBuilder(@Nonnull Material material, @Nonnull String name, @Nonnull String... lore) {
+ super(material, name, lore);
+ }
+
+ public PotionBuilder(@Nonnull Material material, @Nonnull String name, int amount) {
+ super(material, name, amount);
+ }
+
+ public PotionBuilder(@Nonnull ItemStack item) {
+ super(item);
+ }
+
+ @Nonnull
+ public PotionBuilder addEffect(@Nonnull PotionEffect effect) {
+ getMeta().addCustomEffect(effect, true);
+ return this;
+ }
+
+ @Nonnull
+ public PotionBuilder setColor(@Nonnull Color color) {
+ getMeta().setColor(color);
+ return this;
+ }
+
+ @Nonnull
+ public PotionBuilder color(@Nonnull Color color) {
+ return setColor(color);
+ }
+
+ @Nonnull
+ @Override
+ public PotionMeta getMeta() {
+ return getCastedMeta();
+ }
+
+ }
+
+ public static class LeatherArmorBuilder extends ItemBuilder {
+
+ public LeatherArmorBuilder(@Nonnull Material material) {
+ super(material);
+ }
+
+ public LeatherArmorBuilder(@Nonnull Material material, @Nonnull String name) {
+ super(material, name);
+ }
+
+ public LeatherArmorBuilder(@Nonnull Material material, @Nonnull String name, @Nonnull String... lore) {
+ super(material, name, lore);
+ }
+
+ public LeatherArmorBuilder(@Nonnull Material material, @Nonnull String name, int amount) {
+ super(material, name, amount);
+ }
+
+ public LeatherArmorBuilder(@Nonnull ItemStack item) {
+ super(item);
+ }
+
+ @Nonnull
+ public LeatherArmorBuilder setColor(@Nonnull Color color) {
+ getMeta().setColor(color);
+ return this;
+ }
+
+ @Nonnull
+ public LeatherArmorBuilder color(@Nonnull Color color) {
+ return setColor(color);
+ }
+
+ @Nonnull
+ @Override
+ public LeatherArmorMeta getMeta() {
+ return getCastedMeta();
+ }
+
+ }
+
+}
diff --git a/plugin/src/main/java/net/codingarea/commons/bukkit/utils/item/ItemUtils.java b/plugin/src/main/java/net/codingarea/commons/bukkit/utils/item/ItemUtils.java
new file mode 100644
index 000000000..e967429a8
--- /dev/null
+++ b/plugin/src/main/java/net/codingarea/commons/bukkit/utils/item/ItemUtils.java
@@ -0,0 +1,117 @@
+package net.codingarea.commons.bukkit.utils.item;
+
+import net.codingarea.commons.bukkit.utils.misc.BukkitReflectionUtils;
+import net.codingarea.commons.bukkit.utils.misc.MinecraftVersion;
+import org.bukkit.Material;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.inventory.meta.Damageable;
+import org.bukkit.inventory.meta.ItemMeta;
+
+import javax.annotation.Nonnull;
+
+public class ItemUtils {
+
+ @Nonnull
+ public static Material convertFoodToCookedFood(@Nonnull Material material) {
+ try {
+ return Material.valueOf("COOKED_" + material.name());
+ } catch (Exception ex) {
+ return material; // No cooked material is available
+ }
+ }
+
+ public static boolean isObtainableInSurvival(@Nonnull Material material) {
+ String name = material.name();
+ if (BukkitReflectionUtils.isAir(material)) return false;
+ if (name.endsWith("_SPAWN_EGG")) return false;
+ if (name.startsWith("INFESTED_")) return false;
+ if (name.startsWith("LEGACY_")) return false; // Legacy items should not be obtainable
+ switch (name) { // Use name instead of enum its self, to prevent NoSuchFieldErrors in older versions where this specific enum does not exist
+ case "CHAIN_COMMAND_BLOCK":
+ case "REPEATING_COMMAND_BLOCK":
+ case "COMMAND_BLOCK":
+ case "COMMAND_BLOCK_MINECART":
+ case "JIGSAW":
+ case "STRUCTURE_BLOCK":
+ case "STRUCTURE_VOID":
+ case "BARRIER":
+ case "BEDROCK":
+ case "KNOWLEDGE_BOOK":
+ case "DEBUG_STICK":
+ case "END_PORTAL_FRAME":
+ case "END_PORTAL":
+ case "NETHER_PORTAL":
+ case "END_GATEWAY":
+ case "LAVA":
+ case "WATER":
+ case "LARGE_FERN":
+ case "TALL_GRASS":
+ case "TALL_SEAGRASS":
+ case "PATH_BLOCK":
+ case "CHORUS_PLANT":
+ case "PETRIFIED_OAK_SLAB":
+ case "FARMLAND":
+ case "PLAYER_HEAD":
+ case "GLOBE_BANNER_PATTERN":
+ case "SPAWNER":
+ case "AMETHYST_CLUSTER":
+ case "BUDDING_AMETHYST":
+ case "POWDER_SNOW":
+ case "LIGHT":
+ case "BUNDLE":
+ case "REINFORCED_DEEPSLATE":
+ case "FROGSPAWN":
+ return false;
+ }
+
+ if (MinecraftVersion.current().isOlderThan(MinecraftVersion.V1_19)) {
+ return !name.equals("SCULK_SENSOR");
+ }
+
+ return true;
+ }
+
+ public static boolean blockIsAvailableInSurvival(@Nonnull Material material) {
+ if (!material.isBlock()) return false;
+ String name = material.name();
+ if (BukkitReflectionUtils.isAir(material)) return false;
+ if (name.startsWith("LEGACY_")) return false; // Legacy items should not be obtainable
+ switch (name) { // Use name instead of enum its self, to prevent NoSuchFieldErrors in older versions where this specific enum does not exist
+ case "CHAIN_COMMAND_BLOCK":
+ case "REPEATING_COMMAND_BLOCK":
+ case "COMMAND_BLOCK":
+ case "COMMAND_BLOCK_MINECART":
+ case "JIGSAW":
+ case "STRUCTURE_BLOCK":
+ case "STRUCTURE_VOID":
+ case "BARRIER":
+ case "KNOWLEDGE_BOOK":
+ case "DEBUG_STICK":
+ case "END_PORTAL":
+ case "NETHER_PORTAL":
+ case "END_GATEWAY":
+ case "PETRIFIED_OAK_SLAB":
+ case "PLAYER_HEAD":
+ case "GLOBE_BANNER_PATTERN":
+ case "LIGHT":
+ case "BUNDLE":
+ return false;
+ }
+
+ return true;
+ }
+
+ public static void damageItem(@Nonnull ItemStack item) {
+ damageItem(item, 1);
+ }
+
+ public static void damageItem(@Nonnull ItemStack item, int amount) {
+ ItemMeta meta = item.getItemMeta();
+ if (meta == null) return;
+ if (!(meta instanceof Damageable)) return;
+ Damageable damageable = (Damageable) meta;
+ damageable.setDamage(damageable.getDamage() + amount);
+ item.setItemMeta(meta);
+ }
+
+}
diff --git a/plugin/src/main/java/net/codingarea/commons/bukkit/utils/logging/Logger.java b/plugin/src/main/java/net/codingarea/commons/bukkit/utils/logging/Logger.java
new file mode 100644
index 000000000..ac6f766f5
--- /dev/null
+++ b/plugin/src/main/java/net/codingarea/commons/bukkit/utils/logging/Logger.java
@@ -0,0 +1,39 @@
+package net.codingarea.commons.bukkit.utils.logging;
+
+import net.codingarea.commons.bukkit.core.BukkitModule;
+import net.codingarea.commons.common.logging.ILogger;
+import net.codingarea.commons.common.misc.ReflectionUtils;
+
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+
+public final class Logger {
+
+ private Logger() {}
+
+ @Nonnull
+ public static ILogger getInstance() {
+ return BukkitModule.getProvidingModule(ReflectionUtils.getCaller()).getILogger();
+ }
+
+ public static void error(@Nullable Object message, @Nonnull Object... args) {
+ getInstance().error(message, args);
+ }
+
+ public static void warn(@Nullable Object message, @Nonnull Object... args) {
+ getInstance().warn(message, args);
+ }
+
+ public static void info(@Nullable Object message, @Nonnull Object... args) {
+ getInstance().info(message, args);
+ }
+
+ public static void debug(@Nullable Object message, @Nonnull Object... args) {
+ getInstance().debug(message, args);
+ }
+
+ public static void trace(@Nullable Object message, @Nonnull Object... args) {
+ getInstance().trace(message, args);
+ }
+
+}
diff --git a/plugin/src/main/java/net/codingarea/commons/bukkit/utils/menu/MenuClickInfo.java b/plugin/src/main/java/net/codingarea/commons/bukkit/utils/menu/MenuClickInfo.java
new file mode 100644
index 000000000..5753ad174
--- /dev/null
+++ b/plugin/src/main/java/net/codingarea/commons/bukkit/utils/menu/MenuClickInfo.java
@@ -0,0 +1,75 @@
+package net.codingarea.commons.bukkit.utils.menu;
+
+import org.bukkit.Material;
+import org.bukkit.entity.Player;
+import org.bukkit.inventory.Inventory;
+import org.bukkit.inventory.ItemStack;
+
+import javax.annotation.Nonnegative;
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+
+public class MenuClickInfo {
+
+ protected final Player player;
+ protected final Inventory inventory;
+ protected final boolean shiftClick;
+ protected final boolean rightClick;
+ protected final int slot;
+
+ public MenuClickInfo(@Nonnull Player player, @Nonnull Inventory inventory, boolean shiftClick, boolean rightClick, @Nonnegative int slot) {
+ this.player = player;
+ this.inventory = inventory;
+ this.shiftClick = shiftClick;
+ this.rightClick = rightClick;
+ this.slot = slot;
+ }
+
+ @Nonnull
+ public Player getPlayer() {
+ return player;
+ }
+
+ @Nonnull
+ public Inventory getInventory() {
+ return inventory;
+ }
+
+ public boolean isRightClick() {
+ return rightClick;
+ }
+
+ public boolean isLeftClick() {
+ return !rightClick;
+ }
+
+ public boolean isShiftClick() {
+ return shiftClick;
+ }
+
+ public int getSlot() {
+ return slot;
+ }
+
+ @Nullable
+ public ItemStack getClickedItem() {
+ return inventory.getItem(slot);
+ }
+
+ @Nonnull
+ public Material getClickedMaterial() {
+ return getClickedItem() == null ? Material.AIR : getClickedItem().getType();
+ }
+
+ @Override
+ public String toString() {
+ return "MenuClickInfo{" +
+ "player=" + player +
+ ", inventory=" + inventory +
+ ", shiftClick=" + shiftClick +
+ ", rightClick=" + rightClick +
+ ", slot=" + slot +
+ '}';
+ }
+
+}
diff --git a/plugin/src/main/java/net/codingarea/commons/bukkit/utils/menu/MenuPosition.java b/plugin/src/main/java/net/codingarea/commons/bukkit/utils/menu/MenuPosition.java
new file mode 100644
index 000000000..527cc844f
--- /dev/null
+++ b/plugin/src/main/java/net/codingarea/commons/bukkit/utils/menu/MenuPosition.java
@@ -0,0 +1,44 @@
+package net.codingarea.commons.bukkit.utils.menu;
+
+import net.codingarea.commons.bukkit.utils.menu.positions.EmptyMenuPosition;
+import org.bukkit.entity.Player;
+import org.bukkit.inventory.InventoryHolder;
+
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+
+@FunctionalInterface
+public interface MenuPosition {
+
+ final class Holder {
+
+ private Holder() {}
+
+ private static final Map positions = new ConcurrentHashMap<>();
+
+ }
+
+ InventoryHolder HOLDER = new MenuPositionHolder();
+
+ static void set(@Nonnull Player player, @Nullable MenuPosition position) {
+ Holder.positions.put(player, position);
+ }
+
+ static void remove(@Nonnull Player player) {
+ Holder.positions.remove(player);
+ }
+
+ @Nullable
+ static MenuPosition get(@Nonnull Player player) {
+ return Holder.positions.get(player);
+ }
+
+ static void setEmpty(@Nonnull Player player) {
+ set(player, new EmptyMenuPosition());
+ }
+
+ void handleClick(@Nonnull MenuClickInfo info);
+
+}
diff --git a/plugin/src/main/java/net/codingarea/commons/bukkit/utils/menu/MenuPositionHolder.java b/plugin/src/main/java/net/codingarea/commons/bukkit/utils/menu/MenuPositionHolder.java
new file mode 100644
index 000000000..669b1367f
--- /dev/null
+++ b/plugin/src/main/java/net/codingarea/commons/bukkit/utils/menu/MenuPositionHolder.java
@@ -0,0 +1,16 @@
+package net.codingarea.commons.bukkit.utils.menu;
+
+import org.bukkit.inventory.Inventory;
+import org.bukkit.inventory.InventoryHolder;
+
+import javax.annotation.Nonnull;
+
+class MenuPositionHolder implements InventoryHolder {
+
+ @Nonnull
+ @Override
+ public Inventory getInventory() {
+ return null;
+ }
+
+}
diff --git a/plugin/src/main/java/net/codingarea/commons/bukkit/utils/menu/MenuPositionListener.java b/plugin/src/main/java/net/codingarea/commons/bukkit/utils/menu/MenuPositionListener.java
new file mode 100644
index 000000000..8addddaca
--- /dev/null
+++ b/plugin/src/main/java/net/codingarea/commons/bukkit/utils/menu/MenuPositionListener.java
@@ -0,0 +1,47 @@
+package net.codingarea.commons.bukkit.utils.menu;
+
+import net.codingarea.commons.bukkit.utils.misc.CompatibilityUtils;
+import org.bukkit.entity.HumanEntity;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.Listener;
+import org.bukkit.event.inventory.InventoryClickEvent;
+import org.bukkit.inventory.Inventory;
+
+import javax.annotation.Nonnull;
+
+public final class MenuPositionListener implements Listener {
+
+ @EventHandler(priority = EventPriority.LOW)
+ public void onClick(@Nonnull InventoryClickEvent event) {
+
+ HumanEntity human = event.getWhoClicked();
+ if (!(human instanceof Player)) return;
+ Player player = (Player) human;
+
+ Inventory inventory = event.getClickedInventory();
+ if (inventory == null) return;
+
+ if (inventory == CompatibilityUtils.getTopInventory(event)) {
+
+ if (inventory.getHolder() != MenuPosition.HOLDER) return; // No menu inventory
+
+ MenuPosition position = MenuPosition.get(player);
+ if (position == null) return; // Currently in no menu
+
+ event.setCancelled(true);
+ position.handleClick(new MenuClickInfo(player, inventory, event.isShiftClick(), event.isRightClick(), event.getSlot()));
+
+ } else if (event.isShiftClick()) { // Player inventory was clicked
+
+ Inventory topInventory = event.getInventory();
+ if (topInventory.getHolder() != MenuPosition.HOLDER) return; // No menu inventory
+
+ event.setCancelled(true);
+
+ }
+
+ }
+
+}
diff --git a/plugin/src/main/java/net/codingarea/commons/bukkit/utils/menu/positions/EmptyMenuPosition.java b/plugin/src/main/java/net/codingarea/commons/bukkit/utils/menu/positions/EmptyMenuPosition.java
new file mode 100644
index 000000000..dfe653abf
--- /dev/null
+++ b/plugin/src/main/java/net/codingarea/commons/bukkit/utils/menu/positions/EmptyMenuPosition.java
@@ -0,0 +1,16 @@
+package net.codingarea.commons.bukkit.utils.menu.positions;
+
+import net.codingarea.commons.bukkit.utils.animation.SoundSample;
+import net.codingarea.commons.bukkit.utils.menu.MenuClickInfo;
+import net.codingarea.commons.bukkit.utils.menu.MenuPosition;
+
+import javax.annotation.Nonnull;
+
+public class EmptyMenuPosition implements MenuPosition {
+
+ @Override
+ public void handleClick(@Nonnull MenuClickInfo info) {
+ SoundSample.CLICK.play(info.getPlayer());
+ }
+
+}
diff --git a/plugin/src/main/java/net/codingarea/commons/bukkit/utils/menu/positions/SlottedMenuPosition.java b/plugin/src/main/java/net/codingarea/commons/bukkit/utils/menu/positions/SlottedMenuPosition.java
new file mode 100644
index 000000000..8ea854148
--- /dev/null
+++ b/plugin/src/main/java/net/codingarea/commons/bukkit/utils/menu/positions/SlottedMenuPosition.java
@@ -0,0 +1,50 @@
+package net.codingarea.commons.bukkit.utils.menu.positions;
+
+import net.codingarea.commons.bukkit.utils.animation.SoundSample;
+import net.codingarea.commons.bukkit.utils.menu.MenuClickInfo;
+import net.codingarea.commons.bukkit.utils.menu.MenuPosition;
+import org.bukkit.entity.Player;
+
+import javax.annotation.Nonnull;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.function.Consumer;
+
+public class SlottedMenuPosition implements MenuPosition {
+
+ protected final Map> actions = new HashMap<>();
+ protected boolean emptySound = true;
+
+ @Override
+ public void handleClick(@Nonnull MenuClickInfo info) {
+ Consumer action = actions.get(info.getSlot());
+ if (action == null) {
+ if (emptySound) SoundSample.CLICK.play(info.getPlayer());
+ return;
+ }
+
+ action.accept(info);
+ }
+
+ @Nonnull
+ public SlottedMenuPosition setAction(int slot, @Nonnull Consumer action) {
+ actions.put(slot, action);
+ return this;
+ }
+
+ @Nonnull
+ public SlottedMenuPosition setPlayerAction(int slot, @Nonnull Consumer action) {
+ return setAction(slot, info -> action.accept(info.getPlayer()));
+ }
+
+ @Nonnull
+ public SlottedMenuPosition setAction(int slot, @Nonnull Runnable action) {
+ return setAction(slot, info -> action.run());
+ }
+
+ public SlottedMenuPosition setEmptySound(boolean playSound) {
+ this.emptySound = playSound;
+ return this;
+ }
+
+}
diff --git a/plugin/src/main/java/net/codingarea/commons/bukkit/utils/misc/BukkitReflectionUtils.java b/plugin/src/main/java/net/codingarea/commons/bukkit/utils/misc/BukkitReflectionUtils.java
new file mode 100644
index 000000000..36284f5e3
--- /dev/null
+++ b/plugin/src/main/java/net/codingarea/commons/bukkit/utils/misc/BukkitReflectionUtils.java
@@ -0,0 +1,170 @@
+package net.codingarea.commons.bukkit.utils.misc;
+
+import com.google.common.base.Preconditions;
+import net.codingarea.commons.common.logging.ILogger;
+import org.bukkit.Material;
+import org.bukkit.NamespacedKey;
+import org.bukkit.World;
+import org.bukkit.entity.Entity;
+import org.bukkit.entity.Player;
+import org.bukkit.plugin.Plugin;
+
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+import java.lang.reflect.Method;
+import java.util.regex.Pattern;
+
+/**
+ * This class gives access to
+ * - api functions which are not directly implemented in some versions of bukkit or spigot
+ * - some basic nms functionality.
+ */
+public final class BukkitReflectionUtils {
+
+ private static final ILogger logger = ILogger.forThisClass();
+
+ private BukkitReflectionUtils() {
+ }
+
+ public static double getAbsorptionAmount(@Nonnull Player player) {
+ Class classOfPlayer = player.getClass();
+
+ try {
+ return player.getAbsorptionAmount();
+ } catch (Throwable ignored) {
+ }
+
+ try {
+ Method getHandleMethod = classOfPlayer.getMethod("getHandle");
+ getHandleMethod.setAccessible(true);
+
+ Object handle = getHandleMethod.invoke(player);
+ Class classOfHandle = handle.getClass();
+
+ Method getAbsorptionMethod = classOfHandle.getMethod("getAbsorptionHearts");
+ getAbsorptionMethod.setAccessible(true);
+ return (double) (float) getAbsorptionMethod.invoke(handle);
+ } catch (Throwable ignored) {
+ }
+
+ logger.warn("Could not get absorption amount for player of class {}", classOfPlayer.getName());
+ return 0;
+ }
+
+ public static boolean isAir(@Nonnull Material material) {
+ try {
+ return material.isAir();
+ } catch (Throwable ignored) {
+ }
+
+ switch (material.name()) {
+ case "AIR":
+ case "VOID_AIR":
+ case "CAVE_AIR":
+ case "LEGACY_AIR":
+ return true;
+ default:
+ return false;
+ }
+ }
+
+ public static int getMinHeight(@Nonnull World world) {
+ try {
+ return world.getMinHeight();
+ } catch (Throwable ignored) {
+ }
+
+ return 0;
+ }
+
+ /**
+ * @return if the entity is in water, {@code false} otherwise or if not implemented
+ * @deprecated not implemented in all forks of bukkit
+ */
+ @Deprecated
+ public static boolean isInWater(@Nonnull Entity entity) {
+ try {
+ return entity.isInWater();
+ } catch (Throwable ignored) {
+ }
+
+ return false;
+ }
+
+ private static final Pattern VALID_KEY = Pattern.compile("[a-z0-9/._-]+");
+
+ /**
+ * Get a NamespacedKey from the supplied string.
+ *
+ * The default namespace will be Minecraft's (i.e.
+ * {@link NamespacedKey#minecraft(String)}).
+ *
+ * @param key the key to convert to a NamespacedKey
+ * @return the created NamespacedKey. null if invalid
+ * @see #fromString(String, Plugin)
+ */
+ @Nullable
+ public static NamespacedKey fromString(@Nonnull String key) {
+ return fromString(key, null);
+ }
+
+ /**
+ * Does not exists in versions prior to 1.14
+ *
+ * Get a NamespacedKey from the supplied string with a default namespace if
+ * a namespace is not defined. This is a utility method meant to fetch a
+ * NamespacedKey from user input. Please note that casing does matter and
+ * any instance of uppercase characters will be considered invalid. The
+ * input contract is as follows:
+ *
+ * fromString("foo", plugin) -{@literal >} "plugin:foo"
+ * fromString("foo:bar", plugin) -{@literal >} "foo:bar"
+ * fromString(":foo", null) -{@literal >} "minecraft:foo"
+ * fromString("foo", null) -{@literal >} "minecraft:foo"
+ * fromString("Foo", plugin) -{@literal >} null
+ * fromString(":Foo", plugin) -{@literal >} null
+ * fromString("foo:bar:bazz", plugin) -{@literal >} null
+ * fromString("", plugin) -{@literal >} null
+ *
+ *
+ * @param string the string to convert to a NamespacedKey
+ * @param defaultNamespace the default namespace to use if none was
+ * supplied. If null, the {@code minecraft} namespace
+ * ({@link NamespacedKey#minecraft(String)}) will be used
+ * @return the created NamespacedKey. null if invalid key
+ * @see #fromString(String)
+ */
+ @Nullable
+ public static NamespacedKey fromString(@Nonnull String string, @Nullable Plugin defaultNamespace) {
+ Preconditions.checkArgument(string != null && !string.isEmpty(), "Input string must not be empty or null");
+
+ String[] components = string.split(":", 3);
+ if (components.length > 2) {
+ return null;
+ }
+
+ String key = (components.length == 2) ? components[1] : "";
+ if (components.length == 1) {
+ String value = components[0];
+ if (value.isEmpty() || !VALID_KEY.matcher(value).matches()) {
+ return null;
+ }
+
+ return (defaultNamespace != null) ? new NamespacedKey(defaultNamespace, value) : NamespacedKey.minecraft(value);
+ } else if (components.length == 2 && !VALID_KEY.matcher(key).matches()) {
+ return null;
+ }
+
+ String namespace = components[0];
+ if (namespace.isEmpty()) {
+ return (defaultNamespace != null) ? new NamespacedKey(defaultNamespace, key) : NamespacedKey.minecraft(key);
+ }
+
+ if (!VALID_KEY.matcher(namespace).matches()) {
+ return null;
+ }
+
+ return new NamespacedKey(namespace, key);
+ }
+
+}
diff --git a/plugin/src/main/java/net/codingarea/commons/bukkit/utils/misc/CompatibilityUtils.java b/plugin/src/main/java/net/codingarea/commons/bukkit/utils/misc/CompatibilityUtils.java
new file mode 100644
index 000000000..47cd94c9d
--- /dev/null
+++ b/plugin/src/main/java/net/codingarea/commons/bukkit/utils/misc/CompatibilityUtils.java
@@ -0,0 +1,50 @@
+package net.codingarea.commons.bukkit.utils.misc;
+
+import net.codingarea.commons.common.logging.ILogger;
+import org.bukkit.entity.Player;
+import org.bukkit.event.inventory.InventoryClickEvent;
+import org.bukkit.inventory.Inventory;
+import org.bukkit.inventory.InventoryView;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import javax.annotation.Nonnull;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+
+/*
+ * In API version 1.20.6 and earlier, InventoryView is an abstract class
+ * In API version 1.21, InventoryView is an interface
+ */
+public class CompatibilityUtils {
+
+ protected static final ILogger logger = ILogger.forThisClass();
+ private static final Logger log = LoggerFactory.getLogger(CompatibilityUtils.class);
+
+ private CompatibilityUtils() {
+ }
+
+ public static Inventory getTopInventory(@Nonnull Player player) {
+ InventoryView view = player.getOpenInventory();
+
+ try {
+ Method getTopInventory = InventoryView.class.getMethod("getTopInventory");
+ return (Inventory) getTopInventory.invoke(view);
+ } catch (NoSuchMethodException | InvocationTargetException | IllegalAccessException ex) {
+ logger.error("Failed to get top inventory", ex);
+ return null;
+ }
+ }
+
+ public static Inventory getTopInventory(@Nonnull InventoryClickEvent event) {
+ InventoryView view = event.getView();
+
+ try {
+ Method getTopInventory = InventoryView.class.getMethod("getTopInventory");
+ return (Inventory) getTopInventory.invoke(view);
+ } catch (NoSuchMethodException | InvocationTargetException | IllegalAccessException ex) {
+ logger.error("Failed to get top inventory", ex);
+ return null;
+ }
+ }
+}
diff --git a/plugin/src/main/java/net/codingarea/commons/bukkit/utils/misc/GameProfileUtils.java b/plugin/src/main/java/net/codingarea/commons/bukkit/utils/misc/GameProfileUtils.java
new file mode 100644
index 000000000..44d8d380f
--- /dev/null
+++ b/plugin/src/main/java/net/codingarea/commons/bukkit/utils/misc/GameProfileUtils.java
@@ -0,0 +1,91 @@
+package net.codingarea.commons.bukkit.utils.misc;
+
+import com.mojang.authlib.GameProfile;
+import com.mojang.authlib.properties.Property;
+import net.codingarea.commons.common.collection.WrappedException;
+import net.codingarea.commons.common.logging.ILogger;
+import org.bukkit.entity.Player;
+import org.bukkit.inventory.meta.SkullMeta;
+
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+import java.util.UUID;
+
+public final class GameProfileUtils {
+
+ private static final ILogger logger = ILogger.forThisClass();
+
+ private GameProfileUtils() {}
+
+ @Nonnull
+ public static GameProfile getGameProfile(@Nonnull Player player) {
+ try {
+
+ Class classOfPlayer = player.getClass();
+
+ Method getProfileMethod = classOfPlayer.getMethod("getProfile");
+ getProfileMethod.setAccessible(true);
+ return (GameProfile) getProfileMethod.invoke(player);
+
+ } catch (Exception ex) {
+ throw new WrappedException(ex);
+ }
+ }
+
+ public static void applyTextures(@Nonnull SkullMeta meta, @Nullable UUID uuid, @Nullable String name, @Nullable String texture) {
+ applyTextures(meta, uuid, name, texture, null);
+ }
+
+ public static void applyTextures(@Nonnull SkullMeta meta, @Nullable UUID uuid, @Nullable String name, @Nullable String texture, @Nullable String signature) {
+ if (texture == null || texture.isEmpty()) return;
+
+ GameProfile profile = new GameProfile(uuid == null ? UUID.randomUUID() : uuid, name);
+ profile.getProperties().put("textures", new Property("textures", texture, signature));
+
+ Class classOfMeta = meta.getClass();
+ try {
+ Method setProfileMethod = classOfMeta.getDeclaredMethod("setProfile", GameProfile.class);
+ setProfileMethod.setAccessible(true);
+ setProfileMethod.invoke(meta, profile);
+ return;
+ } catch (Exception ignored) {
+ }
+
+ try {
+ Field field = classOfMeta.getDeclaredField("profile");
+ field.setAccessible(true);
+ field.set(meta, profile);
+
+ // This field is not implemented in every version
+ try {
+ field = classOfMeta.getDeclaredField("serializedProfile");
+ field.setAccessible(true);
+ field.set(meta, profile);
+ } catch (Exception ignored) {
+ }
+
+ return;
+ } catch (Exception ignored) {
+ }
+
+ logger.warn("Unable to apply textures to item");
+
+ }
+
+ @Nonnull
+ public static GameProfile getTextures(@Nonnull SkullMeta meta) {
+
+ Class classOfMeta = meta.getClass();
+ try {
+ Field field = classOfMeta.getDeclaredField("profile");
+ field.setAccessible(true);
+ return (GameProfile) field.get(meta);
+ } catch (Exception ex) {
+ throw new WrappedException(ex);
+ }
+
+ }
+
+}
diff --git a/plugin/src/main/java/net/codingarea/commons/bukkit/utils/misc/MinecraftVersion.java b/plugin/src/main/java/net/codingarea/commons/bukkit/utils/misc/MinecraftVersion.java
new file mode 100644
index 000000000..16e369a67
--- /dev/null
+++ b/plugin/src/main/java/net/codingarea/commons/bukkit/utils/misc/MinecraftVersion.java
@@ -0,0 +1,115 @@
+package net.codingarea.commons.bukkit.utils.misc;
+
+import net.codingarea.commons.common.version.Version;
+import org.bukkit.Bukkit;
+
+import javax.annotation.CheckReturnValue;
+import javax.annotation.Nonnull;
+
+public enum MinecraftVersion implements Version {
+
+ V1_0, // 1.0
+ V1_1, // 1.1
+ V1_2_1, // 1.2.1
+ V1_3_1, // 1.3.1
+ V1_4_2, // 1.4.2
+ V1_5, // 1.5
+ V1_6, // 1.6
+ V1_7, // 1.7
+ V1_7_2, // 1.7.2
+ V1_8, // 1.8
+ V1_9, // 1.9
+ V1_10, // 1.10
+ V1_11, // 1.11
+ V1_12, // 1.12
+ V1_13, // 1.13
+ V1_14, // 1.14
+ V1_15, // 1.15
+ V1_16, // 1.16
+ V1_16_5, // 1.16.5
+ V1_17, // 1.17
+ V1_18, // 1.18
+ V1_19, // 1.19
+ V1_20, // 1.20
+ V1_20_1, // 1.20.1
+ V1_20_2, // 1.20.2
+ V1_20_3, // 1.20.3
+ V1_20_4, // 1.20.4
+ V1_20_5, // 1.20.5
+ V1_21, // 1.21
+ V1_21_1, // 1.21.1
+ V1_21_2, // 1.21.2
+ V1_21_3, // 1.21.3
+ V1_21_4, // 1.21.4
+ V1_21_5 // 1.21.5
+ ;
+
+ private final int major, minor, revision;
+
+ MinecraftVersion() {
+
+ String name = this.name().substring(1);
+ String[] version = name.split("_");
+
+ if (version.length != 2 && version.length != 3)
+ throw new IllegalArgumentException("Name '" + name() + "' does not match pattern: V{major}_{minor}_[revision]");
+
+ major = Integer.parseInt(version[0]);
+ minor = Integer.parseInt(version[1]);
+ revision = version.length > 2 ? Integer.parseInt(version[2]) : 0;
+
+ }
+
+ @Override
+ public int getMajor() {
+ return major;
+ }
+
+ @Override
+ public int getMinor() {
+ return minor;
+ }
+
+ @Override
+ public int getRevision() {
+ return revision;
+ }
+
+ @Override
+ public String toString() {
+ return this.format();
+ }
+
+ @Nonnull
+ @CheckReturnValue
+ public static Version parseExact(@Nonnull String bukkitVersion) {
+ bukkitVersion = bukkitVersion.substring(0, bukkitVersion.indexOf("-"));
+ return Version.parse(bukkitVersion);
+ }
+
+ @Nonnull
+ @CheckReturnValue
+ public static MinecraftVersion findNearest(@Nonnull Version realVersion) {
+ return Version.findNearest(realVersion, values());
+ }
+
+ private static Version currentExact;
+ private static MinecraftVersion current;
+
+ @Nonnull
+ @CheckReturnValue
+ public static Version currentExact() {
+ if (currentExact == null)
+ currentExact = parseExact(Bukkit.getBukkitVersion());
+ return currentExact;
+ }
+
+ @Nonnull
+ @CheckReturnValue
+ public static MinecraftVersion current() {
+ if (current == null)
+ current = findNearest(currentExact());
+ return current;
+ }
+
+}
diff --git a/plugin/src/main/java/net/codingarea/commons/bukkit/utils/wrapper/ActionListener.java b/plugin/src/main/java/net/codingarea/commons/bukkit/utils/wrapper/ActionListener.java
new file mode 100644
index 000000000..8faa0993b
--- /dev/null
+++ b/plugin/src/main/java/net/codingarea/commons/bukkit/utils/wrapper/ActionListener.java
@@ -0,0 +1,57 @@
+package net.codingarea.commons.bukkit.utils.wrapper;
+
+import org.bukkit.event.Event;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.Listener;
+
+import javax.annotation.Nonnull;
+import java.util.Objects;
+import java.util.function.Consumer;
+
+public final class ActionListener implements Listener {
+
+ private final Class classOfEvent;
+ private final Consumer listener;
+ private final EventPriority priority;
+ private final boolean ignoreCancelled;
+
+ public ActionListener(@Nonnull Class classOfEvent, @Nonnull Consumer listener, @Nonnull EventPriority priority, boolean ignoreCancelled) {
+ this.classOfEvent = classOfEvent;
+ this.listener = listener;
+ this.priority = priority;
+ this.ignoreCancelled = ignoreCancelled;
+ }
+
+ @Override
+ public boolean equals(Object o) {
+ if (this == o) return true;
+ if (o == null || getClass() != o.getClass()) return false;
+ ActionListener that = (ActionListener) o;
+ return listener.equals(that.listener);
+ }
+
+ @Override
+ public int hashCode() {
+ return Objects.hash(listener);
+ }
+
+ @Nonnull
+ public Consumer getListener() {
+ return listener;
+ }
+
+ @Nonnull
+ public EventPriority getPriority() {
+ return priority;
+ }
+
+ @Nonnull
+ public Class getClassOfEvent() {
+ return classOfEvent;
+ }
+
+ public boolean isIgnoreCancelled() {
+ return ignoreCancelled;
+ }
+
+}
diff --git a/plugin/src/main/java/net/codingarea/challenges/plugin/utils/bukkit/misc/wrapper/AttributeWrapper.java b/plugin/src/main/java/net/codingarea/commons/bukkit/utils/wrapper/AttributeWrapper.java
similarity index 80%
rename from plugin/src/main/java/net/codingarea/challenges/plugin/utils/bukkit/misc/wrapper/AttributeWrapper.java
rename to plugin/src/main/java/net/codingarea/commons/bukkit/utils/wrapper/AttributeWrapper.java
index 5b5abbdb8..ea2a13e3f 100644
--- a/plugin/src/main/java/net/codingarea/challenges/plugin/utils/bukkit/misc/wrapper/AttributeWrapper.java
+++ b/plugin/src/main/java/net/codingarea/commons/bukkit/utils/wrapper/AttributeWrapper.java
@@ -1,6 +1,6 @@
-package net.codingarea.challenges.plugin.utils.bukkit.misc.wrapper;
+package net.codingarea.commons.bukkit.utils.wrapper;
-import net.codingarea.challenges.plugin.utils.bukkit.misc.version.MinecraftVersion;
+import net.codingarea.commons.bukkit.utils.misc.MinecraftVersion;
import org.bukkit.attribute.Attribute;
public class AttributeWrapper {
diff --git a/plugin/src/main/java/net/codingarea/commons/bukkit/utils/wrapper/MaterialWrapper.java b/plugin/src/main/java/net/codingarea/commons/bukkit/utils/wrapper/MaterialWrapper.java
new file mode 100644
index 000000000..d073dd81f
--- /dev/null
+++ b/plugin/src/main/java/net/codingarea/commons/bukkit/utils/wrapper/MaterialWrapper.java
@@ -0,0 +1,27 @@
+package net.codingarea.commons.bukkit.utils.wrapper;
+
+import net.codingarea.commons.common.misc.ReflectionUtils;
+import org.bukkit.Material;
+
+import javax.annotation.Nonnull;
+
+/**
+ * This class allows you to use materials, whose names are changed at some point, in most versions.
+ * For example the red dye was first named {@code ROSE_RED} but then renamed to {@code RED_DYE}.
+ * To prevent unwanted {@link NoSuchFieldError NoSuchFieldErrors}, you should use this wrapper instead of a direct call to the material enum {@link Material}.
+ */
+public final class MaterialWrapper {
+
+ private MaterialWrapper() {}
+
+ public static final Material GREEN_DYE = getMaterialByNames("CACTUS_GREEN", "GREEN_DYE");
+ public static final Material RED_DYE = getMaterialByNames("ROSE_RED", "RED_DYE");
+ public static final Material YELLOW_DYE = getMaterialByNames("DANDELION_YELLOW", "YELLOW_DYE");
+ public static final Material SIGN = getMaterialByNames("SIGN", "OAK_SIGN");
+
+ @Nonnull
+ private static Material getMaterialByNames(@Nonnull String... names) {
+ return ReflectionUtils.getFirstEnumByNames(Material.class, names);
+ }
+
+}
diff --git a/plugin/src/main/java/net/codingarea/commons/bukkit/utils/wrapper/SimpleEventExecutor.java b/plugin/src/main/java/net/codingarea/commons/bukkit/utils/wrapper/SimpleEventExecutor.java
new file mode 100644
index 000000000..2b3055417
--- /dev/null
+++ b/plugin/src/main/java/net/codingarea/commons/bukkit/utils/wrapper/SimpleEventExecutor.java
@@ -0,0 +1,31 @@
+package net.codingarea.commons.bukkit.utils.wrapper;
+
+import org.bukkit.event.Event;
+import org.bukkit.event.EventException;
+import org.bukkit.event.Listener;
+import org.bukkit.plugin.EventExecutor;
+
+import javax.annotation.Nonnull;
+import java.util.function.Consumer;
+
+public class SimpleEventExecutor implements EventExecutor {
+
+ private final Class classOfEvent;
+ private final Consumer action;
+
+ public SimpleEventExecutor(@Nonnull Class classOfEvent, @Nonnull Consumer action) {
+ this.classOfEvent = classOfEvent;
+ this.action = action;
+ }
+
+ @Override
+ public void execute(@Nonnull Listener listener, @Nonnull Event event) throws EventException {
+ if (!classOfEvent.isAssignableFrom(event.getClass())) return;
+ try {
+ action.accept(event);
+ } catch (Throwable ex) {
+ throw new EventException(ex);
+ }
+ }
+
+}
diff --git a/plugin/src/main/java/net/codingarea/commons/common/annotations/AlsoKnownAs.java b/plugin/src/main/java/net/codingarea/commons/common/annotations/AlsoKnownAs.java
new file mode 100644
index 000000000..685852b83
--- /dev/null
+++ b/plugin/src/main/java/net/codingarea/commons/common/annotations/AlsoKnownAs.java
@@ -0,0 +1,17 @@
+package net.codingarea.commons.common.annotations;
+
+import javax.annotation.Nonnull;
+import java.lang.annotation.*;
+
+/**
+ * Used to declare alternate names which are used in used or similar libraries.
+ */
+@Documented
+@Retention(RetentionPolicy.CLASS)
+@Target({ElementType.FIELD, ElementType.METHOD, ElementType.TYPE})
+public @interface AlsoKnownAs {
+
+ @Nonnull
+ String[] value();
+
+}
diff --git a/plugin/src/main/java/net/codingarea/commons/common/annotations/DeprecatedSince.java b/plugin/src/main/java/net/codingarea/commons/common/annotations/DeprecatedSince.java
new file mode 100644
index 000000000..72fb1e113
--- /dev/null
+++ b/plugin/src/main/java/net/codingarea/commons/common/annotations/DeprecatedSince.java
@@ -0,0 +1,17 @@
+package net.codingarea.commons.common.annotations;
+
+import javax.annotation.Nonnull;
+import java.lang.annotation.*;
+
+/**
+ * @see Deprecated
+ */
+@Documented
+@Retention(RetentionPolicy.CLASS)
+@Target({ElementType.CONSTRUCTOR, ElementType.FIELD, ElementType.LOCAL_VARIABLE, ElementType.METHOD, ElementType.PACKAGE, ElementType.PARAMETER, ElementType.TYPE})
+public @interface DeprecatedSince {
+
+ @Nonnull
+ String value();
+
+}
diff --git a/plugin/src/main/java/net/codingarea/commons/common/annotations/ReplaceWith.java b/plugin/src/main/java/net/codingarea/commons/common/annotations/ReplaceWith.java
new file mode 100644
index 000000000..469355d3b
--- /dev/null
+++ b/plugin/src/main/java/net/codingarea/commons/common/annotations/ReplaceWith.java
@@ -0,0 +1,17 @@
+package net.codingarea.commons.common.annotations;
+
+import javax.annotation.Nonnull;
+import java.lang.annotation.*;
+
+/**
+ * @see Deprecated
+ */
+@Documented
+@Retention(RetentionPolicy.CLASS)
+@Target({ElementType.CONSTRUCTOR, ElementType.FIELD, ElementType.LOCAL_VARIABLE, ElementType.METHOD, ElementType.PACKAGE, ElementType.PARAMETER, ElementType.TYPE})
+public @interface ReplaceWith {
+
+ @Nonnull
+ String value();
+
+}
diff --git a/plugin/src/main/java/net/codingarea/commons/common/annotations/Since.java b/plugin/src/main/java/net/codingarea/commons/common/annotations/Since.java
new file mode 100644
index 000000000..0f27a0c69
--- /dev/null
+++ b/plugin/src/main/java/net/codingarea/commons/common/annotations/Since.java
@@ -0,0 +1,14 @@
+package net.codingarea.commons.common.annotations;
+
+import javax.annotation.Nonnull;
+import java.lang.annotation.*;
+
+@Documented
+@Target({ElementType.TYPE, ElementType.METHOD, ElementType.CONSTRUCTOR, ElementType.PACKAGE})
+@Retention(RetentionPolicy.RUNTIME)
+public @interface Since {
+
+ @Nonnull
+ String value();
+
+}
diff --git a/plugin/src/main/java/net/codingarea/commons/common/collection/ArrayWalker.java b/plugin/src/main/java/net/codingarea/commons/common/collection/ArrayWalker.java
new file mode 100644
index 000000000..23ba208f9
--- /dev/null
+++ b/plugin/src/main/java/net/codingarea/commons/common/collection/ArrayWalker.java
@@ -0,0 +1,56 @@
+package net.codingarea.commons.common.collection;
+
+import javax.annotation.Nonnull;
+import java.lang.reflect.Array;
+import java.util.Iterator;
+import java.util.NoSuchElementException;
+import java.util.function.Consumer;
+
+public class ArrayWalker implements Iterable {
+
+ protected final Object array;
+ protected final int length;
+
+ protected ArrayWalker(@Nonnull Object array) {
+ if (!array.getClass().isArray()) throw new IllegalArgumentException(array.getClass().getName() + " is not an array");
+ this.array = array;
+ this.length = Array.getLength(array);
+ }
+
+ public static ArrayWalker walk(@Nonnull Object array) {
+ return new ArrayWalker<>(array);
+ }
+
+ public static ArrayWalker walk(@Nonnull T... array) {
+ return new ArrayWalker<>(array);
+ }
+
+ @Override
+ public Iterator iterator() {
+ return new Iterator() {
+
+ private int cursor = 0;
+
+ @Override
+ public boolean hasNext() {
+ return cursor < length;
+ }
+
+ @Override
+ @SuppressWarnings("unchecked")
+ public T next() {
+ if (!hasNext()) throw new NoSuchElementException();
+ return (T) Array.get(array, cursor++);
+ }
+
+ };
+ }
+
+ @Override
+ @SuppressWarnings("unchecked")
+ public void forEach(Consumer action) {
+ for (int i = 0; i < length; i++) {
+ action.accept((T) Array.get(array, i));
+ }
+ }
+}
diff --git a/plugin/src/main/java/net/codingarea/commons/common/collection/ClassWalker.java b/plugin/src/main/java/net/codingarea/commons/common/collection/ClassWalker.java
new file mode 100644
index 000000000..d71f0df71
--- /dev/null
+++ b/plugin/src/main/java/net/codingarea/commons/common/collection/ClassWalker.java
@@ -0,0 +1,65 @@
+package net.codingarea.commons.common.collection;
+
+import javax.annotation.Nonnull;
+import java.util.*;
+
+/**
+ * @author JDA | https://github.com/DV8FromTheWorld/JDA/blob/development/src/main/java/net/dv8tion/jda/internal/utils/ClassWalker.java
+ */
+public class ClassWalker implements Iterable> {
+
+ protected final Class clazz;
+ protected final Class end;
+
+ protected ClassWalker(@Nonnull Class clazz) {
+ this(clazz, Object.class);
+ }
+
+ protected ClassWalker(@Nonnull Class clazz, @Nonnull Class end) {
+ this.clazz = clazz;
+ this.end = end;
+ }
+
+ public static ClassWalker range(@Nonnull Class start, @Nonnull Class end) {
+ return new ClassWalker(start, end);
+ }
+
+ public static ClassWalker walk(@Nonnull Class start) {
+ return new ClassWalker(start);
+ }
+
+ @Nonnull
+ @Override
+ public Iterator> iterator() {
+ return new Iterator>() {
+
+ private final Set> done = new HashSet<>();
+ private final Deque> work = new LinkedList<>();
+
+ {
+ work.addLast(clazz);
+ done.add(end);
+ }
+
+ @Override
+ public boolean hasNext() {
+ return !work.isEmpty();
+ }
+
+ @Override
+ public Class next() {
+ Class current = work.removeFirst();
+ done.add(current);
+ for (Class parent : current.getInterfaces()) {
+ if (!done.contains(parent))
+ work.addLast(parent);
+ }
+
+ Class parent = current.getSuperclass();
+ if (parent != null && !done.contains(parent))
+ work.addLast(parent);
+ return current;
+ }
+ };
+ }
+}
diff --git a/plugin/src/main/java/net/codingarea/commons/common/collection/Colors.java b/plugin/src/main/java/net/codingarea/commons/common/collection/Colors.java
new file mode 100644
index 000000000..dc7950c10
--- /dev/null
+++ b/plugin/src/main/java/net/codingarea/commons/common/collection/Colors.java
@@ -0,0 +1,38 @@
+package net.codingarea.commons.common.collection;
+
+import javax.annotation.CheckReturnValue;
+import javax.annotation.Nonnull;
+import java.awt.*;
+
+import static java.awt.Color.decode;
+
+public final class Colors {
+
+ private Colors() {}
+
+ public static final Color
+ ONLINE = decode("#40AC7B"),
+ DO_NOT_DISTURB = decode("#E84444"),
+ IDLE = decode("#F09F19"),
+ OFFLINE = decode("#747F8D"),
+ STREAMING = decode("#573591"),
+
+ EMBED = decode("#2F3136"),
+ NO_RANK = decode("#CCD8DE"),
+
+ LIGHT_BLACK = decode("#1c1c1c")
+ ;
+
+ @Nonnull
+ @CheckReturnValue
+ public static String asHex(@Nonnull Color color) {
+ String red = Integer.toHexString(color.getRed());
+ String green = Integer.toHexString(color.getGreen());
+ String blue = Integer.toHexString(color.getBlue());
+ return "#" + (red.length() == 1 ? "0" + red : red) +
+ (green.length() == 1 ? "0" + green : green) +
+ (blue.length() == 1 ? "0" + blue : blue);
+ }
+
+
+}
diff --git a/plugin/src/main/java/net/codingarea/commons/common/collection/FontBuilder.java b/plugin/src/main/java/net/codingarea/commons/common/collection/FontBuilder.java
new file mode 100644
index 000000000..4625c3347
--- /dev/null
+++ b/plugin/src/main/java/net/codingarea/commons/common/collection/FontBuilder.java
@@ -0,0 +1,93 @@
+package net.codingarea.commons.common.collection;
+
+import javax.annotation.CheckReturnValue;
+import javax.annotation.Nonnull;
+import java.awt.*;
+import java.io.File;
+import java.io.IOException;
+import java.util.Objects;
+
+public class FontBuilder {
+
+ private Font font;
+
+ public FontBuilder(@Nonnull File file) throws IOException, FontFormatException {
+ this(file, Font.TRUETYPE_FONT);
+ }
+
+ public FontBuilder(@Nonnull File file, int type) throws IOException, FontFormatException {
+ this.font = Font.createFont(type, file);
+ }
+
+ public FontBuilder(@Nonnull String resource) throws IOException, FontFormatException {
+ this(resource, Font.TRUETYPE_FONT);
+ }
+
+ public FontBuilder(@Nonnull String resource, int type) throws IOException, FontFormatException {
+ this.font = Font.createFont(type, Objects.requireNonNull(getClass().getClassLoader().getResourceAsStream(resource)));
+ }
+
+ @Nonnull
+ @CheckReturnValue
+ public FontBuilder bold() {
+ return style(Font.BOLD);
+ }
+
+ @Nonnull
+ @CheckReturnValue
+ public FontBuilder italic() {
+ return style(Font.ITALIC);
+ }
+
+ @Nonnull
+ @CheckReturnValue
+ public FontBuilder style(int style) {
+ font = font.deriveFont(style);
+ return this;
+ }
+
+ @Nonnull
+ @CheckReturnValue
+ public FontBuilder size(float size) {
+ font = font.deriveFont(size);
+ return this;
+ }
+
+ @Nonnull
+ @CheckReturnValue
+ public FontBuilder derive(int style, float size) {
+ font = font.deriveFont(style, size);
+ return this;
+ }
+
+ @Nonnull
+ public Font build() {
+ registerFont(font);
+ return font;
+ }
+
+ public static void registerFont(@Nonnull Font font) {
+ GraphicsEnvironment.getLocalGraphicsEnvironment().registerFont(font);
+ }
+
+ @Nonnull
+ @CheckReturnValue
+ public static FontBuilder fromFile(@Nonnull String filename) {
+ try {
+ return new FontBuilder(new File(filename));
+ } catch (Exception ex) {
+ throw new WrappedException(ex);
+ }
+ }
+
+ @Nonnull
+ @CheckReturnValue
+ public static FontBuilder fromResource(@Nonnull String resource) {
+ try {
+ return new FontBuilder(resource);
+ } catch (Exception ex) {
+ throw new WrappedException(ex);
+ }
+ }
+
+}
diff --git a/plugin/src/main/java/net/codingarea/commons/common/collection/IOUtils.java b/plugin/src/main/java/net/codingarea/commons/common/collection/IOUtils.java
new file mode 100644
index 000000000..54c8675fe
--- /dev/null
+++ b/plugin/src/main/java/net/codingarea/commons/common/collection/IOUtils.java
@@ -0,0 +1,43 @@
+package net.codingarea.commons.common.collection;
+
+import javax.annotation.CheckReturnValue;
+import javax.annotation.Nonnull;
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.net.HttpURLConnection;
+import java.net.URL;
+import java.nio.charset.StandardCharsets;
+
+public final class IOUtils {
+
+ private IOUtils() {}
+
+ public static String toString(@Nonnull String url) throws IOException {
+ return toString(new URL(url));
+ }
+
+ public static String toString(@Nonnull URL url) throws IOException {
+ InputStream input = url.openStream();
+ String string = toString(input);
+ input.close();
+ return string;
+ }
+
+ public static String toString(@Nonnull InputStream input) throws IOException {
+ StringBuilder builder = new StringBuilder();
+ BufferedReader reader = new BufferedReader(new InputStreamReader(input, StandardCharsets.UTF_8));
+ reader.lines().forEach(builder::append);
+ return builder.toString();
+ }
+
+ @Nonnull
+ @CheckReturnValue
+ public static HttpURLConnection createConnection(@Nonnull String url) throws IOException {
+ HttpURLConnection connection = (HttpURLConnection) new URL(url).openConnection();
+ connection.setRequestProperty("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/56.0.2924.87 Safari/537.36");
+ return connection;
+ }
+
+}
diff --git a/plugin/src/main/java/net/codingarea/commons/common/collection/IRandom.java b/plugin/src/main/java/net/codingarea/commons/common/collection/IRandom.java
new file mode 100644
index 000000000..cfd4a96bc
--- /dev/null
+++ b/plugin/src/main/java/net/codingarea/commons/common/collection/IRandom.java
@@ -0,0 +1,152 @@
+package net.codingarea.commons.common.collection;
+
+import javax.annotation.CheckReturnValue;
+import javax.annotation.Nonnegative;
+import javax.annotation.Nonnull;
+import java.security.SecureRandom;
+import java.util.*;
+import java.util.concurrent.ThreadLocalRandom;
+import java.util.stream.DoubleStream;
+import java.util.stream.IntStream;
+import java.util.stream.LongStream;
+
+public interface IRandom {
+
+ @Nonnull
+ @CheckReturnValue
+ static IRandom create() {
+ return new SeededRandomWrapper();
+ }
+
+ @Nonnull
+ @CheckReturnValue
+ static IRandom create(long seed) {
+ return new SeededRandomWrapper(seed);
+ }
+
+ @Nonnull
+ @CheckReturnValue
+ static IRandom wrap(@Nonnull Random random) {
+ return new RandomWrapper(random);
+ }
+
+ @Nonnull
+ @CheckReturnValue
+ static IRandom threadLocal() {
+ return wrap(ThreadLocalRandom.current());
+ }
+
+ @Nonnull
+ @CheckReturnValue
+ static IRandom secure() {
+ return wrap(new SecureRandom());
+ }
+
+ @Nonnull
+ @CheckReturnValue
+ static IRandom singleton() {
+ return SingletonRandom.INSTANCE;
+ }
+
+ long getSeed();
+
+ void setSeed(long seed);
+
+ void nextBytes(@Nonnull byte[] bytes);
+
+ boolean nextBoolean();
+
+ int nextInt();
+
+ int nextInt(int bound);
+
+ @Nonnull
+ @CheckReturnValue
+ IntStream ints();
+
+ @Nonnull
+ @CheckReturnValue
+ IntStream ints(@Nonnegative long streamSize);
+
+ @Nonnull
+ @CheckReturnValue
+ IntStream ints(int randomNumberOrigin, int randomNumberBound);
+
+ @Nonnull
+ @CheckReturnValue
+ IntStream ints(@Nonnegative long streamSize, int randomNumberOrigin, int randomNumberBound);
+
+ @Nonnull
+ @CheckReturnValue
+ LongStream longs();
+
+ long nextLong();
+
+ @Nonnull
+ @CheckReturnValue
+ LongStream longs(@Nonnegative long streamSize);
+
+ @Nonnull
+ @CheckReturnValue
+ LongStream longs(long randomNumberOrigin, long randomNumberBound);
+
+ @Nonnull
+ @CheckReturnValue
+ LongStream longs(@Nonnegative long streamSize, long randomNumberOrigin, long randomNumberBound);
+
+ double nextDouble();
+
+ double nextGaussian();
+
+ @Nonnull
+ @CheckReturnValue
+ DoubleStream doubles();
+
+ @Nonnull
+ @CheckReturnValue
+ DoubleStream doubles(@Nonnegative long streamSize);
+
+ @Nonnull
+ @CheckReturnValue
+ DoubleStream doubles(double randomNumberOrigin, double randomNumberBound);
+
+ @Nonnull
+ @CheckReturnValue
+ DoubleStream doubles(@Nonnegative long streamSize, double randomNumberOrigin, double randomNumberBound);
+
+ float nextFloat();
+
+ default T choose(@Nonnull T... array) {
+ return array[nextInt(array.length)];
+ }
+
+ default T choose(@Nonnull List list) {
+ return list.get(nextInt(list.size()));
+ }
+
+ default T choose(@Nonnull Collection collection) {
+ return choose(new ArrayList<>(collection));
+ }
+
+ default void shuffle(@Nonnull List list) {
+ Collections.shuffle(list, asRandom());
+ }
+
+ default int around(int value, @Nonnegative int range) {
+ return range(value - range, value + range);
+ }
+
+ default int range(int min, int max) {
+ if (min >= max) throw new IllegalArgumentException("min >= max");
+ return nextInt(max - min) + min;
+ }
+
+ @Nonnull
+ @CheckReturnValue
+ default Random asRandom() {
+ if (!(this instanceof Random))
+ throw new IllegalStateException(this.getClass().getName() + " cannot be converted a java.util.Random");
+ return (Random) this;
+ }
+
+}
diff --git a/plugin/src/main/java/net/codingarea/commons/common/collection/NamedThreadFactory.java b/plugin/src/main/java/net/codingarea/commons/common/collection/NamedThreadFactory.java
new file mode 100644
index 000000000..624f2508f
--- /dev/null
+++ b/plugin/src/main/java/net/codingarea/commons/common/collection/NamedThreadFactory.java
@@ -0,0 +1,37 @@
+package net.codingarea.commons.common.collection;
+
+import javax.annotation.Nonnull;
+import java.util.concurrent.ThreadFactory;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.function.IntFunction;
+
+public class NamedThreadFactory implements ThreadFactory {
+
+ private static final AtomicInteger poolNumber = new AtomicInteger(1);
+
+ protected final int id = poolNumber.getAndIncrement();
+ protected final IntFunction nameFunction;
+ protected final ThreadGroup group;
+ protected final AtomicInteger threadNumber = new AtomicInteger(1);
+
+ public NamedThreadFactory(@Nonnull IntFunction nameFunction) {
+ SecurityManager securityManager = System.getSecurityManager();
+ this.group = (securityManager != null) ? securityManager.getThreadGroup() : Thread.currentThread().getThreadGroup();
+ this.nameFunction = nameFunction;
+ }
+
+ public NamedThreadFactory(@Nonnull String prefix) {
+ this(id -> prefix + "-" + id);
+ }
+
+ @Override
+ public Thread newThread(@Nonnull Runnable task) {
+ Thread thread = new Thread(group, task, nameFunction.apply(threadNumber.getAndIncrement()));
+ if (thread.isDaemon())
+ thread.setDaemon(false);
+ if (thread.getPriority() != Thread.NORM_PRIORITY)
+ thread.setPriority(Thread.NORM_PRIORITY);
+ return thread;
+ }
+
+}
diff --git a/plugin/src/main/java/net/codingarea/commons/common/collection/NumberFormatter.java b/plugin/src/main/java/net/codingarea/commons/common/collection/NumberFormatter.java
new file mode 100644
index 000000000..4a734b55b
--- /dev/null
+++ b/plugin/src/main/java/net/codingarea/commons/common/collection/NumberFormatter.java
@@ -0,0 +1,357 @@
+package net.codingarea.commons.common.collection;
+
+import javax.annotation.CheckReturnValue;
+import javax.annotation.Nonnull;
+import java.text.DecimalFormat;
+import java.text.DecimalFormatSymbols;
+import java.util.function.Consumer;
+
+public interface NumberFormatter {
+
+ @Nonnull
+ @CheckReturnValue
+ String format(double value);
+
+ @Nonnull
+ @CheckReturnValue
+ default String format(float value) {
+ return format(Float.valueOf(value));
+ }
+
+ @Nonnull
+ @CheckReturnValue
+ default String format(long value) {
+ return format(Long.valueOf(value));
+ }
+
+ @Nonnull
+ @CheckReturnValue
+ default String format(int value) {
+ return format(Integer.valueOf(value));
+ }
+
+ @Nonnull
+ @CheckReturnValue
+ default String format(short value) {
+ return format(Short.valueOf(value));
+ }
+
+ @Nonnull
+ @CheckReturnValue
+ default String format(byte value) {
+ return format(Byte.valueOf(value));
+ }
+
+ @Nonnull
+ @CheckReturnValue
+ default String format(@Nonnull Number number) {
+ return format(number.doubleValue());
+ }
+
+ public static final NumberFormatter
+ DEFAULT = fromPattern("0.##", null, false),
+ INTEGER = value -> (int) value + "",
+ SPACE_SPLIT = fromPattern("###,##0.###############", null, false,
+ init -> updateSymbols(init, symbols -> symbols.setGroupingSeparator(' '))),
+ FLOATING_POINT = fromPattern("0.0", null, false),
+ DOUBLE_FLOATING_POINT = fromPattern("0.00", null, false),
+ BIG_FLOATING_POINT = fromPattern("###,##0.00000", null, false),
+ PERCENTAGE = fromPattern("0.##", "%", true),
+ FLOATING_PERCENTAGE = fromPattern("0.00", "%", true),
+ MIDDLE_NUMBER = fromPattern("###,###,##0.#", null, false),
+
+ /**
+ * days, hours, minutes, seconds
+ */
+ TIME = value -> {
+
+ int seconds = (int) value;
+ int minutes = seconds / 60;
+ int hours = minutes / 60;
+ int days = hours / 24;
+ int years = days / 365;
+
+ seconds %= 60;
+ minutes %= 60;
+ hours %= 24;
+ days %= 365;
+
+ return ((years > 0 ? years + "y " : "")
+ + (days > 0 ? days + "d " : "")
+ + (hours > 0 ? hours + "h " : "")
+ + (minutes > 0 ? minutes + "m " : "")
+ + (seconds > 0 || (years == 0 && days == 0 && hours == 0 && minutes == 0) ? seconds + "s" : "")).trim();
+
+ },
+
+ /**
+ * days, hours, minutes
+ */
+ BIG_TIME = value -> {
+
+ int seconds = (int) value;
+ int minutes = seconds / 60;
+ int hours = minutes / 60;
+ int days = hours / 24;
+ int years = days / 365;
+
+ minutes %= 60;
+ hours %= 24;
+ days %= 365;
+
+ return ((years > 0 ? years + "y " : "")
+ + (days > 0 ? days + "d " : "")
+ + (hours > 0 ? hours + "h " : "")
+ + (minutes > 0 || (years == 0 && days == 0 && hours == 0) ? minutes + "m " : "")).trim();
+
+ },
+
+ /**
+ * input: millis
+ * 1 Tag, H:M:S
+ */
+ GERMAN_TIME = value -> {
+
+ DecimalFormat format = new DecimalFormat("00");
+
+ long millis = (long) value;
+ long seconds = millis / 1000;
+ long minutes = seconds / 60;
+ long hours = minutes / 60;
+ long days = hours / 24;
+ seconds %= 60;
+ minutes %= 60;
+ hours %= 24;
+
+ return (days > 0 ? (days == 1 ? "1 Tag " : days + " Tage ") : "")
+ + (hours > 0 ? format.format(hours) + ":" : "")
+ + format.format(minutes) + ":"
+ + format.format(seconds);
+
+ },
+ /**
+ * input: seconds
+ * 1 Tag, H:M:S
+ */
+ FULL_GERMAN_TIME_HOURS = value -> {
+
+ long seconds = (long) (value);
+ long minutes = seconds / 60;
+ long hours = minutes / 60;
+ seconds %= 60;
+ minutes %= 60;
+
+ return hours > 0 ? (hours == 1 ? "1 Stunde" : hours + " Stunden") : (minutes == 1 ? "1 Minute" : minutes + " Minuten");
+ },
+
+ FULL_GERMAN_TIME = value -> {
+
+ long seconds = (long) value;
+ long minutes = seconds / 60;
+ long hours = minutes / 60;
+ long days = hours / 24;
+ long years = days / 365;
+
+ seconds %= 60;
+ minutes %= 60;
+ hours %= 24;
+ days %= 265;
+
+ return ((years > 0 ? (years == 1 ? "1 Jahr " : years + " Jahre ") : "")
+ + (days > 0 ? (days == 1 ? "1 Tag " : days + " Tage ") : "")
+ + (hours > 0 ? (hours == 1 ? "1 Stunde " : hours + " Stunden ") : "")
+ + (minutes > 0 ? (minutes == 1 ? "1 Minute " : minutes + " Minuten ") : "")
+ + (seconds > 0 || years == 0 && hours == 0 && minutes == 0 ? (seconds == 1 ? "1 Sekunde" : seconds + " Sekunden") : "")).trim();
+
+ },
+
+ NORMAL_FULL_GERMAN_TIME = value -> {
+
+ long seconds = (long) value;
+ long minutes = seconds / 60;
+ long hours = minutes / 60;
+ long days = hours / 24;
+ long years = days / 365;
+
+ minutes %= 60;
+ hours %= 24;
+ days %= 265;
+
+ return ((years > 0 ? (years == 1 ? "1 Jahr " : years + " Jahre ") : "")
+ + (days > 0 ? (days == 1 ? "1 Tag " : days + " Tage ") : "")
+ + (hours > 0 ? (hours == 1 ? "1 Stunde " : hours + " Stunden ") : "")
+ + (minutes > 0 || value == 0 ? (minutes == 1 ? "1 Minute " : minutes + " Minuten ") : "")).trim();
+
+ },
+
+ BIG_FULL_GERMAN_TIME = value -> {
+
+ long seconds = (long) value;
+ long minutes = seconds / 60;
+ long hours = minutes / 60;
+ long days = hours / 24;
+ long years = days / 365;
+
+ hours %= 24;
+ days %= 265;
+
+ return ((years > 0 ? (years == 1 ? "1 Jahr " : years + " Jahre ") : "")
+ + (days > 0 ? (days == 1 ? "1 Tag " : days + " Tage ") : "")
+ + (hours > 0 || years == 0 && days == 0 ? (hours == 1 ? "1 Stunde" : hours + " Stunden") : "")).trim();
+
+ },
+
+ /**
+ * billion, million, thousand, number
+ */
+ BIG_NUMBER = value -> {
+
+ DecimalFormat format = new DecimalFormat("0.##");
+ double divide;
+ String ending = "";
+
+ // Normal number
+ if (value < 1000) {
+ divide = 1;
+ format = new DecimalFormat("0.#");
+ // Thousand
+ } else if (value < 1000000) {
+ divide = 1000;
+ ending = "k";
+ // Million
+ } else if (value < 1000000000) {
+ divide = 1000000;
+ ending = "m";
+ // Billion (Milliarde)
+ } else if (value < 1000000000000D) {
+ divide = 1000000000;
+ ending = "b";
+ // Trillion (Billion)
+ } else {
+ divide = 1000000000000D;
+ ending = "t";
+ }
+
+ value /= divide;
+ return format.format(value) + ending;
+
+ },
+
+ /**
+ * input in bytes
+ * kilobyte, megabyte, gigabyte, terrabyte
+ */
+ DATA_SIZE = value -> {
+
+ if (value < 0) value = 0;
+
+ DecimalFormat format = new DecimalFormat("0.##");
+ double divide;
+ String ending;
+
+ // KiloByte
+ if (value < 1000000L) {
+ divide = 1000;
+ format = new DecimalFormat("0.#");
+ ending = "KB";
+ } else if (value < 1000000000L) {
+ // MegaByte
+ divide = 1000000L;
+ ending = "MB";
+ // GigaByte
+ } else if (value < 1000000000000L) {
+ divide = 1000000000L;
+ ending = "GB";
+ // TerraByte
+ } else {
+ divide = 1000000000000L;
+ ending = "TB";
+ }
+
+ value /= divide;
+ return format.format(value) + ending;
+
+ },
+
+ /**
+ * input in bytes
+ * gigabyte, terrabyte, petabyte
+ */
+ BIG_DATA_SIZE = value -> {
+
+ if (value < 0) value = 0;
+
+ DecimalFormat format = new DecimalFormat("0.##");
+ double divide;
+ String ending;
+
+ // GigaByte
+ if (value < 1000000000000L) {
+ divide = 1000000000L;
+ ending = "GB";
+ // TerraByte
+ } else if (value < 1000000000000000L) {
+ divide = 1000000000000L;
+ ending = "TB";
+ // PetaByte
+ } else {
+ divide = 1000000000000000L;
+ ending = "PB";
+ }
+
+ value /= divide;
+ return format.format(value) + ending;
+
+ },
+ ORDINAL = value -> {
+
+ String string = String.valueOf(((long) value));
+ int number = Integer.parseInt(string.substring(string.length() - 1));
+ String ending = "th";
+
+ if (value != 11 && value != 12 && value != 13) {
+ switch (number) {
+ case 1:
+ ending = "st";
+ break;
+ case 2:
+ ending = "nd";
+ break;
+ case 3:
+ ending = "rd";
+ break;
+ }
+ }
+
+ return string + ending;
+
+ },
+ GERMAN_ORDINAL = fromPattern("0", ".", false);
+
+ @Nonnull
+ @CheckReturnValue
+ public static NumberFormatter fromPattern(@Nonnull String pattern, String ending, boolean positive) {
+ return fromPattern(pattern, ending, positive, null);
+ }
+
+ @Nonnull
+ @CheckReturnValue
+ public static NumberFormatter fromPattern(@Nonnull String pattern, String ending, boolean positive, Consumer init) {
+ DecimalFormat format = new DecimalFormat(pattern);
+ if (init != null) init.accept(format);
+ return value -> Double.isNaN(value) ? "NaN" : format.format(positive ? (value > 0 ? value : 0) : value) + (ending != null ? ending : "");
+ }
+
+ @Nonnull
+ @CheckReturnValue
+ public static DecimalFormatSymbols updateSymbols(@Nonnull DecimalFormatSymbols symbols, @Nonnull Consumer action) {
+ action.accept(symbols);
+ return symbols;
+ }
+
+ @CheckReturnValue
+ public static void updateSymbols(@Nonnull DecimalFormat format, @Nonnull Consumer action) {
+ format.setDecimalFormatSymbols(updateSymbols(format.getDecimalFormatSymbols(), action));
+ }
+
+}
diff --git a/plugin/src/main/java/net/codingarea/commons/common/collection/PublicSecurityManager.java b/plugin/src/main/java/net/codingarea/commons/common/collection/PublicSecurityManager.java
new file mode 100644
index 000000000..b561b6bf8
--- /dev/null
+++ b/plugin/src/main/java/net/codingarea/commons/common/collection/PublicSecurityManager.java
@@ -0,0 +1,12 @@
+package net.codingarea.commons.common.collection;
+
+import javax.annotation.Nonnull;
+
+public class PublicSecurityManager extends SecurityManager {
+
+ @Nonnull
+ public Class[] getPublicClassContext() {
+ return getClassContext();
+ }
+
+}
diff --git a/plugin/src/main/java/net/codingarea/commons/common/collection/RandomWrapper.java b/plugin/src/main/java/net/codingarea/commons/common/collection/RandomWrapper.java
new file mode 100644
index 000000000..a845fbc10
--- /dev/null
+++ b/plugin/src/main/java/net/codingarea/commons/common/collection/RandomWrapper.java
@@ -0,0 +1,149 @@
+package net.codingarea.commons.common.collection;
+
+import javax.annotation.Nonnull;
+import java.util.Random;
+import java.util.stream.DoubleStream;
+import java.util.stream.IntStream;
+import java.util.stream.LongStream;
+
+public class RandomWrapper implements IRandom {
+
+ private final Random random;
+
+ public RandomWrapper(@Nonnull Random random) {
+ this.random = random;
+ }
+
+ @Override
+ public long getSeed() {
+ throw new UnsupportedOperationException("Random.getSeed()");
+ }
+
+ @Override
+ public void setSeed(long seed) {
+ random.setSeed(seed);
+ }
+
+ @Override
+ public void nextBytes(@Nonnull byte[] bytes) {
+ random.nextBytes(bytes);
+ }
+
+ @Override
+ public boolean nextBoolean() {
+ return random.nextBoolean();
+ }
+
+ @Override
+ public int nextInt() {
+ return random.nextInt();
+ }
+
+ @Override
+ public int nextInt(int bound) {
+ return random.nextInt(bound);
+ }
+
+ @Nonnull
+ @Override
+ public IntStream ints() {
+ return random.ints();
+ }
+
+ @Nonnull
+ @Override
+ public IntStream ints(long streamSize) {
+ return random.ints(streamSize);
+ }
+
+ @Nonnull
+ @Override
+ public IntStream ints(int randomNumberOrigin, int randomNumberBound) {
+ return random.ints(randomNumberOrigin, randomNumberBound);
+ }
+
+ @Nonnull
+ @Override
+ public IntStream ints(long streamSize, int randomNumberOrigin, int randomNumberBound) {
+ return random.ints(streamSize, randomNumberOrigin, randomNumberBound);
+ }
+
+ @Nonnull
+ @Override
+ public LongStream longs() {
+ return random.longs();
+ }
+
+ @Override
+ public long nextLong() {
+ return random.nextLong();
+ }
+
+ @Nonnull
+ @Override
+ public LongStream longs(long streamSize) {
+ return random.longs(streamSize);
+ }
+
+ @Nonnull
+ @Override
+ public LongStream longs(long randomNumberOrigin, long randomNumberBound) {
+ return random.longs(randomNumberOrigin, randomNumberBound);
+ }
+
+ @Nonnull
+ @Override
+ public LongStream longs(long streamSize, long randomNumberOrigin, long randomNumberBound) {
+ return random.longs(streamSize, randomNumberOrigin, randomNumberBound);
+ }
+
+ @Override
+ public double nextDouble() {
+ return random.nextDouble();
+ }
+
+ @Override
+ public double nextGaussian() {
+ return random.nextGaussian();
+ }
+
+ @Nonnull
+ @Override
+ public DoubleStream doubles() {
+ return random.doubles();
+ }
+
+ @Nonnull
+ @Override
+ public DoubleStream doubles(long streamSize) {
+ return random.doubles(streamSize);
+ }
+
+ @Nonnull
+ @Override
+ public DoubleStream doubles(double randomNumberOrigin, double randomNumberBound) {
+ return random.doubles(randomNumberOrigin, randomNumberBound);
+ }
+
+ @Nonnull
+ @Override
+ public DoubleStream doubles(long streamSize, double randomNumberOrigin, double randomNumberBound) {
+ return random.doubles(streamSize, randomNumberOrigin, randomNumberBound);
+ }
+
+ @Override
+ public float nextFloat() {
+ return random.nextFloat();
+ }
+
+ @Nonnull
+ @Override
+ public Random asRandom() {
+ return random;
+ }
+
+ @Override
+ public String toString() {
+ return "Random[wrapped=" + random.getClass().getSimpleName() + "]";
+ }
+}
diff --git a/plugin/src/main/java/net/codingarea/commons/common/collection/RomanNumerals.java b/plugin/src/main/java/net/codingarea/commons/common/collection/RomanNumerals.java
new file mode 100644
index 000000000..e1401ba5e
--- /dev/null
+++ b/plugin/src/main/java/net/codingarea/commons/common/collection/RomanNumerals.java
@@ -0,0 +1,47 @@
+package net.codingarea.commons.common.collection;
+
+import javax.annotation.Nonnull;
+import java.util.TreeMap;
+
+public final class RomanNumerals {
+
+ public static final class IllegalRomanNumeralException extends IllegalArgumentException {
+
+ private IllegalRomanNumeralException(int number) {
+ super("Number " + number + " out of bounds for 0 to 3999");
+ }
+
+ }
+
+ private static final TreeMap values = new TreeMap<>();
+
+ static {
+ values.put(1000, "M" );
+ values.put(900, "CM");
+ values.put(500, "D" );
+ values.put(400, "CD");
+ values.put(100, "C" );
+ values.put(90, "XC");
+ values.put(50, "L" );
+ values.put(40, "XL");
+ values.put(10, "X" );
+ values.put(9, "IX");
+ values.put(5, "V" );
+ values.put(4, "IV");
+ values.put(1, "I" );
+ }
+
+ private RomanNumerals() {}
+
+ @Nonnull
+ public static String forNumber(int number) {
+ if (number < 0 || number > 3999) throw new IllegalRomanNumeralException(number);
+ if (number == 0) return "";
+ int i = values.floorKey(number);
+ if (number == i) {
+ return values.get(number);
+ }
+ return values.get(i) + forNumber(number - i);
+ }
+
+}
diff --git a/plugin/src/main/java/net/codingarea/commons/common/collection/RunnableTimerTask.java b/plugin/src/main/java/net/codingarea/commons/common/collection/RunnableTimerTask.java
new file mode 100644
index 000000000..540c375f1
--- /dev/null
+++ b/plugin/src/main/java/net/codingarea/commons/common/collection/RunnableTimerTask.java
@@ -0,0 +1,19 @@
+package net.codingarea.commons.common.collection;
+
+import javax.annotation.Nonnull;
+import java.util.TimerTask;
+
+public class RunnableTimerTask extends TimerTask {
+
+ protected final Runnable action;
+
+ public RunnableTimerTask(@Nonnull Runnable action) {
+ this.action = action;
+ }
+
+ @Override
+ public void run() {
+ action.run();
+ }
+
+}
diff --git a/plugin/src/main/java/net/codingarea/commons/common/collection/SeededRandomWrapper.java b/plugin/src/main/java/net/codingarea/commons/common/collection/SeededRandomWrapper.java
new file mode 100644
index 000000000..a9fcb48f2
--- /dev/null
+++ b/plugin/src/main/java/net/codingarea/commons/common/collection/SeededRandomWrapper.java
@@ -0,0 +1,35 @@
+package net.codingarea.commons.common.collection;
+
+import java.util.Random;
+
+/**
+ * Since there is no way of getting the seed of a {@link Random} we create a wrapper
+ * which will save seed. This allows us to save randomization and reload it.
+ */
+public class SeededRandomWrapper extends Random implements IRandom {
+
+ protected long seed;
+
+ public SeededRandomWrapper() {
+ super();
+ }
+
+ public SeededRandomWrapper(long seed) {
+ super(seed);
+ }
+
+ @Override
+ public void setSeed(long seed) {
+ super.setSeed(seed);
+ this.seed = seed;
+ }
+
+ public long getSeed() {
+ return seed;
+ }
+
+ @Override
+ public String toString() {
+ return "Random[seed=" + seed + "]";
+ }
+}
diff --git a/plugin/src/main/java/net/codingarea/commons/common/collection/SingletonRandom.java b/plugin/src/main/java/net/codingarea/commons/common/collection/SingletonRandom.java
new file mode 100644
index 000000000..93a2ce6ed
--- /dev/null
+++ b/plugin/src/main/java/net/codingarea/commons/common/collection/SingletonRandom.java
@@ -0,0 +1,13 @@
+package net.codingarea.commons.common.collection;
+
+import java.util.Random;
+
+public class SingletonRandom extends RandomWrapper {
+
+ public static final SingletonRandom INSTANCE = new SingletonRandom();
+
+ private SingletonRandom() {
+ super(new Random());
+ }
+
+}
diff --git a/plugin/src/main/java/net/codingarea/commons/common/collection/StringBuilderPrintWriter.java b/plugin/src/main/java/net/codingarea/commons/common/collection/StringBuilderPrintWriter.java
new file mode 100644
index 000000000..2d0e45d21
--- /dev/null
+++ b/plugin/src/main/java/net/codingarea/commons/common/collection/StringBuilderPrintWriter.java
@@ -0,0 +1,28 @@
+package net.codingarea.commons.common.collection;
+
+import javax.annotation.Nonnull;
+import java.io.PrintWriter;
+
+/**
+ * @author org.apache.commons.io
+ */
+public class StringBuilderPrintWriter extends PrintWriter {
+
+ protected final StringBuilderWriter writer;
+
+ public StringBuilderPrintWriter() {
+ super(new StringBuilderWriter());
+ writer = (StringBuilderWriter) out;
+ }
+
+ @Nonnull
+ public StringBuilder getBuilder() {
+ return writer.getBuilder();
+ }
+
+ @Override
+ public String toString() {
+ return getBuilder().toString();
+ }
+
+}
diff --git a/plugin/src/main/java/net/codingarea/commons/common/collection/StringBuilderWriter.java b/plugin/src/main/java/net/codingarea/commons/common/collection/StringBuilderWriter.java
new file mode 100644
index 000000000..5ad40651c
--- /dev/null
+++ b/plugin/src/main/java/net/codingarea/commons/common/collection/StringBuilderWriter.java
@@ -0,0 +1,68 @@
+package net.codingarea.commons.common.collection;
+
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+import java.io.Writer;
+
+/**
+ * @author org.apache.commons.io
+ */
+public class StringBuilderWriter extends Writer {
+
+ private final StringBuilder builder;
+
+ public StringBuilderWriter() {
+ this.builder = new StringBuilder();
+ }
+
+ public StringBuilderWriter(int capacity) {
+ this.builder = new StringBuilder(capacity);
+ }
+
+ public StringBuilderWriter(@Nullable StringBuilder builder) {
+ this.builder = builder != null ? builder : new StringBuilder();
+ }
+
+ public Writer append(char value) {
+ builder.append(value);
+ return this;
+ }
+
+ public Writer append(@Nullable CharSequence value) {
+ builder.append(value);
+ return this;
+ }
+
+ public Writer append(@Nullable CharSequence value, int start, int end) {
+ builder.append(value, start, end);
+ return this;
+ }
+
+ public void close() {
+ }
+
+ public void flush() {
+ }
+
+ public void write(@Nonnull String value) {
+ builder.append(value);
+ }
+
+ public void write(@Nullable char[] value, int offset, int length) {
+ if (value != null) {
+ builder.append(value, offset, length);
+ }
+ }
+
+ @Nonnull
+ public StringBuilder getBuilder() {
+ return this.builder;
+ }
+
+ @Override
+ public String toString() {
+ return this.builder.toString();
+ }
+
+}
+
diff --git a/plugin/src/main/java/net/codingarea/commons/common/collection/Triple.java b/plugin/src/main/java/net/codingarea/commons/common/collection/Triple.java
new file mode 100644
index 000000000..b480031d2
--- /dev/null
+++ b/plugin/src/main/java/net/codingarea/commons/common/collection/Triple.java
@@ -0,0 +1,20 @@
+package net.codingarea.commons.common.collection;
+
+import javax.annotation.Nullable;
+
+/**
+ * @param The type of the first value
+ * @param The type of the second value
+ * @param The type of the third value
+ */
+@Deprecated
+public class Triple extends net.codingarea.commons.common.collection.pair.Triple {
+
+ public Triple() {
+ }
+
+ public Triple(@Nullable F first, @Nullable S second, @Nullable T third) {
+ super(first, second, third);
+ }
+
+}
diff --git a/plugin/src/main/java/net/codingarea/commons/common/collection/Tuple.java b/plugin/src/main/java/net/codingarea/commons/common/collection/Tuple.java
new file mode 100644
index 000000000..8e9077907
--- /dev/null
+++ b/plugin/src/main/java/net/codingarea/commons/common/collection/Tuple.java
@@ -0,0 +1,19 @@
+package net.codingarea.commons.common.collection;
+
+import javax.annotation.Nullable;
+
+/**
+ * @param The type of the first value
+ * @param The type of the second value
+ */
+@Deprecated
+public class Tuple extends net.codingarea.commons.common.collection.pair.Tuple {
+
+ public Tuple() {
+ }
+
+ public Tuple(@Nullable F first, @Nullable S second) {
+ super(first, second);
+ }
+
+}
diff --git a/plugin/src/main/java/net/codingarea/commons/common/collection/WrappedException.java b/plugin/src/main/java/net/codingarea/commons/common/collection/WrappedException.java
new file mode 100644
index 000000000..1e8999988
--- /dev/null
+++ b/plugin/src/main/java/net/codingarea/commons/common/collection/WrappedException.java
@@ -0,0 +1,61 @@
+package net.codingarea.commons.common.collection;
+
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+
+/**
+ * This class is used to rethrow signed exception as unsigned exceptions.
+ */
+public class WrappedException extends RuntimeException {
+
+ public static class SilentWrappedException extends WrappedException {
+
+ public SilentWrappedException(@Nullable String message, @Nonnull Throwable cause) {
+ super(message, cause);
+ }
+
+ public SilentWrappedException(@Nonnull Throwable cause) {
+ super(cause);
+ }
+
+ @Override
+ public synchronized Throwable fillInStackTrace() {
+ return this;
+ }
+
+ }
+
+ public WrappedException(@Nullable String message, @Nonnull Throwable cause) {
+ super(message, cause);
+ }
+
+ public WrappedException(@Nonnull Throwable cause) {
+ super(cause);
+ }
+
+ @Nonnull
+ @Override
+ public Throwable getCause() {
+ return super.getCause();
+ }
+
+ @Nonnull
+ public static RuntimeException rethrow(@Nonnull Throwable ex) {
+ if (ex instanceof Error)
+ throw (Error) ex;
+ if (ex instanceof RuntimeException)
+ throw (RuntimeException) ex;
+ throw silent(ex);
+ }
+
+ @Nonnull
+ public static WrappedException silent(@Nonnull Throwable cause) {
+ return new SilentWrappedException(cause);
+ }
+
+ @Nonnull
+ public static WrappedException silent(@Nullable String message, @Nonnull Throwable cause) {
+ return new SilentWrappedException(message, cause);
+ }
+
+}
diff --git a/plugin/src/main/java/net/codingarea/commons/common/collection/pair/Pair.java b/plugin/src/main/java/net/codingarea/commons/common/collection/pair/Pair.java
new file mode 100644
index 000000000..bb4c23a4a
--- /dev/null
+++ b/plugin/src/main/java/net/codingarea/commons/common/collection/pair/Pair.java
@@ -0,0 +1,32 @@
+package net.codingarea.commons.common.collection.pair;
+
+import javax.annotation.Nonnegative;
+import javax.annotation.Nonnull;
+
+/**
+ * @see Tuple
+ * @see Triple
+ * @see Quadro
+ */
+public interface Pair {
+
+ /**
+ * @return The amount of values
+ */
+ @Nonnegative
+ int amount();
+
+ @Nonnull
+ Object[] values();
+
+ /**
+ * @return {@code true} when all of the values are null, {@code false} otherwise
+ */
+ boolean allNull();
+
+ /**
+ * @return {@code true} when none of the values are null, {@code false} otherwise
+ */
+ boolean noneNull();
+
+}
diff --git a/plugin/src/main/java/net/codingarea/commons/common/collection/pair/Quadro.java b/plugin/src/main/java/net/codingarea/commons/common/collection/pair/Quadro.java
new file mode 100644
index 000000000..df07b890d
--- /dev/null
+++ b/plugin/src/main/java/net/codingarea/commons/common/collection/pair/Quadro.java
@@ -0,0 +1,139 @@
+package net.codingarea.commons.common.collection.pair;
+
+import javax.annotation.CheckReturnValue;
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+import java.util.Objects;
+import java.util.function.Function;
+
+/**
+ * @param The type of the first value
+ * @param The type of the second value
+ * @param The type of the third value
+ * @param The type of the fourth value
+ */
+public class Quadro implements Pair {
+
+ protected F first;
+ protected S second;
+ protected T third;
+ protected FF fourth;
+
+ public Quadro() {
+ }
+
+ public Quadro(@Nullable F first, @Nullable S second, @Nullable T third, @Nullable FF fourth) {
+ this.first = first;
+ this.second = second;
+ this.third = third;
+ this.fourth = fourth;
+ }
+
+ @Override
+ public final int amount() {
+ return 4;
+ }
+
+ @Nonnull
+ @Override
+ public final Object[] values() {
+ return new Object[] { first, second, third, first };
+ }
+
+ public F getFirst() {
+ return first;
+ }
+
+ public S getSecond() {
+ return second;
+ }
+
+ public T getThird() {
+ return third;
+ }
+
+ public FF getFourth() {
+ return fourth;
+ }
+
+ public void setFirst(@Nullable F first) {
+ this.first = first;
+ }
+
+ public void setSecond(@Nullable S second) {
+ this.second = second;
+ }
+
+ public void setThird(@Nullable T third) {
+ this.third = third;
+ }
+
+ public void setFourth(@Nullable FF fourth) {
+ this.fourth = fourth;
+ }
+
+ @Nonnull
+ @CheckReturnValue
+ public Quadro map(@Nonnull Function firstMapper,
+ @Nonnull Function secondMapper,
+ @Nonnull Function thirdMapper,
+ @Nonnull Function fourthMapper) {
+ return of(firstMapper.apply(first), secondMapper.apply(second), thirdMapper.apply(third), fourthMapper.apply(fourth));
+ }
+
+ public boolean noneNull() {
+ return first != null && second != null && third != null && fourth != null;
+ }
+
+ public boolean allNull() {
+ return first == null && second == null && third == null && fourth != null;
+ }
+
+ @Override
+ public boolean equals(Object o) {
+ if (this == o) return true;
+ if (o == null || getClass() != o.getClass()) return false;
+ Quadro quadro = (Quadro) o;
+ return Objects.equals(first, quadro.first) && Objects.equals(second, quadro.second) && Objects.equals(third, quadro.third) && Objects.equals(fourth, quadro.fourth);
+ }
+
+ @Override
+ public int hashCode() {
+ return Objects.hash(first, second, third, fourth);
+ }
+
+ @Override
+ public String toString() {
+ return "Quadro[" + first + ", " + second + ", " + third + ", " + fourth + "]";
+ }
+
+ @Nonnull
+ public static Quadro ofFirst(@Nullable F first) {
+ return of(first, null, null, null);
+ }
+
+ @Nonnull
+ public static Quadro ofSecond(@Nullable S second) {
+ return of(null, second, null, null);
+ }
+
+ @Nonnull
+ public static Quadro ofThird(@Nullable T third) {
+ return of(null, null, third, null);
+ }
+
+ @Nonnull
+ public static Quadro ofFourth(@Nullable FF fourth) {
+ return of(null, null, null, fourth);
+ }
+
+ @Nonnull
+ public static Quadro of(@Nullable F first, @Nullable S second, @Nullable T third, @Nullable FF fourth) {
+ return new Quadro<>(first, second, third, fourth);
+ }
+
+ @Nonnull
+ public static Quadro empty() {
+ return new Quadro<>();
+ }
+}
diff --git a/plugin/src/main/java/net/codingarea/commons/common/collection/pair/Triple.java b/plugin/src/main/java/net/codingarea/commons/common/collection/pair/Triple.java
new file mode 100644
index 000000000..48c8dfcde
--- /dev/null
+++ b/plugin/src/main/java/net/codingarea/commons/common/collection/pair/Triple.java
@@ -0,0 +1,123 @@
+package net.codingarea.commons.common.collection.pair;
+
+import javax.annotation.CheckReturnValue;
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+import java.util.Objects;
+import java.util.function.Function;
+
+/**
+ * @param The type of the first value
+ * @param The type of the second value
+ * @param The type of the third value
+ */
+public class Triple implements Pair {
+
+ protected F first;
+ protected S second;
+ protected T third;
+
+ public Triple() {
+ }
+
+ public Triple(@Nullable F first, @Nullable S second, @Nullable T third) {
+ this.first = first;
+ this.second = second;
+ this.third = third;
+ }
+
+ @Override
+ public final int amount() {
+ return 3;
+ }
+
+ @Nonnull
+ @Override
+ public final Object[] values() {
+ return new Object[] { first, second, third };
+ }
+
+ public F getFirst() {
+ return first;
+ }
+
+ public S getSecond() {
+ return second;
+ }
+
+ public T getThird() {
+ return third;
+ }
+
+ public void setFirst(@Nullable F first) {
+ this.first = first;
+ }
+
+ public void setSecond(@Nullable S second) {
+ this.second = second;
+ }
+
+ public void setThird(@Nullable T third) {
+ this.third = third;
+ }
+
+ @Nonnull
+ @CheckReturnValue
+ public Triple map(@Nonnull Function firstMapper,
+ @Nonnull Function secondMapper,
+ @Nonnull Function thirdMapper) {
+ return of(firstMapper.apply(first), secondMapper.apply(second), thirdMapper.apply(third));
+ }
+
+ public boolean noneNull() {
+ return first != null && second != null && third != null;
+ }
+
+ public boolean allNull() {
+ return first == null && second == null && third == null;
+ }
+
+ @Override
+ public boolean equals(Object o) {
+ if (this == o) return true;
+ if (o == null || getClass() != o.getClass()) return false;
+ Triple triple = (Triple) o;
+ return Objects.equals(first, triple.first) && Objects.equals(second, triple.second) && Objects.equals(third, triple.third);
+ }
+
+ @Override
+ public int hashCode() {
+ return Objects.hash(first, second, third);
+ }
+
+ @Override
+ public String toString() {
+ return "Triple[" + first + ", " + second + ", " + third + "]";
+ }
+
+ @Nonnull
+ public static Triple ofFirst(@Nullable F first) {
+ return of(first, null, null);
+ }
+
+ @Nonnull
+ public static Triple ofSecond(@Nullable S second) {
+ return of(null, second, null);
+ }
+
+ @Nonnull
+ public static Triple ofThird(@Nullable T third) {
+ return of(null, null, third);
+ }
+
+ @Nonnull
+ public static Triple of(@Nullable F first, @Nullable S second, @Nullable T third) {
+ return new Triple<>(first, second, third);
+ }
+
+ @Nonnull
+ public static Triple empty() {
+ return new Triple<>();
+ }
+
+}
diff --git a/plugin/src/main/java/net/codingarea/commons/common/collection/pair/Tuple.java b/plugin/src/main/java/net/codingarea/commons/common/collection/pair/Tuple.java
new file mode 100644
index 000000000..9d320ba6e
--- /dev/null
+++ b/plugin/src/main/java/net/codingarea/commons/common/collection/pair/Tuple.java
@@ -0,0 +1,106 @@
+package net.codingarea.commons.common.collection.pair;
+
+import javax.annotation.CheckReturnValue;
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+import java.util.Objects;
+import java.util.function.Function;
+
+/**
+ * @param The type of the first value
+ * @param The type of the second value
+ */
+public class Tuple implements Pair {
+
+ protected F first;
+ protected S second;
+
+ public Tuple() {
+ }
+
+ public Tuple(@Nullable F first, @Nullable S second) {
+ this.first = first;
+ this.second = second;
+ }
+
+ @Override
+ public final int amount() {
+ return 2;
+ }
+
+ @Nonnull
+ @Override
+ public final Object[] values() {
+ return new Object[] { first, second };
+ }
+
+ public F getFirst() {
+ return first;
+ }
+
+ public S getSecond() {
+ return second;
+ }
+
+ public void setFirst(@Nullable F first) {
+ this.first = first;
+ }
+
+ public void setSecond(@Nullable S second) {
+ this.second = second;
+ }
+
+ @Nonnull
+ @CheckReturnValue
+ public Tuple map(@Nonnull Function firstMapper,
+ @Nonnull Function secondMapper) {
+ return of(firstMapper.apply(first), secondMapper.apply(second));
+ }
+
+ public boolean noneNull() {
+ return first != null && second != null;
+ }
+
+ public boolean allNull() {
+ return first == null && second == null;
+ }
+
+ @Override
+ public boolean equals(Object o) {
+ if (this == o) return true;
+ if (o == null || getClass() != o.getClass()) return false;
+ Tuple tuple = (Tuple) o;
+ return Objects.equals(first, tuple.first) && Objects.equals(second, tuple.second);
+ }
+
+ @Override
+ public int hashCode() {
+ return Objects.hash(first, second);
+ }
+
+ @Override
+ public String toString() {
+ return "Tuple[" + first + ", " + second + "]";
+ }
+
+ @Nonnull
+ public static Tuple ofFirst(@Nullable F frist) {
+ return new Tuple<>(frist, null);
+ }
+
+ @Nonnull
+ public static Tuple ofSecond(@Nullable S second) {
+ return new Tuple<>(null, second);
+ }
+
+ @Nonnull
+ public static Tuple of(@Nullable F first, @Nullable S second) {
+ return new Tuple<>(first, second);
+ }
+
+ @Nonnull
+ public static Tuple empty() {
+ return new Tuple<>();
+ }
+
+}
diff --git a/plugin/src/main/java/net/codingarea/commons/common/concurrent/cache/CleanAndWriteDatabaseCache.java b/plugin/src/main/java/net/codingarea/commons/common/concurrent/cache/CleanAndWriteDatabaseCache.java
new file mode 100644
index 000000000..87bf70c77
--- /dev/null
+++ b/plugin/src/main/java/net/codingarea/commons/common/concurrent/cache/CleanAndWriteDatabaseCache.java
@@ -0,0 +1,118 @@
+package net.codingarea.commons.common.concurrent.cache;
+
+import net.codingarea.commons.common.annotations.ReplaceWith;
+import net.codingarea.commons.common.collection.pair.Tuple;
+import net.codingarea.commons.common.logging.ILogger;
+import net.codingarea.commons.common.misc.SimpleCollectionUtils;
+
+import javax.annotation.Nonnegative;
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.TimeUnit;
+import java.util.function.BiConsumer;
+import java.util.function.Function;
+import java.util.function.Predicate;
+
+@Deprecated
+@ReplaceWith("com.google.common.cache.LoadingCache")
+public class CleanAndWriteDatabaseCache implements DatabaseCache {
+
+ protected final Map> cache = new ConcurrentHashMap<>();
+ protected final Predicate check;
+ protected final Function query;
+ protected final Function fallback;
+ protected final BiConsumer writer;
+ protected final long unusedTimeBeforeClean;
+ protected final long cleanAndWriteInterval;
+ protected final ILogger logger;
+
+ public CleanAndWriteDatabaseCache(@Nullable ILogger logger, @Nonnegative long unusedTimeBeforeClean, @Nonnegative long cleanAndWriteInterval, @Nonnull String taskName,
+ @Nonnull Predicate check, @Nonnull Function fallback,
+ @Nonnull Function query, @Nonnull BiConsumer writer) {
+ this.logger = logger;
+ this.unusedTimeBeforeClean = unusedTimeBeforeClean;
+ this.cleanAndWriteInterval = cleanAndWriteInterval;
+ this.check = check;
+ this.query = query;
+ this.fallback = fallback;
+ this.writer = writer;
+
+ EXECUTOR.scheduleAtFixedRate(this::writeCache, cleanAndWriteInterval, cleanAndWriteInterval, TimeUnit.MILLISECONDS);
+ Runtime.getRuntime().addShutdownHook(new Thread(this::writeCache));
+ }
+
+ public void writeCache() {
+ if (logger != null ) logger.debug("Writing & Cleaning cache");
+ cleanAndWrite(cache, unusedTimeBeforeClean, logger, check, writer);
+ }
+
+ @Nonnull
+ @Override
+ public V getData(@Nonnull K key) {
+ Tuple cached = cache.get(key);
+ if (cached != null) {
+ cached.setFirst(System.currentTimeMillis());
+ return cached.getSecond();
+ }
+
+ try {
+ V data = query.apply(key);
+ if (logger != null ) logger.trace("Queried data {} for {}", data, key);
+ cache.put(key, new Tuple<>(System.currentTimeMillis(), data));
+ return data;
+ } catch (Exception ex) {
+ if (logger != null ) logger.error("Could not get data for {}", key, ex);
+ return fallback.apply(key);
+ }
+ }
+
+ @Override
+ public boolean contains(@Nonnull K key) {
+ return cache.containsKey(key);
+ }
+
+ @Override
+ public int size() {
+ return cache.size();
+ }
+
+ @Override
+ public void clear() {
+ cache.clear();
+ }
+
+ public static void cleanAndWrite(@Nonnull Map> cache, @Nonnegative long unusedTimeBeforeClean, @Nullable ILogger logger,
+ @Nonnull Predicate check, @Nonnull BiConsumer writer) {
+ long now = System.currentTimeMillis();
+ Collection remove = new ArrayList<>();
+ cache.forEach((key, pair) -> {
+ try {
+ if (now - pair.getFirst() > unusedTimeBeforeClean) {
+ if (logger != null ) logger.trace("Removing {} from cache, last usage was {}s ago", key, (now - pair.getFirst()) / 1000);
+ remove.add(key);
+ }
+
+ V value = pair.getSecond();
+ if (!check.test(value)) return;
+
+ if (logger != null ) logger.trace("Writing {}", value);
+ writer.accept(key, value);
+ } catch (Exception ex) {
+ if (logger != null ) logger.error("Unable to write cache for {}", key, ex);
+ }
+ });
+ remove.forEach(cache::remove);
+ }
+
+ @Nonnull
+ @Override
+ public Map values() {
+ return Collections.unmodifiableMap(SimpleCollectionUtils.convertMap(cache, k -> k, Tuple::getSecond));
+ }
+
+}
diff --git a/plugin/src/main/java/net/codingarea/commons/common/concurrent/cache/CleanWriteableCache.java b/plugin/src/main/java/net/codingarea/commons/common/concurrent/cache/CleanWriteableCache.java
new file mode 100644
index 000000000..6cf0779c6
--- /dev/null
+++ b/plugin/src/main/java/net/codingarea/commons/common/concurrent/cache/CleanWriteableCache.java
@@ -0,0 +1,83 @@
+package net.codingarea.commons.common.concurrent.cache;
+
+import net.codingarea.commons.common.annotations.ReplaceWith;
+import net.codingarea.commons.common.collection.pair.Tuple;
+import net.codingarea.commons.common.logging.ILogger;
+import net.codingarea.commons.common.misc.SimpleCollectionUtils;
+
+import javax.annotation.Nonnegative;
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.TimeUnit;
+
+@Deprecated
+@ReplaceWith("com.google.common.cache.Cache")
+public class CleanWriteableCache implements WriteableCache {
+
+ protected final Map> cache = new ConcurrentHashMap<>();
+ protected final ILogger logger;
+ protected final long cleanInterval;
+ protected final long unusedTimeBeforeClean;
+
+ public CleanWriteableCache(@Nullable ILogger logger, @Nonnegative long unusedTimeBeforeClean, @Nonnegative long cleanInterval, @Nonnull String taskName) {
+ this.logger = logger;
+ this.cleanInterval = cleanInterval;
+ this.unusedTimeBeforeClean = unusedTimeBeforeClean;
+
+ EXECUTOR.scheduleAtFixedRate(this::cleanCache, cleanInterval, cleanInterval, TimeUnit.MILLISECONDS);
+ }
+
+ public void cleanCache() {
+ if (logger != null ) logger.debug("Cleaning cache");
+ long now = System.currentTimeMillis();
+ Collection remove = new ArrayList<>();
+ cache.forEach((key, pair) -> {
+ if (now - pair.getFirst() > unusedTimeBeforeClean) {
+ if (logger != null ) logger.trace("Removing {} from cache, last usage was {}s ago", key, (now - pair.getFirst()) / 1000);
+ remove.add(key);
+ }
+ });
+ remove.forEach(cache::remove);
+ }
+
+ @Nullable
+ @Override
+ public V getData(@Nonnull K key) {
+ Tuple pair = cache.get(key);
+ if (pair == null) return null;
+ pair.setFirst(System.currentTimeMillis());
+ return pair.getSecond();
+ }
+
+ @Override
+ public void setData(@Nonnull K key, @Nullable V value) {
+ cache.put(key, new Tuple<>(System.currentTimeMillis(), value));
+ }
+
+ @Override
+ public boolean contains(@Nonnull K key) {
+ return cache.containsKey(key);
+ }
+
+ @Override
+ public int size() {
+ return cache.size();
+ }
+
+ @Override
+ public void clear() {
+ cache.clear();
+ }
+
+ @Nonnull
+ @Override
+ public Map values() {
+ return Collections.unmodifiableMap(SimpleCollectionUtils.convertMap(cache, k -> k, Tuple::getSecond));
+ }
+
+}
diff --git a/plugin/src/main/java/net/codingarea/commons/common/concurrent/cache/CoolDownCache.java b/plugin/src/main/java/net/codingarea/commons/common/concurrent/cache/CoolDownCache.java
new file mode 100644
index 000000000..1279ae1f5
--- /dev/null
+++ b/plugin/src/main/java/net/codingarea/commons/common/concurrent/cache/CoolDownCache.java
@@ -0,0 +1,83 @@
+package net.codingarea.commons.common.concurrent.cache;
+
+import net.codingarea.commons.common.collection.RunnableTimerTask;
+import net.codingarea.commons.common.logging.ILogger;
+
+import javax.annotation.Nonnegative;
+import javax.annotation.Nonnull;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Map;
+import java.util.Timer;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.function.ToLongFunction;
+
+public class CoolDownCache {
+
+ protected final Map cache = new ConcurrentHashMap<>();
+ protected final ILogger logger;
+ protected final ToLongFunction cooldownTime;
+ protected final long cleanInterval;
+
+ public CoolDownCache(@Nonnull ILogger logger, @Nonnegative long cleanInterval, @Nonnull String taskName, @Nonnull ToLongFunction cooldownTime) {
+ this.logger = logger;
+ this.cooldownTime = cooldownTime;
+ this.cleanInterval = cleanInterval;
+
+ new Timer(taskName).schedule(new RunnableTimerTask(this::cleanCache), cleanInterval, cleanInterval);
+ }
+
+ public void cleanCache() {
+ logger.debug("Cleaning cooldown cache");
+
+ long now = System.currentTimeMillis();
+ Collection remove = new ArrayList<>();
+ cache.forEach((key, time) -> {
+ if (time == null || !isOnCoolDown(now, time, key)) {
+ logger.trace("Removing {} from cooldown cache", key);
+ remove.add(key);
+ }
+ });
+ remove.forEach(cache::remove);
+ }
+
+ public boolean isOnCoolDown(long now, long suspect, @Nonnull K key) {
+ long difference = now - suspect;
+ return difference < getCoolDownTime(key);
+ }
+
+ public boolean isOnCoolDown(@Nonnull K key) {
+ Long time = cache.get(key);
+ if (time == null) return false;
+ return isOnCoolDown(System.currentTimeMillis(), time, key);
+ }
+
+ public boolean checkCoolDown(@Nonnull K key) {
+ boolean cooldown = isOnCoolDown(key);
+ if (!cooldown) setOnCoolDown(key);
+ return cooldown;
+ }
+
+ public void setOnCoolDown(@Nonnull K key) {
+ cache.put(key, System.currentTimeMillis());
+ }
+
+ public long getCoolDown(@Nonnull K key) {
+ Long time = cache.get(key);
+ if (time == null) return 0;
+ return System.currentTimeMillis() - time;
+ }
+
+ public float getCoolDownSeconds(@Nonnull K key) {
+ return getCoolDown(key) / 1000f;
+ }
+
+ public long getCoolDownTime(@Nonnull K key) {
+ return cooldownTime.applyAsLong(key);
+ }
+
+ public int size() {
+ return cache.size();
+ }
+
+}
diff --git a/plugin/src/main/java/net/codingarea/commons/common/concurrent/cache/DatabaseCache.java b/plugin/src/main/java/net/codingarea/commons/common/concurrent/cache/DatabaseCache.java
new file mode 100644
index 000000000..5afc4e461
--- /dev/null
+++ b/plugin/src/main/java/net/codingarea/commons/common/concurrent/cache/DatabaseCache.java
@@ -0,0 +1,19 @@
+package net.codingarea.commons.common.concurrent.cache;
+
+import net.codingarea.commons.common.annotations.ReplaceWith;
+
+import javax.annotation.Nonnull;
+
+/**
+ * @deprecated Use {@link com.google.common.cache.LoadingCache} instead
+ *
+ * @see com.google.common.cache.LoadingCache
+ */
+@Deprecated
+@ReplaceWith("com.google.common.cache.LoadingCache")
+public interface DatabaseCache extends ICache {
+
+ @Nonnull
+ V getData(@Nonnull K key);
+
+}
diff --git a/plugin/src/main/java/net/codingarea/commons/common/concurrent/cache/ICache.java b/plugin/src/main/java/net/codingarea/commons/common/concurrent/cache/ICache.java
new file mode 100644
index 000000000..4a6b49f7f
--- /dev/null
+++ b/plugin/src/main/java/net/codingarea/commons/common/concurrent/cache/ICache.java
@@ -0,0 +1,40 @@
+package net.codingarea.commons.common.concurrent.cache;
+
+import net.codingarea.commons.common.annotations.ReplaceWith;
+import net.codingarea.commons.common.collection.NamedThreadFactory;
+
+import javax.annotation.Nonnull;
+import java.util.Map;
+import java.util.concurrent.Executors;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.function.BiConsumer;
+
+/**
+ * @deprecated Use {@link com.google.common.cache.Cache} instead
+ *
+ * @see com.google.common.cache.Cache
+ */
+@Deprecated
+@ReplaceWith("com.google.common.cache.Cache")
+public interface ICache {
+
+ ScheduledExecutorService EXECUTOR = Executors.newScheduledThreadPool(2, new NamedThreadFactory(threadId -> String.format("CacheTask-%s", threadId)));
+
+ boolean contains(@Nonnull K key);
+
+ int size();
+
+ default boolean isEmpty() {
+ return size() == 0;
+ }
+
+ void clear();
+
+ @Nonnull
+ Map values();
+
+ default void forEach(@Nonnull BiConsumer action) {
+ values().forEach(action);
+ }
+
+}
diff --git a/plugin/src/main/java/net/codingarea/commons/common/concurrent/cache/WriteableCache.java b/plugin/src/main/java/net/codingarea/commons/common/concurrent/cache/WriteableCache.java
new file mode 100644
index 000000000..a2c887e25
--- /dev/null
+++ b/plugin/src/main/java/net/codingarea/commons/common/concurrent/cache/WriteableCache.java
@@ -0,0 +1,17 @@
+package net.codingarea.commons.common.concurrent.cache;
+
+import net.codingarea.commons.common.annotations.ReplaceWith;
+
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+
+@Deprecated
+@ReplaceWith("com.google.common.cache.Cache")
+public interface WriteableCache extends ICache {
+
+ @Nullable
+ V getData(@Nonnull K key);
+
+ void setData(@Nonnull K key, @Nullable V value);
+
+}
diff --git a/plugin/src/main/java/net/codingarea/commons/common/concurrent/task/CompletableTask.java b/plugin/src/main/java/net/codingarea/commons/common/concurrent/task/CompletableTask.java
new file mode 100644
index 000000000..37b71703f
--- /dev/null
+++ b/plugin/src/main/java/net/codingarea/commons/common/concurrent/task/CompletableTask.java
@@ -0,0 +1,169 @@
+package net.codingarea.commons.common.concurrent.task;
+
+import net.codingarea.commons.common.collection.NamedThreadFactory;
+
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.concurrent.*;
+import java.util.function.Function;
+
+public class CompletableTask implements Task {
+
+ static final ExecutorService SERVICE = Executors.newCachedThreadPool(new NamedThreadFactory("TaskProcessor"));
+
+ private final Collection> listeners = new ArrayList<>();
+ private final CompletableFuture future;
+
+ private Throwable failure;
+
+ public CompletableTask() {
+ this(new CompletableFuture<>());
+ }
+
+ private CompletableTask(@Nonnull CompletableFuture future) {
+ this.future = future;
+ this.future.exceptionally(ex -> {
+ this.failure = ex;
+ return null;
+ });
+ }
+
+ @Nonnull
+ public static Task callAsync(@Nonnull Callable callable) {
+ CompletableTask task = new CompletableTask<>();
+ SERVICE.execute(() -> {
+ try {
+ task.complete(callable.call());
+ } catch (Throwable ex) {
+ task.fail(ex);
+ }
+ });
+ return task;
+ }
+
+ @Nonnull
+ public static Task callSync(@Nonnull Callable callable) {
+ CompletableTask task = new CompletableTask<>();
+ try {
+ task.complete(callable.call());
+ } catch (Throwable ex) {
+ task.fail(ex);
+ }
+ return task;
+ }
+
+ @Nonnull
+ @Override
+ public Task addListener(@Nonnull TaskListener listener) {
+ if (future.isDone()) {
+ V value = future.getNow(null);
+ if (future.isCancelled() || value != null) {
+ listener.onCancelled(this);
+ } else if (failure != null) {
+ listener.onFailure(this, failure);
+ } else {
+ listener.onComplete(this, value);
+ }
+ return this;
+ }
+
+ listeners.add(listener);
+ return this;
+ }
+
+ @Nonnull
+ @Override
+ public Task clearListeners() {
+ this.listeners.clear();
+ return this;
+ }
+
+ public void fail(Throwable throwable) {
+ this.failure = throwable;
+ this.future.completeExceptionally(throwable);
+ for (TaskListener listener : this.listeners) {
+ listener.onFailure(this, throwable);
+ }
+ }
+
+ @Override
+ public V call() {
+ if (this.future.isDone()) {
+ return this.future.getNow(null);
+ }
+ throw new UnsupportedOperationException("Use #complete in the CompletableTask");
+ }
+
+ public void complete(@Nullable V value) {
+ future.complete(value);
+ if (value != null) {
+ for (TaskListener listener : listeners) {
+ listener.onComplete(this, value);
+ }
+ } else {
+ for (TaskListener listener : listeners) {
+ listener.onCancelled(this);
+ }
+ }
+
+ }
+
+ @Override
+ public boolean cancel(boolean b) {
+ if (this.future.isCancelled()) {
+ return false;
+ }
+
+ if (this.future.cancel(b)) {
+ for (TaskListener listener : this.listeners) {
+ listener.onCancelled(this);
+ }
+ return true;
+ }
+ return false;
+ }
+
+ @Override
+ public boolean isCancelled() {
+ return this.future.isCancelled();
+ }
+
+ @Override
+ public boolean isDone() {
+ return this.future.isDone();
+ }
+
+ @Override
+ public V get() throws InterruptedException, ExecutionException {
+ return future.get();
+ }
+
+ @Override
+ public V get(long timeout, @Nonnull TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException {
+ return future.get(timeout, unit);
+ }
+
+ @Nonnull
+ @Override
+ public Task map(@Nullable Function mapper) {
+ CompletableTask task = new CompletableTask<>();
+ this.future.thenAccept(v -> {
+ try {
+ task.complete(mapper == null ? null : mapper.apply(v));
+ } catch (Throwable ex) {
+ task.fail(ex);
+ }
+ });
+ this.onFailure(task.future::completeExceptionally);
+ this.onCancelled(otherTask -> task.cancel(true));
+ return task;
+ }
+
+ @Nonnull
+ @Override
+ public CompletionStage stage() {
+ return future;
+ }
+}
diff --git a/plugin/src/main/java/net/codingarea/commons/common/concurrent/task/CompletedTask.java b/plugin/src/main/java/net/codingarea/commons/common/concurrent/task/CompletedTask.java
new file mode 100644
index 000000000..aed5684ba
--- /dev/null
+++ b/plugin/src/main/java/net/codingarea/commons/common/concurrent/task/CompletedTask.java
@@ -0,0 +1,108 @@
+package net.codingarea.commons.common.concurrent.task;
+
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+import java.util.concurrent.*;
+import java.util.function.Function;
+
+public class CompletedTask implements Task {
+
+ private final V value;
+ private final Throwable failure;
+
+ private CompletableFuture future;
+
+ public CompletedTask(@Nullable V value) {
+ this.value = value;
+ this.failure = null;
+ }
+
+ public CompletedTask(@Nullable Throwable failure) {
+ this.value = null;
+ this.failure = failure;
+ }
+
+ @Nonnull
+ @Override
+ public Task addListener(@Nonnull TaskListener listener) {
+ if (failure != null) {
+ listener.onFailure(this, failure);
+ } else if (value != null) {
+ listener.onComplete(this, value);
+ } else {
+ listener.onCancelled(this);
+ }
+
+ return this;
+ }
+
+ @Nonnull
+ @Override
+ public Task clearListeners() {
+ return this;
+ }
+
+ @Nonnull
+ @Override
+ public Task map(@Nullable Function mapper) {
+ if (failure != null)
+ return new CompletedTask<>(failure);
+
+ return new CompletedTask<>(value == null || mapper == null ? null : mapper.apply(value));
+ }
+
+ @Override
+ public V getOrDefault(long timeout, @Nonnull TimeUnit unit, V def) {
+ if (value != null)
+ return value;
+
+ return def;
+ }
+
+ @Override
+ public V call() throws Exception {
+ return value;
+ }
+
+ @Override
+ public boolean cancel(boolean mayInterruptIfRunning) {
+ return false;
+ }
+
+ @Override
+ public boolean isCancelled() {
+ return false;
+ }
+
+ @Override
+ public boolean isDone() {
+ return true;
+ }
+
+ @Override
+ public V get() throws InterruptedException, ExecutionException {
+ return value;
+ }
+
+ @Override
+ public V get(long timeout, @Nonnull TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException {
+ return value;
+ }
+
+ @Nonnull
+ @Override
+ public CompletionStage stage() {
+ if (future == null) {
+ future = new CompletableFuture<>();
+
+ if (failure != null) {
+ future.completeExceptionally(failure);
+ } else {
+ future.complete(value);
+ }
+ }
+
+ return future;
+ }
+
+}
diff --git a/plugin/src/main/java/net/codingarea/commons/common/concurrent/task/Task.java b/plugin/src/main/java/net/codingarea/commons/common/concurrent/task/Task.java
new file mode 100644
index 000000000..8b43122ec
--- /dev/null
+++ b/plugin/src/main/java/net/codingarea/commons/common/concurrent/task/Task.java
@@ -0,0 +1,228 @@
+package net.codingarea.commons.common.concurrent.task;
+
+import net.codingarea.commons.common.collection.WrappedException;
+import net.codingarea.commons.common.function.ExceptionallyFunction;
+import net.codingarea.commons.common.function.ExceptionallyRunnable;
+
+import javax.annotation.CheckReturnValue;
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+import java.util.concurrent.*;
+import java.util.function.BiConsumer;
+import java.util.function.Consumer;
+import java.util.function.Function;
+import java.util.function.Supplier;
+
+/**
+ * A task that may complete (done / failed / cancelled) in the future or may already be done.
+ *
+ * For the completion can be listened by calling {@link #onComplete(Consumer)}, for the cancellation by {@link #onCancelled(Runnable)} and for failure by {@link #onFailure(Consumer)}.
+ *
+ * @see #asyncCall(Callable)
+ * @see #completed(Object)
+ */
+public interface Task extends Future, Callable