XType.hx

class XType<T>
{
	static var classTypes:Map<String,XType<Dynamic>> = { new Map<String,XType<Dynamic>>(); };
	static var enumTypes:Map<String,XType<Dynamic>> = { new Map<String,XType<Dynamic>>(); };

	public static var XNull = new XType(TNull);
	public static var XInt:XType<Int> = new XType(TInt);
	public static var XFloat:XType<Float> = new XType(TFloat);
	public static var XBool:XType<Bool> = new XType(TBool);
	public static var XObject = new XType(TObject);
	public static var XFunction = new XType(TFunction);
	public static var XUnknown = new XType(TUnknown);

	public var valueType (default, null):ValueType;

	function new(valueType:ValueType)
	{
		this.valueType = valueType;
	}

	public function toString():String
	{
		return Std.string(valueType);
	}

	public function isInstance(value:Dynamic):Bool
	{
		var type:Dynamic;
		return switch (valueType)
		{
			case TInt: Std.is(value, Int);
			case TFloat: Std.is(value, Float);
			case TBool: Std.is(value, Bool);
			case TClass(t): Std.is(value, t);
			case TEnum(e): Std.is(value, e);
			case TNull: value == null;
			case TFunction: Reflect.isFunction(value);
			case TObject: Reflect.isObject(value);
			case TUnknown: false;
		};
	}

	public static function of<T>(value:T):XType<T>
	{
		var valueType = Type.typeof(value);
		var xtype:Dynamic = switch (valueType)
		{
			case TInt: XInt;
			case TFloat: XFloat;
			case TBool: XBool;
			case TClass(t): ofClass(t);
			case TEnum(e): ofEnum(e);
			case TNull: XNull;
			case TFunction: XFunction;
			case TObject: XObject;
			case TUnknown: XUnknown;
		}
		return cast xtype;
	}

	public static function ofClass<T>(type:Class<T>):XType<T>
	{
		var className = Type.getClassName(type);
		var xtype:XType<T> = cast classTypes.get(className);
		if (xtype == null)
		{
			xtype = new XType(TClass(type));
			classTypes.set(className, xtype);
		}
		return xtype;
	}

	public static function ofEnum<T>(type:Enum<T>):XType<T>
	{
		var enumName = Type.getEnumName(type);
		var xtype:XType<T> = cast enumTypes.get(enumName);
		if (xtype == null)
		{
			xtype = new XType(TEnum(type));
			enumTypes.set(enumName, xtype);
		}
		return xtype;
	}
}