initial commit

src/bindx/BindSignal.hx

@@ -0,0 +1,210 @@
+package bindx;
+
+import haxe.macro.Expr;
+import haxe.macro.Type;
+import haxe.macro.Context;
+
+using bindx.MetaUtils;
+
+class BindSignalProvider implements IBindingSignalProvider {
+
+    macro static public function register() {
+        bindx.BindMacros.setBindingSignalProvider(new BindSignalProvider());
+        return macro {};
+    }
+
+    #if macro
+
+    static inline var SIGNAL_POSTFIX = "Changed";
+
+    /**
+     * default value: true
+     */
+    static inline var LAZY_SIGNAL = "lazySignal";
+    /**
+     * default value: false
+     */
+    static inline var INLINE_SIGNAL_GETTER = "inlineSignalGetter";
+
+    public function new() {}
+
+    @:expose static inline function signalName(fieldName:String) return fieldName + SIGNAL_POSTFIX;
+    @:expose static inline function signalGetterName(fieldName:String) return "get_" + signalName(fieldName);
+    @:expose static inline function signalPrivateName(fieldName:String) return "_" + signalName(fieldName);
+
+    public function getFieldDispatcher(field:Field, res:Array<Field>) {
+        switch (field.kind) {
+            case FFun(_):
+                generateSignal(field, macro : bindx.BindSignal.MethodSignal, macro new bindx.BindSignal.MethodSignal(), res);
+            case FProp(_, _, type, _) | FVar(type, _):
+                generateSignal(field, macro : bindx.BindSignal.FieldSignal<$type>, macro new bindx.BindSignal.FieldSignal<$type>(), res);
+        }
+    }
+
+    public function getFieldChangedExpr(field:Field, oldValue:Expr, newValue:Expr):Expr {
+        var args = switch (field.kind) { case FFun(_): []; case _: [oldValue, newValue]; }
+        return dispatchSignal(macro this, field.name, hasLazy(field.bindableMeta()), args);
+    }
+
+    public function getClassFieldBindExpr(expr:Expr, field:ClassField, listener:Expr):Expr {
+        var signalName = signalName(field.name);
+        return macro $expr.$signalName.add($listener);
+    }
+
+    public function getClassFieldBindToExpr(expr:Expr, field:ClassField, target:Expr):Expr {
+        var signalName = signalName(field.name);
+        return switch (field.kind) {
+            case FMethod(_):
+                var fieldName = field.name;
+                macro {
+                    var listener = function () $target = $expr.$fieldName();
+                    $expr.$signalName.add(listener);
+                    function __unbind__() $expr.$signalName.remove(listener);
+                }
+            case FVar(_, _):
+                macro {
+                    var listener = function (from, to) $target = to;
+                    $expr.$signalName.add(listener);
+                    function __unbind__() $expr.$signalName.remove(listener);
+                }
+            }
+    }
+
+    public function getClassFieldUnbindExpr(expr:Expr, field:ClassField, listener:Expr):Expr {
+        var signalName = signalName(field.name);
+        return macro $expr.$signalName.remove($listener);
+    }
+
+    public function getClassFieldChangedExpr(expr:Expr, field:ClassField, oldValue:Expr, newValue:Expr):Expr {
+        var args = switch (field.kind) {
+            case FMethod(_): [];
+           case FVar(_, _): [oldValue, newValue];
+        }
+        return dispatchSignal(expr, field.name, hasLazy(field.bindableMeta()), args);
+    }
+
+    function generateSignal(field:Field, type:ComplexType, builder:Expr, res:Array<Field>) {
+        var signalName = signalName(field.name);
+        var meta = field.bindableMeta();
+        var inlineSignalGetter = meta.findParam(INLINE_SIGNAL_GETTER);
+
+        if (hasLazy(meta)) {
+            var signalPrivateName = signalPrivateName(field.name);
+            res.push({
+                name: signalPrivateName,
+                kind: FVar(type, null),
+                pos: field.pos
+            });
+
+            res.push({
+                name: signalName,
+                kind: FProp("get", "never", type, null),
+                pos: field.pos,
+                access: [APublic]
+            });
+
+            var getter = macro function foo() {
+                if (this.$signalPrivateName == null) {
+                    this.$signalPrivateName = ${builder}
+                }
+                return $i{signalPrivateName};
+            };
+            var getterAccess = [];
+            if (inlineSignalGetter.isNotNullAndTrue()) getterAccess.push(AInline);
+
+            res.push({
+                name: signalGetterName(field.name),
+                kind: FFun(switch (getter.expr) { case EFunction (_, func): func; case _: throw false; }),
+                pos: field.pos,
+                access: getterAccess
+            });
+        } else {
+            if (inlineSignalGetter != null)
+                Context.warning('$INLINE_SIGNAL_GETTER works only with lazy signals', inlineSignalGetter.pos);
+
+            res.push({
+                name: signalName,
+                kind: FProp("default", "null", type, builder),
+                pos: field.pos,
+                access: [APublic]
+            });
+        }
+    }
+
+    inline function dispatchSignal(expr:Expr, fieldName:String, lazy:Bool, args:Array<Expr>) {
+        return 
+            if (lazy) {
+                var signalPrivateName = signalPrivateName(fieldName);
+                macro if ($expr.$signalPrivateName != null) {
+                    $expr.$signalPrivateName.dispatch($a{args});
+               }
+            } else {
+                var signalName = signalName(fieldName);
+                macro $expr.$signalName.dispatch($a{args});
+            }
+    }
+
+    @:expose inline function hasLazy(meta:MetadataEntry) {
+        return meta.findParam(LAZY_SIGNAL).isNullOrTrue();
+    }
+    #end
+}
+
+class MethodSignal extends Signal<Void -> Void> {
+
+    public function dispatch():Void {
+        lock ++;
+        for (l in listeners) l();
+        if (lock > 0) lock --;
+    }
+}
+
+class FieldSignal<T> extends Signal<T -> T -> Void> {
+
+    public function dispatch(oldValue:T = null, newValue:T = null):Void {
+        lock ++;
+        for (l in listeners) l(oldValue, newValue);
+        if (lock > 0) lock --;
+    }
+}
+
+class Signal<T> {
+
+    var listeners:Array<T>;
+
+    var lock = 0;
+
+    public function new() {
+        removeAll();
+    }
+
+    public inline function removeAll() {
+        listeners = [];
+    }
+
+    public inline function dispose() {
+        listeners = null;
+    }
+
+    public function add(listener:T):Void {
+        if (listeners.indexOf(listener) == -1) {
+            checkLock();
+            listeners.push(listener);
+        }
+    }
+
+    public function remove(listener:T):Void {
+        var pos = listeners.indexOf(listener);
+        if (pos > -1) {
+            checkLock();
+            listeners.splice(pos, 1);
+        }
+    }
+
+    @:expose inline function checkLock() {
+        if (lock > 0) {
+            listeners = listeners.copy();
+            lock --;
+        }
+    }
+}