1.3

lib/src/Core/AsyncBag.dart

@@ -1,63 +1,50 @@
 import 'AsyncReply.dart';
 
-class AsyncBag<T> extends AsyncReply<List<T>>
-{
+class AsyncBag<T> extends AsyncReply<List<T>> {
+  List<AsyncReply<T>> _replies = new List<AsyncReply<T>>();
+  List<T> _results = <T>[];
 
-    List<AsyncReply<T>> _replies = new List<AsyncReply<T>>();
-    List<T> _results = new List<T>();
+  int _count = 0;
+  bool _sealedBag = false;
 
-    int _count = 0;
-    bool _sealedBag = false;
+  Type arrayType;
+  
+  seal() {
+    //print("SEALED");
 
-    seal()
-    {
-        //print("SEALED");
-      
-        if (_sealedBag)
-            return;
+    if (_sealedBag) return;
 
-        _sealedBag = true;
+    _sealedBag = true;
 
-        if (_results.length == 0)
-            trigger(new List<T>());
+    if (_results.length == 0) trigger(new List<T>());
 
-        for (var i = 0; i < _results.length; i++)
-        {
-            var k = _replies[i];
-            var index = i;
+    for (var i = 0; i < _results.length; i++) {
+      var k = _replies[i];
+      var index = i;
 
-            k.then<dynamic>((r)
-            {
-                _results[index] = r;
-                _count++;
-                //print("Seal ${_count}/${_results.length}");
-                if (_count == _results.length)
-                    trigger(_results);
-            }).error((ex){
-              triggerError(ex);
-            });
-        }
+      k.then<dynamic>((r) {
+        _results[index] = r;
+        _count++;
+        //print("Seal ${_count}/${_results.length}");
+        if (_count == _results.length) trigger(_results);
+      }).error((ex) {
+        triggerError(ex);
+      });
     }
+  }
 
-    add(AsyncReply<T> reply)
-    {
-        if (!_sealedBag)
-        {
-            _results.add(null);
-            _replies.add(reply);
-        }
+  add(AsyncReply<T> reply) {
+    if (!_sealedBag) {
+      _results.add(null);
+      _replies.add(reply);
     }
+  }
 
-    addBag(AsyncBag<T> bag)
-    {
-        bag._replies.forEach((r) {
-          add(r);
-        });
-    }
-
-    AsyncBag()
-    {
-
-    }
+  addBag(AsyncBag<T> bag) {
+    bag._replies.forEach((r) {
+      add(r);
+    });
+  }
 
+  AsyncBag() {}
 }

lib/src/Core/AsyncReply.dart

@@ -26,196 +26,155 @@ import 'dart:core';
 import 'AsyncException.dart';
 import 'ProgressType.dart';
 
-class AsyncReply<T> implements Future<T>
-{
+class AsyncReply<T> implements Future<T> {
+  List<Function(T)> _callbacks = new List<Function(T)>();
 
-    List<Function(T)> _callbacks = new List<Function(T)>();
+  T _result;
 
-    T _result;
+  List<Function(AsyncException)> _errorCallbacks =
+      new List<Function(AsyncException)>();
 
-    List<Function(AsyncException)> _errorCallbacks = new List<Function(AsyncException)>();
-    
-    List<Function(ProgressType, int, int)> _progressCallbacks = new List<Function(ProgressType, int, int)>();
+  List<Function(ProgressType, int, int)> _progressCallbacks =
+      new List<Function(ProgressType, int, int)>();
 
-    List<Function(T)> _chunkCallbacks = new List<Function(T)>();
+  List<Function(T)> _chunkCallbacks = new List<Function(T)>();
 
+  bool _resultReady = false;
+  AsyncException _exception;
 
+  bool get ready {
+    return _resultReady;
+  }
 
-    bool _resultReady = false;
-    AsyncException _exception;
+  set ready(value) {
+    _resultReady = value;
+  }
 
+  T get result {
+    return _result;
+  }
 
-    bool get ready
-    {
-        return _resultReady;
-    }
+  setResultReady(bool val) {
+    _resultReady = val;
+  }
 
-    set ready(value)
-    {
-        _resultReady = value; 
-    }
-    
-    T get result
-    {
-        return _result;
-    }
-
-    setResultReady(bool val)
-    {
-      _resultReady = val;
-    }
- 
-
-  AsyncReply<T> next(Function(T) callback)
-  {
+  AsyncReply<T> next(Function(T) callback) {
     then(callback);
     return this;
   }
 
-  AsyncReply<R> then<R>(FutureOr<R> onValue(T value), {Function onError}) 
-  {
-      _callbacks.add(onValue);
-      if (onError != null)
-      {
-        if (onError is Function(dynamic, dynamic))
-        {
-          _errorCallbacks.add((ex)=>onError(ex, null));
-        }
-        else if (onError is Function(dynamic))
-        {
-          _errorCallbacks.add(onError);
-        }
-        else if (onError is Function())
-        {
-          _errorCallbacks.add((ex)=>onError());
-        }
-        else if (onError is Function(Object, StackTrace))
-        {
-          _errorCallbacks.add((ex)=>onError(ex, null));
-        }
+  AsyncReply<R> then<R>(FutureOr<R> onValue(T value), {Function onError}) {
+    _callbacks.add(onValue);
+    if (onError != null) {
+      if (onError is Function(dynamic, dynamic)) {
+        _errorCallbacks.add((ex) => onError(ex, null));
+      } else if (onError is Function(dynamic)) {
+        _errorCallbacks.add(onError);
+      } else if (onError is Function()) {
+        _errorCallbacks.add((ex) => onError());
+      } else if (onError is Function(Object, StackTrace)) {
+        _errorCallbacks.add((ex) => onError(ex, null));
       }
+    }
 
+    if (_resultReady) onValue(result);
 
-      if (_resultReady)
-          onValue(result);
-
-      if (R == Null)
-        return null;
-      else
-        return this as AsyncReply<R>;
+    if (R == Null)
+      return null;
+    else
+      return this as AsyncReply<R>;
   }
 
-  AsyncReply<T> whenComplete(FutureOr action())
-  {
+  AsyncReply<T> whenComplete(FutureOr action()) {
     return this;
     //_callbacks.add(action);
   }
 
-  Stream<T> asStream()
-  {
+  Stream<T> asStream() {
     return null;
   }
 
-  AsyncReply<T> catchError(Function onError, {bool test(Object error)})
-  {
-      return this.error(onError);
+  AsyncReply<T> catchError(Function onError, {bool test(Object error)}) {
+    return this.error(onError);
   }
 
-  AsyncReply<T> timeout(Duration timeLimit, {FutureOr<T> onTimeout()})
-  {
+  AsyncReply<T> timeout(Duration timeLimit, {FutureOr<T> onTimeout()}) {
     return this;
   }
- 
-    AsyncReply<T> error(Function(dynamic) callback)
-    {
-        _errorCallbacks.add(callback);
 
-        if (_exception != null)
-            callback(_exception);
-        
-        return this;
-    }
+  AsyncReply<T> error(Function(dynamic) callback) {
+    _errorCallbacks.add(callback);
 
-    AsyncReply<T> progress(Function(ProgressType, int, int) callback)
-    {
-        _progressCallbacks.add(callback);
-        return this;
-    }
+    if (_exception != null) callback(_exception);
 
-    
-    AsyncReply<T> chunk(Function(T) callback)
-    {
-        _chunkCallbacks.add(callback);
-        return this;
-    }
+    return this;
+  }
 
-    void trigger(T result)
-    {
+  AsyncReply<T> progress(Function(ProgressType, int, int) callback) {
+    _progressCallbacks.add(callback);
+    return this;
+  }
 
-//            lock (callbacksLock)
-//           {
-            if (_resultReady)
-                return;
+  AsyncReply<T> chunk(Function(T) callback) {
+    _chunkCallbacks.add(callback);
+    return this;
+  }
 
-            _result = result;
-            _resultReady = true;
+  AsyncReply<T> trigger(T result) {
+    if (_resultReady) return this;
 
-            _callbacks.forEach((x) {
-                x(result);
-            });
+    _result = result;
+    _resultReady = true;
 
-//         }
+    _callbacks.forEach((x) {
+      x(result);
+    });
 
-    }
+    return this;
+  }
 
-    triggerError(Exception exception)
-    {
-        if (_resultReady)
-            return;
+  AsyncReply<T> triggerError(Exception exception) {
+    if (_resultReady) return this;
 
-        if (exception is AsyncException)
-            _exception = exception;
-        else
-            _exception = AsyncException.toAsyncException(exception);
+    if (exception is AsyncException)
+      _exception = exception;
+    else
+      _exception = AsyncException.toAsyncException(exception);
 
-        ///lock (callbacksLock)
-        //{
+    ///lock (callbacksLock)
+    //{
 
-        if (this._errorCallbacks.length == 0)
-			    throw _exception;
-        else
-          _errorCallbacks.forEach((x) {
-              x(_exception);
-          });
-        //}
+    if (this._errorCallbacks.length == 0)
+      throw _exception;
+    else
+      _errorCallbacks.forEach((x) {
+        x(_exception);
+      });
+    //}
 
-    }
+    return this;
+  }
 
-    triggerProgress(ProgressType type, int value, int max)
-    {
-        _progressCallbacks.forEach((x) {
-          x(type, value, max);
-        });
-    }
+  AsyncReply<T> triggerProgress(ProgressType type, int value, int max) {
+    _progressCallbacks.forEach((x) {
+      x(type, value, max);
+    });
 
-    
-    triggerChunk(T value)
-    {
-        _chunkCallbacks.forEach((x) {
-            x(value);
-        });
-    }
+    return this;
+  }
 
+  AsyncReply<T> triggerChunk(T value) {
+    _chunkCallbacks.forEach((x) {
+      x(value);
+    });
 
-    AsyncReply.ready(T result)
-    {
-        _resultReady = true;
-        _result = result;
-    }
+    return this;
+  }
 
-    AsyncReply()
-    {
+  AsyncReply.ready(T result) {
+    _resultReady = true;
+    _result = result;
+  }
 
-    }
-
-}
+  AsyncReply() {}
+}

lib/src/Core/ExceptionCode.dart

@@ -31,5 +31,9 @@ enum ExceptionCode
         SetPropertyDenied,
         ReadOnlyProperty,
         GeneralFailure,
-        AddToStoreFailed
+        AddToStoreFailed,
+        NotAttached,
+        AlreadyListened,
+        AlreadyUnlistened,
+        NotListenable
 }

lib/src/Core/IEventHandler.dart

@@ -22,7 +22,7 @@ class IEventHandler
 
         return false;
     }
-
+    
     on(String event, Function callback)
     {
         event = event.toLowerCase();