* Un-deprecated and re-purposed Applicable#apply

* Added silent array processing. * Added new Comment annotation. * Added new Counter object for cross-thread atomic usage. * Optimized skull cache. * Added new scoreboard utility mimicking the tablist utility. * Added new WebResponse interface, static method available for downloading resources.
the-h-team · Mar 31, 2022 · 3208ab8 · 3208ab8
1 parent b00ca8a
commit 3208ab8
Show file tree

Hide file tree

Showing 41 changed files with 910 additions and 64 deletions.
diff --git a/labyrinth-common/pom.xml b/labyrinth-common/pom.xml
@@ -5,7 +5,7 @@
     <parent>
         <artifactId>labyrinth</artifactId>
         <groupId>com.github.the-h-team</groupId>
-        <version>1.7.6</version>
+        <version>1.7.7</version>
     </parent>
     <modelVersion>4.0.0</modelVersion>
 

diff --git a/labyrinth-common/src/main/java/com/github/sanctum/labyrinth/annotation/Comment.java b/labyrinth-common/src/main/java/com/github/sanctum/labyrinth/annotation/Comment.java
@@ -0,0 +1,20 @@
+package com.github.sanctum.labyrinth.annotation;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * <p>A developer comment.</p>
+ */
+@Retention(RetentionPolicy.RUNTIME)
+@Target(value = {ElementType.TYPE, ElementType.METHOD, ElementType.PARAMETER, ElementType.FIELD, ElementType.CONSTRUCTOR, ElementType.ANNOTATION_TYPE, ElementType.TYPE_USE})
+public @interface Comment {
+
+	/**
+	 * @return The developer comment for this example.
+	 */
+	String value() default "no comment";
+
+}
diff --git a/labyrinth-common/src/main/java/com/github/sanctum/labyrinth/data/Configurable.java b/labyrinth-common/src/main/java/com/github/sanctum/labyrinth/data/Configurable.java
@@ -156,7 +156,7 @@ public static void registerClass(@NotNull Class<? extends JsonAdapter<?>> c, Obj
 	 * @return The desired Json element adapter or null if non existent.
 	 */
 	public static <V> JsonAdapter<V> getAdapter(@NotNull Class<V> type) {
-		return serializers.entrySet().stream().filter(e -> e.getKey().equals(type.getName()) || type.isAssignableFrom(e.getValue().getSubClass())).map(Map.Entry::getValue).map(c -> (JsonAdapter<V>) c).findFirst().orElse(null);
+		return serializers.entrySet().stream().filter(e -> e.getKey().equals(type.getName()) || type.isAssignableFrom(e.getValue().getClassType())).map(Map.Entry::getValue).map(c -> (JsonAdapter<V>) c).findFirst().orElse(null);
 	}
 
 	public static <V> JsonAdapter<V> getAdapter(@NotNull String pointer) {

diff --git a/labyrinth-common/src/main/java/com/github/sanctum/labyrinth/data/JsonAdapter.java b/labyrinth-common/src/main/java/com/github/sanctum/labyrinth/data/JsonAdapter.java
@@ -1,7 +1,6 @@
 package com.github.sanctum.labyrinth.data;
 
 import com.github.sanctum.labyrinth.annotation.Note;
-import com.github.sanctum.labyrinth.library.TypeFlag;
 import com.google.gson.GsonBuilder;
 import com.google.gson.InstanceCreator;
 import com.google.gson.JsonElement;
@@ -37,13 +36,12 @@ public interface JsonAdapter<T> extends InstanceCreator<T> {
 	 */
 	T read(Map<String, Object> object);
 
-	@Deprecated
 	Class<T> getClassType();
 
 	/**
 	 * @return The class this serializer represents in relation to T.
 	 */
-	@Note("To be overridden!")
+	@Deprecated
 	default Class<? extends T> getSubClass() {
 		return getClassType();
 	}
@@ -52,9 +50,9 @@ default Class<? extends T> getSubClass() {
 	@Note("Non bare constructors should have this method overridden!")
 	default T createInstance(Type type) {
 		Class<?> c = TypeToken.get(type).getRawType();
-		if (getSubClass().isAssignableFrom(c)) {
+		if (getClassType().isAssignableFrom(c)) {
 			try {
-				return getSubClass().cast(c.getDeclaredConstructor().newInstance());
+				return getClassType().cast(c.getDeclaredConstructor().newInstance());
 			} catch (InstantiationException | IllegalAccessException | InvocationTargetException | NoSuchMethodException e) {
 				e.printStackTrace();
 			}
@@ -64,7 +62,7 @@ default T createInstance(Type type) {
 
 	static GsonBuilder getJsonBuilder() {
 		GsonBuilder builder = new GsonBuilder();
-		Configurable.serializers.forEach((key, value) -> builder.registerTypeHierarchyAdapter(value.getSubClass(), value));
+		Configurable.serializers.forEach((key, value) -> builder.registerTypeHierarchyAdapter(value.getClassType(), value));
 		return builder;
 	}
 
@@ -82,5 +80,9 @@ static void register(Class<? extends JsonAdapter<?>> adapterClass, Object... arg
 		Configurable.registerClass(adapterClass, args);
 	}
 
+	static <T> JsonAdapter<T> get(Class<T> c) {
+		return Configurable.getAdapter(c);
+	}
+
 
 }
diff --git a/labyrinth-common/src/main/java/com/github/sanctum/labyrinth/data/JsonAdapterInput.java b/labyrinth-common/src/main/java/com/github/sanctum/labyrinth/data/JsonAdapterInput.java
@@ -49,7 +49,7 @@ public T deserialize(JsonElement jsonElement, Type type, JsonDeserializationCont
 
 	public String getKey() {
 		String test = AnnotationDiscovery.of(NodePointer.class, serializer).mapFromClass((r, u) -> r.value());
-		return test != null ? test : AnnotationDiscovery.of(NodePointer.class, serializer.getSubClass()).mapFromClass((r, u) -> r.value());
+		return test != null ? test : AnnotationDiscovery.of(NodePointer.class, serializer.getClassType()).mapFromClass((r, u) -> r.value());
 	}
 
 	@Override

diff --git a/labyrinth-common/src/main/java/com/github/sanctum/labyrinth/data/JsonConfiguration.java b/labyrinth-common/src/main/java/com/github/sanctum/labyrinth/data/JsonConfiguration.java
@@ -198,7 +198,7 @@ Object checkObject(Type type, boolean array, Object object) {
 				JSONObject j = (JSONObject) object;
 				Gson g = JsonAdapter.getJsonBuilder().create();
 
-				Map.Entry<String, JsonAdapterInput<?>> d = serializers.entrySet().stream().filter(de -> de.getKey().equals(cl.getTypeName()) || cl.isAssignableFrom(de.getValue().getSubClass())).findFirst().orElse(null);
+				Map.Entry<String, JsonAdapterInput<?>> d = serializers.entrySet().stream().filter(de -> de.getKey().equals(cl.getTypeName()) || cl.isAssignableFrom(de.getValue().getClassType())).findFirst().orElse(null);
 				if (d != null) {
 					if (j.containsKey(d.getKey())) {
 						Object ob = j.get(d.getKey());
@@ -218,7 +218,7 @@ Object checkObject(Type type, boolean array, Object object) {
 			}
 			if (target instanceof JSONArray && array) {
 				JSONArray j = (JSONArray) object;
-				Map.Entry<String, JsonAdapterInput<?>> d = serializers.entrySet().stream().filter(de -> cl.isAssignableFrom(de.getValue().getSubClass())).findFirst().orElse(null);
+				Map.Entry<String, JsonAdapterInput<?>> d = serializers.entrySet().stream().filter(de -> cl.isAssignableFrom(de.getValue().getClassType())).findFirst().orElse(null);
 				if (d != null) {
 					Object[] copy = (Object[]) Array.newInstance(cl, j.size());
 					for (int i = 0; i < j.size(); i++) {

diff --git a/labyrinth-common/src/main/java/com/github/sanctum/labyrinth/data/LabyrinthUser.java b/labyrinth-common/src/main/java/com/github/sanctum/labyrinth/data/LabyrinthUser.java
@@ -1,6 +1,7 @@
 package com.github.sanctum.labyrinth.data;
 
 import com.github.sanctum.labyrinth.LabyrinthProvider;
+import com.github.sanctum.labyrinth.formatting.ScoreboardInstance;
 import com.github.sanctum.labyrinth.formatting.TablistInstance;
 import com.github.sanctum.labyrinth.interfacing.Nameable;
 import com.github.sanctum.labyrinth.library.Cooldown;
@@ -15,6 +16,8 @@ public interface LabyrinthUser extends Nameable {
 
 	@NotNull String getName();
 
+	String[] getPreviousNames();
+
 	@NotNull UUID getId();
 
 	@NotNull OfflinePlayer getPlayer();
@@ -23,6 +26,10 @@ default TablistInstance getTablist() {
 		return isOnline() ? TablistInstance.get(getPlayer().getPlayer()) : null;
 	}
 
+	default ScoreboardInstance getScoreboard() {
+		return isOnline() ? ScoreboardInstance.get(getPlayer().getPlayer()) : null;
+	}
+
 	default @Nullable Cooldown getCooldown(@NotNull String key) {
 		return LabyrinthProvider.getInstance().getCooldown(getId().toString() + "-" + key);
 	}

diff --git a/labyrinth-common/src/main/java/com/github/sanctum/labyrinth/data/MemorySpace.java b/labyrinth-common/src/main/java/com/github/sanctum/labyrinth/data/MemorySpace.java
@@ -1,5 +1,7 @@
 package com.github.sanctum.labyrinth.data;
 
+import com.github.sanctum.labyrinth.annotation.See;
+import com.github.sanctum.labyrinth.data.container.LabyrinthAtlas;
 import java.util.Map;
 import java.util.Set;
 
@@ -9,6 +11,7 @@
  * @author Hempfest
  * @version 1.0
  */
+@See({Node.class, Configurable.class, Atlas.class, LabyrinthAtlas.class})
 public interface MemorySpace {
 
 	/**

diff --git a/...inth-common/src/main/java/com/github/sanctum/labyrinth/data/container/CollectionTask.java b/...inth-common/src/main/java/com/github/sanctum/labyrinth/data/container/CollectionTask.java
@@ -222,6 +222,7 @@ public void reset() {
 	public static <T> CollectionTask<T> process(T[] elements, String table, int interval, Consumer<T> action) {
 		return new CollectionTask<T>(table) {
 
+			private static final long serialVersionUID = -3595452685342615045L;
 			final T[] collector = elements;
 			int index = 0;
 			long started = 0, lastRan = 0;
@@ -295,6 +296,80 @@ public void reset() {
 		};
 	}
 
+	public static <T> CollectionTask<T> processSilent(T[] elements, String table, int interval, Consumer<T> action) {
+		return new CollectionTask<T>(table) {
+
+			private static final long serialVersionUID = -3595452685342615045L;
+			final T[] collector = elements;
+			int index = 0;
+			long started = 0, lastRan = 0;
+			T current;
+
+			public double getCompletion() {
+				return Math.min(100.00, new ProgressBar().setProgress(index + 1).setGoal(collector.length).getPercentage());
+			}
+
+			public T current() {
+				return current;
+			}
+
+			@Override
+			public long getTimeStarted() {
+				return started;
+			}
+
+			@Override
+			public long getRecentExecution() {
+				return lastRan;
+			}
+
+			@Override
+			public boolean hasNext() {
+				return index < collector.length;
+			}
+
+			@Override
+			public boolean hasNext(int bounds) {
+				return index + bounds < collector.length;
+			}
+
+			@Ordinal
+			public T next() {
+				return next(interval);
+			}
+
+			@Ordinal(1)
+			public T next(int bounds) {
+				int processed = 0;
+				if (isPaused()) return current;
+				if (index < collector.length) {
+					if (started == 0) started = System.currentTimeMillis();
+					lastRan = System.currentTimeMillis();
+					for (int i = index; i < collector.length; i++) {
+						if (processed <= bounds) {
+							T o = collector[i];
+							current = o;
+							action.accept(o);
+							index++;
+							processed++;
+						}
+					}
+					return current;
+				}
+				cancel();
+				return current;
+			}
+
+			@Override
+			public void reset() {
+				index = 0;
+				started = 0;
+				lastRan = 0;
+				current = null;
+			}
+		};
+	}
+
 	public static <T> CollectionTask<T> merge(LabyrinthCollection<T> target, LabyrinthCollection<T> additive, String table, int interval) {
 		return new LabyrinthCollectionMergeProcess<>(target, additive, interval, table);
 	}

diff --git a/labyrinth-common/src/main/java/com/github/sanctum/labyrinth/data/service/AnvilMechanics.java b/labyrinth-common/src/main/java/com/github/sanctum/labyrinth/data/service/AnvilMechanics.java
@@ -1,15 +1,20 @@
 package com.github.sanctum.labyrinth.data.service;
 
+import com.github.sanctum.labyrinth.annotation.Note;
+import com.github.sanctum.labyrinth.api.Service;
+import java.util.Objects;
+import org.bukkit.Bukkit;
 import org.bukkit.entity.Player;
 import org.bukkit.inventory.Inventory;
+import org.jetbrains.annotations.NotNull;
 
 /**
  * Wraps versions to be able to easily use different NMS server versions
  *
  * @author Wesley Smith
  * @since 1.0
  */
-public interface AnvilMechanics {
+public interface AnvilMechanics extends Service {
 
 	/**
 	 * Gets the next available NMS container id for the player
@@ -92,4 +97,8 @@ public interface AnvilMechanics {
 	 */
 	Object newContainerAnvil(Player player, String title);
 
+	static @Note @NotNull AnvilMechanics getInstance() {
+		return Objects.requireNonNull(Bukkit.getServicesManager().load(AnvilMechanics.class));
+	}
+
 }
diff --git a/labyrinth-common/src/main/java/com/github/sanctum/labyrinth/data/service/Counter.java b/labyrinth-common/src/main/java/com/github/sanctum/labyrinth/data/service/Counter.java
@@ -0,0 +1,87 @@
+package com.github.sanctum.labyrinth.data.service;
+
+import com.github.sanctum.labyrinth.api.Service;
+import com.github.sanctum.labyrinth.library.TypeFlag;
+
+public interface Counter<N extends Number> extends Service {
+
+	void add();
+
+	void subtract();
+
+	N get();
+
+	static <N extends Number> Counter<N> newInstance() {
+		return new Counter<N>() {
+
+			Number i;
+			boolean integer = false;
+
+			{
+				TypeFlag<N> flag = TypeFlag.get();
+				Class<N> type = flag.getType();
+				if (type == Integer.class) {
+					i = 0L;
+					integer = true;
+				} else i = 0.0D;
+			}
+
+			@Override
+			public void add() {
+				if (integer) {
+					i = (i.longValue() + 1L);
+				} else i = (i.doubleValue() + 1D);
+			}
+
+			@Override
+			public void subtract() {
+				if (integer) {
+					i = (i.longValue() - 1L);
+				} else i = (i.doubleValue() - 1D);
+			}
+
+			@Override
+			public N get() {
+				return (N) i;
+			}
+		};
+	}
+
+	static <N extends Number> Counter<N> newInstance(N influence) {
+		return new Counter<N>() {
+
+			Number i;
+			final Number inf = influence;
+			boolean integer = false;
+
+			{
+				TypeFlag<N> flag = TypeFlag.get();
+				Class<N> type = flag.getType();
+				if (type == Integer.class) {
+					i = 0L;
+					integer = true;
+				} else i = 0.0D;
+			}
+
+			@Override
+			public void add() {
+				if (integer) {
+					i = (i.longValue() + inf.longValue());
+				} else i = (i.doubleValue() + inf.doubleValue());
+			}
+
+			@Override
+			public void subtract() {
+				if (integer) {
+					i = (i.longValue() - inf.longValue());
+				} else i = (i.doubleValue() - inf.doubleValue());
+			}
+
+			@Override
+			public N get() {
+				return (N) i;
+			}
+		};
+	}
+
+}
diff --git a/labyrinth-common/src/main/java/com/github/sanctum/labyrinth/data/service/DummyReducer.java b/labyrinth-common/src/main/java/com/github/sanctum/labyrinth/data/service/DummyReducer.java
@@ -1,11 +1,14 @@
 package com.github.sanctum.labyrinth.data.service;
 
 import com.github.sanctum.labyrinth.annotation.Json;
+import java.util.HashMap;
 import java.util.Map;
 
-public class DummyReducer implements Json.Reducer {
+public final class DummyReducer implements Json.Reducer {
 	@Override
 	public Map<String, Object> reduce(Object o) {
-		return null;
+		Map<String, Object> map = new HashMap<>();
+		map.put("element", o.toString());
+		return map;
 	}
 }