Add Uint32x4List to typed_data

runtime/lib/typed_data.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.
 
 // patch classes for Int8List ..... Float64List and ByteData implementations.
 
 patch class Int8List {
   /* patch */ factory Int8List(int length) {
     return new _Int8Array(length);
   }
@@ skipping 226 matching lines @@
     return result;
   }
 
   /* patch */ factory Float32x4List.view(ByteBuffer buffer,
                                          [int offsetInBytes = 0, int length]) {
     return new _Float32x4ArrayView(buffer, offsetInBytes, length);
   }
 }
 
 
+patch class Uint32x4List {
+  /* patch */ factory Uint32x4List(int length) {
+    return new _Uint32x4Array(length);
+  }
+
+  /* patch */ factory Uint32x4List.fromList(List<Uint32x4> elements) {
+    var result = new _Uint32x4Array(elements.length);
+    for (int i = 0; i < elements.length; i++) {
+      result[i] = elements[i];
+    }
+    return result;
+  }
+
+  /* patch */ factory Uint32x4List.view(ByteBuffer buffer,
+                                        [int offsetInBytes = 0, int length]) {
+    return new _Uint32x4ArrayView(buffer, offsetInBytes, length);
+  }
+}
+
+
 patch class Float32x4 {
   /* patch */ factory Float32x4(double x, double y, double z, double w) {
     return new _Float32x4(x, y, z, w);
   }
   /* patch */ factory Float32x4.splat(double v) {
     return new _Float32x4.splat(v);
   }
   /* patch */ factory Float32x4.zero() {
     return new _Float32x4.zero();
   }
@@ skipping 326 matching lines @@
   void _setFloat32(int offsetInBytes, double value)
       native "TypedData_SetFloat32";
 
   double _getFloat64(int offsetInBytes) native "TypedData_GetFloat64";
   void _setFloat64(int offsetInBytes, double value)
       native "TypedData_SetFloat64";
 
   Float32x4 _getFloat32x4(int offsetInBytes) native "TypedData_GetFloat32x4";
   void _setFloat32x4(int offsetInBytes, Float32x4 value)
       native "TypedData_SetFloat32x4";
+
+  Uint32x4 _getUint32x4(int offsetInBytes) native "TypedData_GetUint32x4";
+  void _setUint32x4(int offsetInBytes, Uint32x4 value)
+      native "TypedData_SetUint32x4";
 }
 
 
 class _Int8Array extends _TypedList implements Int8List {
   // Factory constructors.
 
   factory _Int8Array(int length) {
     return _new(length);
   }
 
@@ skipping 646 matching lines @@
     return _getFloat64(index * Float64List.BYTES_PER_ELEMENT);
   }
 
   void _setIndexedFloat64(int index, double value) {
     _setFloat64(index * Float64List.BYTES_PER_ELEMENT, value);
   }
 
   static _Float64Array _new(int length) native "TypedData_Float64Array_new";
 }
 
+
 class _Float32x4Array extends _TypedList implements Float32x4List {
   // Factory constructors.
 
   factory _Float32x4Array(int length) {
     return _new(length);
   }
 
   factory _Float32x4Array.view(ByteBuffer buffer,
                                [int offsetInBytes = 0, int length]) {
     if (length == null) {
@@ skipping 41 matching lines @@
   }
 
   void _setIndexedFloat32x4(int index, Float32x4 value) {
     _setFloat32x4(index * Float32x4List.BYTES_PER_ELEMENT, value);
   }
 
   static _Float32x4Array _new(int length) native "TypedData_Float32x4Array_new";
 }
 
 
+class _Uint32x4Array extends _TypedList implements Uint32x4List {
+  // Factory constructors.
+
+  factory _Uint32x4Array(int length) {
+    return _new(length);
+  }
+
+  factory _Uint32x4Array.view(ByteBuffer buffer,
+                              [int offsetInBytes = 0, int length]) {
+    if (length == null) {
+      length = (buffer.lengthInBytes - offsetInBytes) ~/
+               Uint32x4List.BYTES_PER_ELEMENT;
+    }
+    return new _Uint32x4ArrayView(buffer, offsetInBytes, length);
+  }
+
+
+  Uint32x4 operator[](int index) {
+    if (index < 0 || index >= length) {
+      _throwRangeError(index, length);
+    }
+    return _getIndexedUint32x4(index);
+  }
+
+  void operator[]=(int index, Uint32x4 value) {
+    if (index < 0 || index >= length) {
+      _throwRangeError(index, length);
+    }
+    _setIndexedUint32x4(index, value);
+  }
+
+  Iterator<Uint32x4> get iterator {
+    return new _TypedListIterator<Uint32x4>(this);
+  }
+
+
+  // Method(s) implementing the TypedData interface.
+
+  int get elementSizeInBytes {
+    return Uint32x4List.BYTES_PER_ELEMENT;
+  }
+
+
+  // Internal utility methods.
+
+  _Uint32x4Array _createList(int length) {
+    return _new(length);
+  }
+
+  Uint32x4 _getIndexedUint32x4(int index) {
+    return _getUint32x4(index * Uint32x4List.BYTES_PER_ELEMENT);
+  }
+
+  void _setIndexedUint32x4(int index, Uint32x4 value) {
+    _setUint32x4(index * Uint32x4List.BYTES_PER_ELEMENT, value);
+  }
+
+  static _Uint32x4Array _new(int length) native "TypedData_Uint32x4Array_new";
+}
+
+
 class _ExternalInt8Array extends _TypedList implements Int8List {
   // Factory constructors.
 
   factory _ExternalInt8Array(int length) {
     return _new(length);
   }
 
 
   // Method(s) implementing the List interface.
   int operator[](int index) {
@@ skipping 615 matching lines @@
 
   void _setIndexedFloat32x4(int index, Float32x4 value) {
     _setFloat32x4(index * Float32x4List.BYTES_PER_ELEMENT, value);
   }
 
   static _ExternalFloat32x4Array _new(int length) native
       "ExternalTypedData_Float32x4Array_new";
 }
 
 
+class _ExternalUint32x4Array extends _TypedList implements Uint32x4List {
+  // Factory constructors.
+
+  factory _ExternalUint32x4Array(int length) {
+    return _new(length);
+  }
+
+
+  // Method(s) implementing the List interface.
+
+  Uint32x4 operator[](int index) {
+    if (index < 0 || index >= length) {
+      _throwRangeError(index, length);
+    }
+    return _getIndexedUint32x4(index);
+  }
+
+  void operator[]=(int index, Uint32x4 value) {
+    if (index < 0 || index >= length) {
+      _throwRangeError(index, length);
+    }
+    _setIndexedUint32x4(index, value);
+  }
+
+  Iterator<Uint32x4> get iterator {
+    return new _TypedListIterator<Uint32x4>(this);
+  }
+
+
+  // Method(s) implementing the TypedData interface.
+
+  int get elementSizeInBytes {
+    return Uint32x4List.BYTES_PER_ELEMENT;
+  }
+
+
+  // Internal utility methods.
+
+  Uint32x4List _createList(int length) {
+    return new Uint32x4List(length);
+  }
+
+  Uint32x4 _getIndexedUint32x4(int index) {
+    return _getUint32x4(index * Uint32x4List.BYTES_PER_ELEMENT);
+  }
+
+  void _setIndexedUint32x4(int index, Uint32x4 value) {
+    _setUint32x4(index * Uint32x4List.BYTES_PER_ELEMENT, value);
+  }
+
+  static _ExternalUint32x4Array _new(int length) native
+      "ExternalTypedData_Uint32x4Array_new";
+}
+
+
 class _Float32x4 implements Float32x4 {
   factory _Float32x4(double x, double y, double z, double w)
       native "Float32x4_fromDoubles";
   factory _Float32x4.splat(double v) native "Float32x4_splat";
   factory _Float32x4.zero() native "Float32x4_zero";
   factory _Float32x4.fromUint32x4Bits(Uint32x4 x)
       native "Float32x4_fromUint32x4Bits";
   Float32x4 operator +(Float32x4 other) {
     return _add(other);
   }
@@ skipping 817 matching lines @@
 
 
   // Internal utility methods.
 
   Float32x4List _createList(int length) {
     return new Float32x4List(length);
   }
 }
 
 
+class _Uint32x4ArrayView extends _TypedListView implements Uint32x4List {
+  // Constructor.
+  _Uint32x4ArrayView(ByteBuffer buffer, [int _offsetInBytes = 0, int _length])
+    : super(buffer, _offsetInBytes,
+            _defaultIfNull(_length,
+                           ((buffer.lengthInBytes - _offsetInBytes) ~/
+                            Uint32x4List.BYTES_PER_ELEMENT))) {
+    _rangeCheck(buffer.lengthInBytes,
+                offsetInBytes,
+                length * Uint32x4List.BYTES_PER_ELEMENT);
+    _offsetAlignmentCheck(_offsetInBytes, Uint32x4List.BYTES_PER_ELEMENT);
+  }
+
+
+  // Method(s) implementing List interface.
+
+  Uint32x4 operator[](int index) {
+    if (index < 0 || index >= length) {
+      _throwRangeError(index, length);
+    }
+    return _typedData._getUint32x4(offsetInBytes +
+                                   (index * Uint32x4List.BYTES_PER_ELEMENT));
+  }
+
+  void operator[]=(int index, Uint32x4 value) {
+    if (index < 0 || index >= length) {
+      _throwRangeError(index, length);
+    }
+    _typedData._setUint32x4(offsetInBytes +
+                            (index * Uint32x4List.BYTES_PER_ELEMENT), value);
+  }
+
+  Iterator<Uint32x4> get iterator {
+    return new _TypedListIterator<Uint32x4>(this);
+  }
+
+
+  // Method(s) implementing TypedData interface.
+
+  int get elementSizeInBytes {
+    return Uint32x4List.BYTES_PER_ELEMENT;
+  }
+
+
+  // Internal utility methods.
+
+  Uint32x4List _createList(int length) {
+    return new Uint32x4List(length);
+  }
+}
+
+
 class _ByteDataView implements ByteData {
   _ByteDataView(ByteBuffer _buffer, int _offsetInBytes, int _lengthInBytes)
     : _typedData = _buffer,  // _buffer is guaranteed to be a TypedData here.
       _offset = _offsetInBytes,
       length = _lengthInBytes {
     _rangeCheck(_buffer.lengthInBytes, _offset, length);
   }
 
 
   // Method(s) implementing TypedData interface.
@@ skipping 351 matching lines @@
     return value;
   }
   return object;
 }
 
 
 void _throwRangeError(int index, int length) {
   String message = "$index must be in the range [0..$length)";
   throw new RangeError(message);
 }