Seamless reconnection for first 5 seconds

1 files changed, 116 insertions, 0 deletions

diff --git a/src/tools/ArrayTools.hx b/src/tools/ArrayTools.hx
new file mode 100644
index 0000000..63b4839
--- /dev/null
+++ b/src/tools/ArrayTools.hx
@@ -0,0 +1,116 @@
+package tools;
+
+import utils.ArrayKeyValueReverseIterator;
+import utils.ArrayReverseIterator;
+
+class ArrayTools {
+	public static function last<T>(arr:Array<T>):Null<T> {
+		return arr[arr.length - 1];
+	}
+
+	public static function min<T:Float>(arr:Array<T>, ?maxValue:T):T {
+		var min = arr[0] ?? maxValue;
+		for (value in arr) if (value < min) min = value;
+		return min;
+	}
+
+	public static function max<T:Float>(arr:Array<T>, ?minValue:T):T {
+		var max = arr[0] ?? minValue;
+		for (value in arr) if (value > max) max = value;
+		return max;
+	}
+
+	public static function indexOfMax<T:Float>(arr:Array<T>, ?minValue:T):Int {
+		if (arr.length == 0) return -1;
+		var max = arr[0] ?? minValue;
+		var maxIndex = 0;
+		for (i in 1...arr.length) {
+			if (arr[i] > max) {
+				maxIndex = i;
+				max = arr[i];
+			}
+		}
+		return maxIndex;
+	}
+
+	public static function sum<T:Float>(arr:Array<T>):T {
+		var total:T = cast 0;
+		for (value in arr) total += value;
+		return total;
+	}
+
+	public static function shuffle<T>(arr:Array<T>):Void {
+		for (i => a in arr) {
+			final n = Std.random(arr.length);
+			final b = arr[n];
+			arr[i] = b;
+			arr[n] = a;
+		}
+	}
+
+	public static inline function reversed<T>(arr:Array<T>) {
+		return new ArrayReverseIterator(arr);
+	}
+
+	/** Key-value reversed array iterator **/
+	public static inline function reversedKV<T>(arr:Array<T>) {
+		return new ArrayKeyValueReverseIterator(arr);
+	}
+
+	public static inline function findMin<T>(
+		arr:Array<T>, f:(item:T) -> Float, maxValue:Float
+	):Null<T> {
+		var result:Null<T> = null;
+		for (item in arr) {
+			final dist = f(item);
+			if (dist > maxValue) continue;
+			maxValue = dist;
+			result = item;
+		}
+		return result;
+	}
+
+	extern overload public static inline function inlineFind<T>(it:Array<T>, f:(item:T) -> Bool):Null<T> {
+		var result:Null<T> = null;
+		for (v in it) {
+			if (f(v)) {
+				result = v;
+				break;
+			}
+		}
+		return result;
+	}
+
+	extern overload public static inline function inlineFind<T>(it:Iterable<T>, f:(item:T) -> Bool):Null<T> {
+		var result:Null<T> = null;
+		for (v in it) {
+			if (f(v)) {
+				result = v;
+				break;
+			}
+		}
+		return result;
+	}
+
+	extern overload public static inline function inlineExists<T>(it:Array<T>, f:(item:T) -> Bool):Bool {
+		var result = false;
+		for (v in it) {
+			if (f(v)) {
+				result = true;
+				break;
+			}
+		}
+		return result;
+	}
+
+	extern overload public static inline function inlineExists<T>(it:Iterable<T>, f:(item:T) -> Bool):Bool {
+		var result = false;
+		for (v in it) {
+			if (f(v)) {
+				result = true;
+				break;
+			}
+		}
+		return result;
+	}
+}