Using and Enums

Based on Enums and Using system from hscript-iris, mostly made by ne_eo.

hscript/utils/UsingClass.hx

@@ -0,0 +1,9 @@
+package hscript.utils;
+
+/**
+ * This is used to mark classes that can be used with the `using` keyword.
+ * You can also add @:usableEntry to your class.
+ * If you wanna force the class to be called with any type, you can add @:usableEntry(forceAny)
+**/
+@:autoBuild(hscript.macros.UsingMacro.build())
+interface UsingClass {}

hscript/utils/UsingEntry.hx

@@ -0,0 +1,17 @@
+package hscript.utils;
+
+typedef UsingCall = (o: Dynamic, f: String, args: Array<Dynamic>) -> Dynamic;
+
+/**
+ * Code based on Using system from "hscript-iris"
+ * @see https://github.com/pisayesiwsi/hscript-iris/blob/master/crowplexus/iris/utils/UsingEntry.hx
+ */
+class UsingEntry {
+	public var name: String;
+	public var call: UsingCall;
+
+	public function new(name: String, call: UsingCall) {
+		this.name = name;
+		this.call = call;
+	}
+}

hscript/utils/UsingHandler.hx

@@ -0,0 +1,45 @@
+package hscript.utils;
+
+import hscript.utils.UsingEntry.UsingCall;
+import StringTools;
+import Lambda;
+
+class UsingHandler {
+    public static var usingEntries:Array<UsingEntry> = [
+        new UsingEntry("StringTools", function(o: Dynamic, f: String, args: Array<Dynamic>): Dynamic {
+			if (f == "isEof") // has @:noUsing
+				return null;
+			switch (Type.typeof(o)) {
+				case TInt if (f == "hex"):
+					return StringTools.hex(o, args[0]);
+				case TClass(String):
+					if (Reflect.hasField(StringTools, f)) {
+						var field = Reflect.field(StringTools, f);
+						if (Reflect.isFunction(field)) {
+							return Reflect.callMethod(StringTools, field, [o].concat(args));
+						}
+					}
+				default:
+			}
+			return null;
+		}),
+		new UsingEntry("Lambda", function(o: Dynamic, f: String, args: Array<Dynamic>): Dynamic {
+			if (Tools.isIterable(o)) {
+				// TODO: Check if the values are Iterable<T>
+				if (Reflect.hasField(Lambda, f)) {
+					var field = Reflect.field(Lambda, f);
+					if (Reflect.isFunction(field)) {
+						return Reflect.callMethod(Lambda, field, [o].concat(args));
+					}
+				}
+			}
+			return null;
+		}),
+    ];
+
+    public static function registerUsingGlobal(name: String, call:UsingCall):UsingEntry {
+		var entry = new UsingEntry(name, call);
+		usingEntries.push(entry);
+		return entry;
+	}
+}