Add x_get_lock, synchronized changes (#1381)

src/main/java/com/laytonsmith/PureUtilities/Quadruplet.java

@@ -0,0 +1,94 @@
+package com.laytonsmith.PureUtilities;
+
+import java.util.Objects;
+
+/**
+ * Creates an object quadruplet. The hashcode and equals functions have been overridden to use the underlying object's hash
+ * code and equals combined. The underlying objects may be null.
+ *
+ * @param <A> The first object's type.
+ * @param <B> The second object's type.
+ * @param <C> The third object's type.
+ * @param <D> The fourth object's type.
+ */
+public class Quadruplet<A, B, C, D> {
+
+	private final A fst;
+	private final B snd;
+	private final C trd;
+	private final D frth;
+
+	/**
+	 * Creates a new Quadruplet with the specified values.
+	 *
+	 * @param a
+	 * @param b
+	 * @param c
+	 * @param d
+	 */
+	public Quadruplet(A a, B b, C c, D d) {
+		fst = a;
+		snd = b;
+		trd = c;
+		frth = d;
+	}
+
+	@Override
+	public String toString() {
+		return "<"
+				+ Objects.toString(fst) + ", "
+				+ Objects.toString(snd) + ", "
+				+ Objects.toString(trd) + ", "
+				+ Objects.toString(frth) + ">";
+	}
+
+	@Override
+	public int hashCode() {
+		int hash = 7;
+		hash = 47 * hash + Objects.hashCode(this.fst);
+		hash = 47 * hash + Objects.hashCode(this.snd);
+		hash = 47 * hash + Objects.hashCode(this.trd);
+		hash = 47 * hash + Objects.hashCode(this.frth);
+		return hash;
+	}
+
+	@Override
+	public boolean equals(Object obj) {
+		if(obj == null) {
+			return false;
+		}
+		if(getClass() != obj.getClass()) {
+			return false;
+		}
+		final Quadruplet<?, ?, ?, ?> other = (Quadruplet<?, ?, ?, ?>) obj;
+		if(!Objects.equals(this.fst, other.fst)) {
+			return false;
+		}
+		if(!Objects.equals(this.snd, other.snd)) {
+			return false;
+		}
+		if(!Objects.equals(this.trd, other.trd)) {
+			return false;
+		}
+		if(!Objects.equals(this.frth, other.frth)) {
+			return false;
+		}
+		return true;
+	}
+
+	public A getFirst() {
+		return fst;
+	}
+
+	public B getSecond() {
+		return snd;
+	}
+
+	public C getThird() {
+		return trd;
+	}
+
+	public D getFourth() {
+		return frth;
+	}
+}

src/main/java/com/laytonsmith/abstraction/AbstractConvertor.java

@@ -13,16 +13,23 @@
 import java.util.TimerTask;
 import java.util.concurrent.Callable;
 import java.util.concurrent.atomic.AtomicInteger;
+import java.util.logging.Logger;
 
 public abstract class AbstractConvertor implements Convertor {
 
 	private final List<Runnable> shutdownHooks = new ArrayList<>();
+	private final List<Runnable> persistentShutdownHooks = new ArrayList<>();
 
 	@Override
 	public void addShutdownHook(Runnable r) {
 		shutdownHooks.add(r);
 	}
 
+	@Override
+	public void addPersistentShutdownHook(Runnable r) {
+		persistentShutdownHooks.add(r);
+	}
+
 	@Override
 	public void runShutdownHooks() {
 		// Fire off the shutdown event, before we shut down all the internal hooks
@@ -35,9 +42,21 @@ public Object _GetObject() {
 		});
 		Iterator<Runnable> iter = shutdownHooks.iterator();
 		while(iter.hasNext()) {
-			iter.next().run();
+			try {
+				iter.next().run();
+			} catch(Error e) {
+				Logger.getLogger(AbstractConvertor.class.getName()).severe(e.getMessage());
+			}
 			iter.remove();
 		}
+
+		for(Runnable r : persistentShutdownHooks) {
+			try {
+				r.run();
+			} catch(Error e) {
+				Logger.getLogger(AbstractConvertor.class.getName()).severe(e.getMessage());
+			}
+		}
 	}
 
 	/**

src/main/java/com/laytonsmith/abstraction/Convertor.java

@@ -131,14 +131,26 @@ public interface Convertor {
 	MCInventoryHolder CreateInventoryHolder(String id, String title);
 
 	/**
-	 * Run whenever the server is shutting down (or restarting). There is no guarantee provided as to what thread the
+	 * Runs whenever the server is shutting down (or reloading). There is no guarantee provided as to what thread the
 	 * runnables actually run on, so you should ensure that the runnable executes it's actions on the appropriate thread
-	 * yourself.
+	 * yourself. Note that this shutdown hook will only run once, so if multiple reload events occur, this will not
+	 * be registered for the second run, unless you specifically add it yourself. If you need a shutdown hook to run
+	 * every time, and only want to register it once, see {@link #addPersistentShutdownHook}.
 	 *
 	 * @param r
 	 */
 	void addShutdownHook(Runnable r);
 
+	/**
+	 * Runs whenever the server is shutting down (or reloading). There is no guarantee provided as to what thread the
+	 * runnables actually run on, so you should ensure that the runnable executes it's actions on the appropriate thread
+	 * yourself. Note that this shutdown hook will never dequeue, so if multiple reload events occur, this will run
+	 * every time, and so you should only call this once (i.e. from a static context). If you need a shutdown hook to
+	 * dequeue after run, see {@link #addShutdownHook}.
+	 * @param r
+	 */
+	void addPersistentShutdownHook(Runnable r);
+
 	/**
 	 * Runs all the registered shutdown hooks. This should only be called by the shutdown mechanism. After running, each
 	 * Runnable will be removed from the queue.
@@ -294,4 +306,13 @@ public interface Convertor {
 	 * @return
 	 */
 	public MCTransformation GetTransformation(Quaternionf leftRotation, Quaternionf rightRotation, Vector3f scale, Vector3f translation);
+
+	/**
+	 * Returns true if this is the main thread of the application. This is only applicable in some managed environments,
+	 * in other environments where this doesn't matter, this will always return false (i.e. all threads are considered
+	 * equally important/unimportant). If this returns true, this means that the current thread is for instance the
+	 * UI thread, and thus should not be blocked on.
+	 * @return
+	 */
+	public boolean IsMainThread();
 }

src/main/java/com/laytonsmith/abstraction/StaticLayer.java

@@ -166,6 +166,10 @@ public static MCPlugin GetPlugin() {
 		return convertor.GetPlugin();
 	}
 
+	public static boolean IsMainThread() {
+		return convertor.IsMainThread();
+	}
+
 	public static synchronized Convertor GetConvertor() {
 		return convertor;
 	}

src/main/java/com/laytonsmith/abstraction/bukkit/BukkitConvertor.java

@@ -910,4 +910,10 @@ public MCNamespacedKey GetNamespacedKey(String key) {
 	public MCTransformation GetTransformation(Quaternionf leftRotation, Quaternionf rightRotation, Vector3f scale, Vector3f translation) {
 		return new BukkitMCTransformation(new Transformation(translation, leftRotation, scale, rightRotation));
 	}
+
+	@Override
+	public boolean IsMainThread() {
+		return Bukkit.isPrimaryThread();
+	}
+
 }

src/main/java/com/laytonsmith/core/functions/ResourceManager.java

@@ -62,7 +62,7 @@ public static ResourceTypes getResourceByType(Class<?> type) {
 	private static final Map<Long, CResource<?>> RESOURCES = new HashMap<>();
 
 	static {
-		StaticLayer.GetConvertor().addShutdownHook(new Runnable() {
+		StaticLayer.GetConvertor().addPersistentShutdownHook(new Runnable() {
 
 			@Override
 			public void run() {