add JsArray and JsObject.asJsMap()

sdk/lib/js/dartium/js_dartium.dart

 // Copyright (c) 2013, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 /**
  * The js.dart library provides simple JavaScript invocation from Dart that
  * works on both Dartium and on other modern browsers via Dart2JS.
  *
  * It provides a model based on scoped [JsObject] objects.  Proxies give Dart
  * code access to JavaScript objects, fields, and functions as well as the
@@ skipping 48 matching lines @@
  *     var foo = new JsObject(context['Foo'], [42]);
  *     var foo2 = foo.callMethod('add', [foo]);
  *     print(foo2['x']);
  *
  * will construct a JavaScript Foo object with the parameter 42, invoke its
  * add method, and return a [JsObject] to a new Foo object whose x field is 84.
  */
 
 library dart.js;
 
+import 'dart:collection' show ListMixin, Maps;
 import 'dart:html';
 import 'dart:isolate';
 
 // Global ports to manage communication from Dart to JS.
 SendPortSync _jsPortSync = window.lookupPort('dart-js-context');
 SendPortSync _jsPortCreate = window.lookupPort('dart-js-create');
 SendPortSync _jsPortInstanceof = window.lookupPort('dart-js-instanceof');
 SendPortSync _jsPortDeleteProperty = window.lookupPort('dart-js-delete-property');
 SendPortSync _jsPortConvert = window.lookupPort('dart-js-convert');
 
@@ skipping 112 matching lines @@
       return _forward(this, 'toString', 'method', []);
     } catch(e) {
       return super.toString();
     }
   }
 
   callMethod(String name, [List args]) {
     return _forward(this, name, 'method', args != null ? args : []);
   }
 
+  Map<String, dynamic> asDartMap() => new _JsObjectAsMap(this);
+
   // Forward member accesses to the backing JavaScript object.
   static _forward(JsObject receiver, String member, String kind, List args) {
     var result = receiver._port.callSync([receiver._id, member, kind,
                                           args.map(_serialize).toList()]);
     switch (result[0]) {
       case 'return': return _deserialize(result[1]);
       case 'throws': throw _deserialize(result[1]);
       case 'none': throw new NoSuchMethodError(receiver, member, args, {});
       default: throw 'Invalid return value';
     }
   }
 }
 
 /// A [JsObject] subtype to JavaScript functions.
 class JsFunction extends JsObject implements Serializable<JsFunction> {
   JsFunction._internal(SendPortSync port, String id)
       : super._internal(port, id);
 
   apply(thisArg, [List args]) {
     return JsObject._forward(this, '', 'apply',
         [thisArg]..addAll(args == null ? [] : args));
   }
 }
 
+/// A [JsObject] subtype for JavaScript arrays.
+class JsArray extends JsObject with ListMixin {
+  JsArray._internal(SendPortSync port, String id) : super._internal(port, id);
+
+  // method to implement for ListMixin
+
+  int get length => super['length'];
+  void set length(int length) { super['length'] = length; }
+  operator [](index) {
+    if (index is int && (index < 0 || index >= this.length)) {
+      throw new RangeError.value(index);
+    }
+    return super[index];
+  }
+  void operator []=(index, value) {
+    if (index is int && (index < 0 || index >= this.length)) {
+      throw new RangeError.value(index);
+    }
+    super[index] = value;
+  }
+
+  // overriden methods for better performance
+
+  void add(value) { callMethod('push', [value]); }
+  void addAll(Iterable iterable) { callMethod('push', iterable.toList()); }
+  void sort([int compare(a, b)]) {
+    final sortedList = toList()..sort(compare);
+    setRange(0, sortedList.length, sortedList);
+  }
+  void insert(int index, element) {
+    callMethod('splice', [index, 0, element]);
+  }
+  removeAt(int index) {
+    if (index < 0 || index >= this.length) throw new RangeError.value(index);
+    return callMethod('splice', [index, 1])[0];
+  }
+  removeLast() => callMethod('pop');
+  void setRange(int start, int length, List from,
+                              [int startFrom = 0]) {
+    final args = [start, length];
+    for(int i = startFrom; i < startFrom + length; i++) {
+      args.add(from[i]);
+    }
+    callMethod('splice', args);
+  }
+  void removeRange(int start, int end) {
+    callMethod('splice', [start, end - start]);
+  }
+}
+
+class _JsObjectAsMap implements Map<String, dynamic> {
+  JsObject _jsObject;
+
+  _JsObjectAsMap(this._jsObject);
+
+  operator [](String key) => _jsObject[key];
+  void operator []=(String key, value) {
+    _jsObject[key] = value;
+  }
+  remove(String key) {
+    final value = this[key];
+    _jsObject.deleteProperty(key);
+    return value;
+  }
+  Iterable<String> get keys =>
+      context['Object'].callMethod('keys', [_jsObject]);
+
+  bool containsValue(value) =>
+      JsObject._forward(_jsObject, 'containsValue', 'asMap', [value]);
+  bool containsKey(String key) => _jsObject.hasProperty(key);
+  putIfAbsent(String key, ifAbsent()) => Maps.putIfAbsent(this, key, ifAbsent);
+  void addAll(Map<String, dynamic> other) {
+    if (other != null) {
+      JsObject._forward(_jsObject, 'addAll', 'asMap', [jsify(other)]);
+    }
+  }
+  void clear() => Maps.clear(this);
+  void forEach(void f(String key, value)) => Maps.forEach(this, f);
+  Iterable get values =>
+      JsObject._forward(_jsObject, 'values', 'asMap', []);
+  int get length =>
+      JsObject._forward(_jsObject, 'length', 'asMap', []);
+  bool get isEmpty => Maps.isEmpty(this);
+  bool get isNotEmpty => Maps.isNotEmpty(this);
+}
+
 /// Marker class used to indicate it is serializable to js. If a class is a
 /// [Serializable] the "toJs" method will be called and the result will be used
 /// as value.
 abstract class Serializable<T> {
   T toJs();
 }
 
 // A table to managed local Dart objects that are proxied in JavaScript.
 class _ProxiedObjectTable {
   // Debugging name.
@@ skipping 76 matching lines @@
     // Remote function proxy.
     return [ 'funcref', message._id, message._port ];
   } else if (message is JsObject) {
     // Remote object proxy.
     return [ 'objref', message._id, message._port ];
   } else if (message is Serializable) {
     // use of result of toJs()
     return _serialize(message.toJs());
   } else if (message is Function) {
     return _serialize(new Callback(message));
+  } else if (message is Map) {
+    return _serialize(jsify(message));
+  } else if (message is Iterable) {
+    return _serialize(jsify(message));
   } else {
     // Local object proxy.
     return [ 'objref',
              _proxiedObjectTable.add(message),
              _proxiedObjectTable.sendPort ];
   }
 }
 
 _deserialize(var message) {
   deserializeFunction(message) {
@@ skipping 13 matching lines @@
     var port = message[2];
     if (port == _proxiedObjectTable.sendPort) {
       // Local object.
       return _proxiedObjectTable.get(id);
     } else {
       // Remote object.
       return new JsObject._internal(port, id);
     }
   }
 
+  deserializeArray(message) {
+    var id = message[1];
+    var port = message[2];
+    return new JsArray._internal(port, id);
+  }
+
   if (message == null) {
     return null;  // Convert undefined to null.
   } else if (message is String ||
              message is num ||
              message is bool) {
     // Primitives are passed directly through.
     return message;
   } else if (message is SendPortSync) {
     // Serialized type.
     return message;
   }
   var tag = message[0];
   switch (tag) {
     case 'funcref': return deserializeFunction(message);
     case 'objref': return deserializeObject(message);
+    case 'arrayref': return deserializeArray(message);
   }
   throw 'Unsupported serialized data: $message';
 }