diff --git a/CompilationOption.hx b/CompilationOption.hx new file mode 100755 index 0000000..5ae779e --- /dev/null +++ b/CompilationOption.hx @@ -0,0 +1,73 @@ +package; +#if macro +import haxe.macro.Context; +import haxe.macro.Expr; +#end + +/** +* CompilationOption allows us to use compile-time variables for advanced conditional compilation. +*/ +class CompilationOption { + #if macro + /** + * Internal storage of the options. + */ + static var storage = new Map(); + #end + + /** + * Set `key` to `value`. + * + * For simplicity `value` can only be constant Bool/Int/Float/String or null. + * Array and structures are also possible, check: + * http://haxe.org/manual/macros#constant-arguments + * + * Set `force` to true in order to override an option. + * But be careful overriding will influenced by compilation order which may be hard to predict. + */ + @:overload(function (key:String, value:Bool, ?force:Bool = false):Void{}) + @:overload(function (key:String, value:Int, ?force:Bool = false):Void{}) + @:overload(function (key:String, value:Float, ?force:Bool = false):Void{}) + @:overload(function (key:String, value:String, ?force:Bool = false):Void{}) + macro static public function set(key:String, value:Dynamic, ?force:Bool = false) { + if (!force && storage.exists(key)) + throw key + " has already been set to " + storage.get(key); + + storage.set(key, value); + + return macro {}; //an empty block, which means nothing + } + + /** + * Return the option as a constant. + */ + macro static public function get(key:String):Expr { + return Context.makeExpr(storage.get(key), Context.currentPos()); + } + + /** + * Tell if `key` was set. + */ + macro static public function exists(key:String):ExprOf { + return Context.makeExpr(storage.exists(key), Context.currentPos()); + } + + /** + * Removes an option. Returns true if there was such option. + */ + macro static public function remove(key:String):ExprOf { + return Context.makeExpr(storage.remove(key), Context.currentPos()); + } + + /** + * Dump the options as an object with keys as fields. + * eg. trace(CompilationOption.dump()); + */ + macro static public function dump():ExprOf { + var obj = {}; + for (key in storage.keys()) { + Reflect.setField(obj, key, storage.get(key)); + } + return Context.makeExpr(obj, Context.currentPos()); + } +} \ No newline at end of file diff --git a/Meta.hx b/Meta.hx new file mode 100755 index 0000000..6b89a8f --- /dev/null +++ b/Meta.hx @@ -0,0 +1,30 @@ +package; + +#if macro +import haxe.macro.Context; +import haxe.macro.Expr; +#end + +class Meta { + + #if macro + private static inline var VERSION:String = "version"; + private static inline var BUILD:String = "build"; + + private static var data:Map = new Map(); + #end + + macro static public function getBuild():ExprOf { + return Context.makeExpr(data.get(BUILD), Context.currentPos()); + } + + macro static public function getVersion():ExprOf { + return Context.makeExpr(data.get(VERSION), Context.currentPos()); + } + + macro static public function set(version:String) { + data.set(BUILD, Date.now().toString()); + data.set(VERSION, version); + return macro {}; + } +} \ No newline at end of file diff --git a/haxework/net/BaseLoader.hx b/haxework/net/BaseLoader.hx index 8bb621b..915326d 100755 --- a/haxework/net/BaseLoader.hx +++ b/haxework/net/BaseLoader.hx @@ -1,5 +1,6 @@ package haxework.net; +import flash.utils.ByteArray; import haxework.net.callback.Callback; import haxework.net.callback.ICallback; import flash.events.Event; @@ -31,6 +32,14 @@ class BaseLoader implements ILoader { return callback; } + public function fromBytes(data:ByteArray):ICallback { + if (busy) throw "Busy"; + busy = true; + callback = new Callback(); + internalFromBytes(data); + return callback; + } + public function GET(url:String, data:Dynamic = null):ICallback { return request(url, Method.GET, data); } @@ -43,6 +52,10 @@ class BaseLoader implements ILoader { throw "Abstract"; } + private function internalFromBytes(data:ByteArray):Void { + throw "Abstract"; + } + private function onComplete(e:Event):Void { var data:T = extrudeResult(e); var c:ICallback = callback; diff --git a/haxework/net/BaseMediaLoader.hx b/haxework/net/BaseMediaLoader.hx index 8b826bf..45fc6d6 100755 --- a/haxework/net/BaseMediaLoader.hx +++ b/haxework/net/BaseMediaLoader.hx @@ -1,5 +1,6 @@ package haxework.net; +import flash.utils.ByteArray; import haxework.net.BaseLoader; import flash.events.SecurityErrorEvent; import flash.events.IOErrorEvent; @@ -16,6 +17,11 @@ class BaseMediaLoader extends BaseLoader { loader.load(new URLRequest(url)); } + override private function internalFromBytes(data:ByteArray):Void { + loader = buildLoader(); + loader.loadBytes(data); + } + private function buildLoader():Loader { var loader:Loader = new Loader(); loader.contentLoaderInfo.addEventListener(Event.COMPLETE, onComplete); diff --git a/haxework/net/BaseURLLoader.hx b/haxework/net/BaseURLLoader.hx index f53ceb6..0bf8c55 100755 --- a/haxework/net/BaseURLLoader.hx +++ b/haxework/net/BaseURLLoader.hx @@ -12,9 +12,9 @@ class BaseURLLoader extends BaseLoader { private var dataFormat:URLLoaderDataFormat; private var loader:URLLoader; - public function new() { + public function new(dateFormat:URLLoaderDataFormat = null) { super(); - dataFormat = URLLoaderDataFormat.TEXT; + this.dataFormat = (dateFormat == null ? URLLoaderDataFormat.TEXT : dateFormat); } override private function internalRequest(url:String):Void { diff --git a/haxework/net/BytesLoader.hx b/haxework/net/BytesLoader.hx new file mode 100755 index 0000000..4cf7489 --- /dev/null +++ b/haxework/net/BytesLoader.hx @@ -0,0 +1,17 @@ +package haxework.net; + +import flash.net.URLLoaderDataFormat; +import flash.utils.ByteArray; +import flash.net.URLLoader; +import flash.events.Event; + +class BytesLoader extends BaseURLLoader { + + public function new() { + super(URLLoaderDataFormat.BINARY); + } + + override private function extrudeResult(e:Event):ByteArray { + return cast(cast(e.currentTarget, URLLoader).data, ByteArray); + } +} diff --git a/haxework/net/ILoader.hx b/haxework/net/ILoader.hx index 4a9add4..fc7b81c 100755 --- a/haxework/net/ILoader.hx +++ b/haxework/net/ILoader.hx @@ -1,5 +1,6 @@ package haxework.net; +import flash.utils.ByteArray; import haxework.net.callback.ICallback; enum Method { @@ -10,6 +11,7 @@ enum Method { interface ILoader { public var busy(default, null):Bool; public function request(url:String, method:Method, data:Dynamic = null):ICallback; + public function fromBytes(data:ByteArray):ICallback; public function GET(url:String, data:Dynamic = null):ICallback; public function POST(url:String, data:Dynamic = null):ICallback; public function cancel():Void; diff --git a/haxework/net/SwfLoader.hx b/haxework/net/SwfLoader.hx new file mode 100755 index 0000000..1ae4743 --- /dev/null +++ b/haxework/net/SwfLoader.hx @@ -0,0 +1,16 @@ +package haxework.net; + +import flash.display.MovieClip; +import flash.display.LoaderInfo; +import flash.display.Loader; +import flash.events.Event; + +class SwfLoader extends BaseMediaLoader { + + override private function extrudeResult(e:Event):MovieClip { + var content:MovieClip = cast(cast(e.currentTarget, LoaderInfo).loader.content, MovieClip); + content.gotoAndStop(0); + return content; + } +} + diff --git a/haxework/net/callback/Callback.hx b/haxework/net/callback/Callback.hx index 6f2ff8c..92d8a03 100755 --- a/haxework/net/callback/Callback.hx +++ b/haxework/net/callback/Callback.hx @@ -1,5 +1,7 @@ package haxework.net.callback; +import haxe.Timer; + class Callback implements ICallback { private var _success:Null Void>; @@ -25,6 +27,12 @@ class Callback implements ICallback { } } + public function callSuccessAsync(data:T):Void { + Timer.delay(function():Void { + callSuccess(data); + }, 1); + } + public function callFail(error:Dynamic):Void { try { if (_fail != null) _fail(error); @@ -32,4 +40,16 @@ class Callback implements ICallback { trace(error); } } + + public function callFailAsync(error:Dynamic):Void { + Timer.delay(function():Void { + callFail(error); + }, 1); + } + + public function glue(callback:ICallback):ICallback { + this._success = callback.callSuccess; + this._fail = callback.callFail; + return this; + } } diff --git a/haxework/net/callback/ICallback.hx b/haxework/net/callback/ICallback.hx index c6afb8d..f6d03c3 100755 --- a/haxework/net/callback/ICallback.hx +++ b/haxework/net/callback/ICallback.hx @@ -4,6 +4,9 @@ interface ICallback { public function success(f:T -> Void):ICallback; public function fail(f:Dynamic -> Void):ICallback; public function callSuccess(data:T):Void; + public function callSuccessAsync(data:T):Void; public function callFail(error:Dynamic):Void; + public function callFailAsync(error:Dynamic):Void; + public function glue(callback:ICallback):ICallback; }