- Typed arrays should implement all methods from Collection and List interfaces.

runtime/lib/byte_array.dart

 // Copyright (c) 2012, 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.
 
 interface ByteArray {
   int lengthInBytes();
 
   ByteArray subByteArray([int start, int length]);
 
   int getInt8(int byteOffset);
@@ skipping 222 matching lines @@
     return new _Float64Array(length);
   }
 
   factory Float64List.view(ByteArray array, [int start, int length]) {
     return new _Float64ArrayView(array, start, length);
   }
 }
 
 
 abstract class _ByteArrayBase {
+
+  // Methods implementing the Collection interface.
+
+  void forEach(void f(element)) {
+    var len = this.length;
+    for (var i = 0; i < len; i++) {
+      f(this[i]);
+    }
+  }
+
+  Collection map(f(element)) {
+    return Collections.map(this,
+                           new GrowableObjectArray.withCapacity(length),

[Anders Johnsen, 2012/05/11 08:38:54]

This could be end up slowing down some users code. You think we could do it by
creating new object of the same type?

+                           f);
+  }
+
+  Collection filter(bool f(element)) {
+    return Collections.filter(this, new GrowableObjectArray(), f);

[Anders Johnsen, 2012/05/11 08:38:54]

Ditto.

+  }
+
+  bool every(bool f(element)) {
+    return Collections.every(this, f);
+  }
+
+  bool some(bool f(element)) {
+    return Collections.some(this, f);;
+  }
+
+  bool isEmpty() {
+    return this.length === 0;
+  }
+
+  int get length() {
+    return _length();
+  }
+
+  // Methods implementing the List interface.
+
+  set length(newLength) {
+    throw const UnsupportedOperationException(
+        "Cannot resize a non-extendable array");
+  }
+
   void add(value) {
     throw const UnsupportedOperationException(
         "Cannot add to a non-extendable array");
   }
 
   void addLast(value) {
     throw const UnsupportedOperationException(
         "Cannot add to a non-extendable array");
   }
 
   void addAll(Collection value) {
     throw const UnsupportedOperationException(
         "Cannot add to a non-extendable array");
   }
 
+  void sort(int compare(a, b)) {
+    DualPivotQuicksort.sort(this, compare);
+  }
+
+  int indexOf(element, [int start = 0]) {
+    return Arrays.indexOf(this, element, start, this.length);
+  }
+
+  int lastIndexOf(element, [int start = null]) {
+    if (start === null) start = length - 1;
+    return Arrays.lastIndexOf(this, element, start);
+  }
+
   void clear() {
     throw const UnsupportedOperationException(
         "Cannot remove from a non-extendable array");
   }
 
-  int indexOf(element, [int start = 0]) {
-    for (int i = start; i < length; i++) {
-      if (this[i] == element) return i;
-    }
-    return -1;
-  }
-
-  void insertRange(int start, int length, [initialValue]) {
-    throw const UnsupportedOperationException(
-        "Cannot add to a non-extendable array");
-  }
-
-  int get length() {
-    return _length();
-  }
-
-  set length(newLength) {
-    throw const UnsupportedOperationException(
-        "Cannot resize a non-extendable array");
-  }
-
   int removeLast() {
     throw const UnsupportedOperationException(
         "Cannot remove from a non-extendable array");
   }
 
+  last() {
+    return this[length - 1];
+  }
+
   void removeRange(int start, int length) {
     throw const UnsupportedOperationException(
         "Cannot remove from a non-extendable array");
   }
 
+  void insertRange(int start, int length, [initialValue]) {
+    throw const UnsupportedOperationException(
+        "Cannot add to a non-extendable array");
+  }
+
   ByteArray asByteArray([int start = 0, int length]) {
     if (length === null) {
       length = this.lengthInBytes();
     }
     return new _ByteArrayView(this, start, length);
   }
 
   int _length() native "ByteArray_getLength";
 
   void _setRange(int startInBytes, int lengthInBytes,
@@ skipping 1336 matching lines @@
     _array._setFloat64(_offset + byteOffset, value);
   }
 
   final _ByteArrayBase _array;
   final int _offset;
   final int _length;
 }
 
 
 class _ByteArrayViewBase {
+
+  // Methods implementing the Collection interface.
+
+  void forEach(void f(element)) {
+    var len = this.length;
+    for (var i = 0; i < len; i++) {
+      f(this[i]);
+    }
+  }
+
+  Collection map(f(element)) {
+    return Collections.map(this,
+                           new GrowableObjectArray.withCapacity(length),
+                           f);
+  }
+
+  Collection filter(bool f(element)) {
+    return Collections.filter(this, new GrowableObjectArray(), f);
+  }
+
+  bool every(bool f(element)) {
+    return Collections.every(this, f);
+  }
+
+  bool some(bool f(element)) {
+    return Collections.some(this, f);;
+  }
+
+  bool isEmpty() {
+    return this.length === 0;
+  }
+
+  int get length() {
+    return _length();
+  }
+
+  // Methods implementing the List interface.
+
+  set length(newLength) {
+    throw const UnsupportedOperationException(
+        "Cannot resize a non-extendable array");
+  }
+
   void add(value) {
     throw const UnsupportedOperationException(
         "Cannot add to a non-extendable array");
   }
 
   void addLast(value) {
     throw const UnsupportedOperationException(
         "Cannot add to a non-extendable array");
   }
 
   void addAll(Collection value) {
     throw const UnsupportedOperationException(
         "Cannot add to a non-extendable array");
   }
 
+  void sort(int compare(a, b)) {
+    DualPivotQuicksort.sort(this, compare);
+  }
+
+  int indexOf(element, [int start = 0]) {
+    return Arrays.indexOf(this, element, start, this.length);
+  }
+
+  int lastIndexOf(element, [int start = null]) {
+    if (start === null) start = length - 1;
+    return Arrays.lastIndexOf(this, element, start);
+  }
+
   void clear() {
     throw const UnsupportedOperationException(
         "Cannot remove from a non-extendable array");
   }
 
-  void insertRange(int start, int length, [initialValue]) {
-    throw const UnsupportedOperationException(
-        "Cannot add to a non-extendable array");
-  }
-
-  set length(int newLength) {
-    throw const UnsupportedOperationException(
-        "Cannot resize a non-extendable array");
-  }
-
   int removeLast() {
     throw const UnsupportedOperationException(
         "Cannot remove from a non-extendable array");
   }
 
+  last() {
+    return this[length - 1];
+  }
+
   void removeRange(int start, int length) {
     throw const UnsupportedOperationException(
         "Cannot remove from a non-extendable array");
   }
+
+  void insertRange(int start, int length, [initialValue]) {
+    throw const UnsupportedOperationException(
+        "Cannot add to a non-extendable array");
+  }
 }
 
 
 class _Int8ArrayView extends _ByteArrayViewBase implements Int8List {
   _Int8ArrayView(ByteArray array, [int offsetInBytes = 0, int length])
     : _array = array,
       _offset = offsetInBytes,
       _length = (length === null) ? (array.lengthInBytes() - offsetInBytes)
     : length {
     if (offsetInBytes < 0 || offsetInBytes >= array.lengthInBytes()) {
@@ skipping 27 matching lines @@
     return new _ByteArrayIterator<int>(this);
   }
 
   List<int> getRange(int start, int length) {
     _rangeCheck(this, start, length);
     List<int> result = new Int8List(length);
     result.setRange(0, length, this, start);
     return result;
   }
 
   void setRange(int start, int length, List<int> from, [int startFrom = 0]) {

[Anders Johnsen, 2012/05/11 08:52:13]

I was wondering if we should change this to a call to ByteArray._setRange, or if
the Arrays.copy version is optimized for these native types?

     Arrays.copy(from, startFrom, this, start, length);
   }
 
   String toString() {
     return Collections.collectionToString(this);
   }
 
   int bytesPerElement() {
     return _BYTES_PER_ELEMENT;
   }
@@ skipping 683 matching lines @@
     }
     _rangeCheck(start, length);
     return _array.subByteArray(_offset + start, length);
   }
 
   static final int _BYTES_PER_ELEMENT = 8;
   final ByteArray _array;
   final int _offset;
   final int _length;
 }