Rename dart:typeddata to dart: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 2173 matching lines @@
     _current = null;
     return false;
   }
 
   E get current => _current;
 }
 
 
 class _TypedListView extends _TypedListBase implements TypedData {
   _TypedListView(ByteBuffer _buffer, int _offset, int _length)
-    : _typeddata = _buffer,  // This assignment is type safe.
+    : _typedData = _buffer,  // This assignment is type safe.
       offsetInBytes = _offset,
       length = _length {
   }
 
 
   // Method(s) implementing the TypedData interface.
 
   int get lengthInBytes {
     return length * elementSizeInBytes;
   }
 
   ByteBuffer get buffer {
-    return _typeddata.buffer;
+    return _typedData.buffer;
   }
 
-  final TypedData _typeddata;
+  final TypedData _typedData;
   final int offsetInBytes;
   final int length;
 }
 
 
 class _Int8ArrayView extends _TypedListView implements Int8List {
   // Constructor.
   _Int8ArrayView(ByteBuffer buffer, [int _offsetInBytes = 0, int _length])
     : super(buffer, _offsetInBytes,
             _defaultIfNull(_length,
                            ((buffer.lengthInBytes - _offsetInBytes) ~/
                             Int8List.BYTES_PER_ELEMENT))) {
     _rangeCheck(buffer.lengthInBytes,
                 _offsetInBytes,
                 length * Int8List.BYTES_PER_ELEMENT);
   }
 
 
   // Method(s) implementing List interface.
 
   int operator[](int index) {
     if (index < 0 || index >= length) {
       _throwRangeError(index, length);
     }
-    return _typeddata._getInt8(offsetInBytes +
+    return _typedData._getInt8(offsetInBytes +
                                (index * Int8List.BYTES_PER_ELEMENT));
   }
 
   void operator[]=(int index, int value) {
     if (index < 0 || index >= length) {
       _throwRangeError(index, length);
     }
-    _typeddata._setInt8(offsetInBytes + (index * Int8List.BYTES_PER_ELEMENT),
+    _typedData._setInt8(offsetInBytes + (index * Int8List.BYTES_PER_ELEMENT),
                         _toInt8(value));
   }
 
   Iterator<int> get iterator {
     return new _TypedListIterator<int>(this);
   }
 
 
   // Method(s) implementing TypedData interface.
 
@@ skipping 22 matching lines @@
                 length * Uint8List.BYTES_PER_ELEMENT);
   }
 
 
   // Method(s) implementing List interface.
 
   int operator[](int index) {
     if (index < 0 || index >= length) {
       _throwRangeError(index, length);
     }
-    return _typeddata._getUint8(offsetInBytes +
+    return _typedData._getUint8(offsetInBytes +
                                 (index * Uint8List.BYTES_PER_ELEMENT));
   }
 
   void operator[]=(int index, int value) {
     if (index < 0 || index >= length) {
       _throwRangeError(index, length);
     }
-    _typeddata._setUint8(offsetInBytes + (index * Uint8List.BYTES_PER_ELEMENT),
+    _typedData._setUint8(offsetInBytes + (index * Uint8List.BYTES_PER_ELEMENT),
                          _toUint8(value));
   }
 
   Iterator<int> get iterator {
     return new _TypedListIterator<int>(this);
   }
 
 
   // Method(s) implementing TypedData interface.
 
@@ skipping 23 matching lines @@
                 length * Uint8List.BYTES_PER_ELEMENT);
   }
 
 
   // Method(s) implementing List interface.
 
   int operator[](int index) {
     if (index < 0 || index >= length) {
       _throwRangeError(index, length);
     }
-    return _typeddata._getUint8(offsetInBytes +
+    return _typedData._getUint8(offsetInBytes +
                                 (index * Uint8List.BYTES_PER_ELEMENT));
   }
 
   void operator[]=(int index, int value) {
     if (index < 0 || index >= length) {
       _throwRangeError(index, length);
     }
-    _typeddata._setUint8(offsetInBytes + (index * Uint8List.BYTES_PER_ELEMENT),
+    _typedData._setUint8(offsetInBytes + (index * Uint8List.BYTES_PER_ELEMENT),
                          _toClampedUint8(value));
   }
 
   Iterator<int> get iterator {
     return new _TypedListIterator<int>(this);
   }
 
 
   // Method(s) implementing TypedData interface.
 
@@ skipping 22 matching lines @@
                 length * Int16List.BYTES_PER_ELEMENT);
   }
 
 
   // Method(s) implementing List interface.
 
   int operator[](int index) {
     if (index < 0 || index >= length) {
       _throwRangeError(index, length);
     }
-    return _typeddata._getInt16(offsetInBytes +
+    return _typedData._getInt16(offsetInBytes +
                                 (index * Int16List.BYTES_PER_ELEMENT));
   }
 
   void operator[]=(int index, int value) {
     if (index < 0 || index >= length) {
       _throwRangeError(index, length);
     }
-    _typeddata._setInt16(offsetInBytes + (index * Int16List.BYTES_PER_ELEMENT),
+    _typedData._setInt16(offsetInBytes + (index * Int16List.BYTES_PER_ELEMENT),
                          _toInt16(value));
   }
 
   Iterator<int> get iterator {
     return new _TypedListIterator<int>(this);
   }
 
 
   // Method(s) implementing TypedData interface.
 
@@ skipping 22 matching lines @@
                 length * Uint16List.BYTES_PER_ELEMENT);
   }
 
 
   // Method(s) implementing List interface.
 
   int operator[](int index) {
     if (index < 0 || index >= length) {
       _throwRangeError(index, length);
     }
-    return _typeddata._getUint16(offsetInBytes +
+    return _typedData._getUint16(offsetInBytes +
                                  (index * Uint16List.BYTES_PER_ELEMENT));
   }
 
   void operator[]=(int index, int value) {
     if (index < 0 || index >= length) {
       _throwRangeError(index, length);
     }
-    _typeddata._setUint16(offsetInBytes + (index * Uint16List.BYTES_PER_ELEMENT),
+    _typedData._setUint16(offsetInBytes + (index * Uint16List.BYTES_PER_ELEMENT),
                           _toUint16(value));
   }
 
   Iterator<int> get iterator {
     return new _TypedListIterator<int>(this);
   }
 
 
   // Method(s) implementing TypedData interface.
 
@@ skipping 22 matching lines @@
                 length * Int32List.BYTES_PER_ELEMENT);
   }
 
 
   // Method(s) implementing List interface.
 
   int operator[](int index) {
     if (index < 0 || index >= length) {
       _throwRangeError(index, length);
     }
-    return _typeddata._getInt32(offsetInBytes +
+    return _typedData._getInt32(offsetInBytes +
                                 (index * Int32List.BYTES_PER_ELEMENT));
   }
 
   void operator[]=(int index, int value) {
     if (index < 0 || index >= length) {
       _throwRangeError(index, length);
     }
-    _typeddata._setInt32(offsetInBytes + (index * Int32List.BYTES_PER_ELEMENT),
+    _typedData._setInt32(offsetInBytes + (index * Int32List.BYTES_PER_ELEMENT),
                          _toInt32(value));
   }
 
   Iterator<int> get iterator {
     return new _TypedListIterator<int>(this);
   }
 
 
   // Method(s) implementing TypedData interface.
 
@@ skipping 22 matching lines @@
                 length * Uint32List.BYTES_PER_ELEMENT);
   }
 
 
   // Method(s) implementing List interface.
 
   int operator[](int index) {
     if (index < 0 || index >= length) {
       _throwRangeError(index, length);
     }
-    return _typeddata._getUint32(offsetInBytes +
+    return _typedData._getUint32(offsetInBytes +
                                  (index * Uint32List.BYTES_PER_ELEMENT));
   }
 
   void operator[]=(int index, int value) {
     if (index < 0 || index >= length) {
       _throwRangeError(index, length);
     }
-    _typeddata._setUint32(offsetInBytes + (index * Uint32List.BYTES_PER_ELEMENT),
+    _typedData._setUint32(offsetInBytes + (index * Uint32List.BYTES_PER_ELEMENT),
                           _toUint32(value));
   }
 
   Iterator<int> get iterator {
     return new _TypedListIterator<int>(this);
   }
 
 
   // Method(s) implementing TypedData interface.
 
@@ skipping 22 matching lines @@
                 length * Int64List.BYTES_PER_ELEMENT);
   }
 
 
   // Method(s) implementing List interface.
 
   int operator[](int index) {
     if (index < 0 || index >= length) {
       _throwRangeError(index, length);
     }
-    return _typeddata._getInt64(offsetInBytes +
+    return _typedData._getInt64(offsetInBytes +
                                 (index * Int64List.BYTES_PER_ELEMENT));
   }
 
   void operator[]=(int index, int value) {
     if (index < 0 || index >= length) {
       _throwRangeError(index, length);
     }
-    _typeddata._setInt64(offsetInBytes + (index * Int64List.BYTES_PER_ELEMENT),
+    _typedData._setInt64(offsetInBytes + (index * Int64List.BYTES_PER_ELEMENT),
                          _toInt64(value));
   }
 
   Iterator<int> get iterator {
     return new _TypedListIterator<int>(this);
   }
 
 
   // Method(s) implementing TypedData interface.
 
@@ skipping 22 matching lines @@
                 length * Uint64List.BYTES_PER_ELEMENT);
   }
 
 
   // Method(s) implementing List interface.
 
   int operator[](int index) {
     if (index < 0 || index >= length) {
       _throwRangeError(index, length);
     }
-    return _typeddata._getUint64(offsetInBytes +
+    return _typedData._getUint64(offsetInBytes +
                                  (index * Uint64List.BYTES_PER_ELEMENT));
   }
 
   void operator[]=(int index, int value) {
     if (index < 0 || index >= length) {
       _throwRangeError(index, length);
     }
-    _typeddata._setUint64(offsetInBytes + (index * Uint64List.BYTES_PER_ELEMENT),
+    _typedData._setUint64(offsetInBytes + (index * Uint64List.BYTES_PER_ELEMENT),
                           _toUint64(value));
   }
 
   Iterator<int> get iterator {
     return new _TypedListIterator<int>(this);
   }
 
 
   // Method(s) implementing TypedData interface.
 
@@ skipping 22 matching lines @@
                 length * Float32List.BYTES_PER_ELEMENT);
   }
 
 
   // Method(s) implementing List interface.
 
   double operator[](int index) {
     if (index < 0 || index >= length) {
       _throwRangeError(index, length);
     }
-    return _typeddata._getFloat32(offsetInBytes +
+    return _typedData._getFloat32(offsetInBytes +
                                   (index * Float32List.BYTES_PER_ELEMENT));
   }
 
   void operator[]=(int index, double value) {
     if (index < 0 || index >= length) {
       _throwRangeError(index, length);
     }
-    _typeddata._setFloat32(offsetInBytes +
+    _typedData._setFloat32(offsetInBytes +
                            (index * Float32List.BYTES_PER_ELEMENT), value);
   }
 
   Iterator<double> get iterator {
     return new _TypedListIterator<double>(this);
   }
 
 
   // Method(s) implementing TypedData interface.
 
@@ skipping 22 matching lines @@
                 length * Float64List.BYTES_PER_ELEMENT);
   }
 
 
   // Method(s) implementing List interface.
 
   double operator[](int index) {
     if (index < 0 || index >= length) {
       _throwRangeError(index, length);
     }
-    return _typeddata._getFloat64(offsetInBytes +
+    return _typedData._getFloat64(offsetInBytes +
                                   (index * Float64List.BYTES_PER_ELEMENT));
   }
 
   void operator[]=(int index, double value) {
     if (index < 0 || index >= length) {
       _throwRangeError(index, length);
     }
-    _typeddata._setFloat64(offsetInBytes +
+    _typedData._setFloat64(offsetInBytes +
                           (index * Float64List.BYTES_PER_ELEMENT), value);
   }
 
   Iterator<double> get iterator {
     return new _TypedListIterator<double>(this);
   }
 
 
   // Method(s) implementing TypedData interface.
 
@@ skipping 22 matching lines @@
                 length * Float32x4List.BYTES_PER_ELEMENT);
   }
 
 
   // Method(s) implementing List interface.
 
   Float32x4 operator[](int index) {
     if (index < 0 || index >= length) {
       _throwRangeError(index, length);
     }
-    return _typeddata._getFloat32x4(offsetInBytes +
+    return _typedData._getFloat32x4(offsetInBytes +
                                   (index * Float32x4List.BYTES_PER_ELEMENT));
   }
 
   void operator[]=(int index, Float32x4 value) {
     if (index < 0 || index >= length) {
       _throwRangeError(index, length);
     }
-    _typeddata._setFloat32x4(offsetInBytes +
+    _typedData._setFloat32x4(offsetInBytes +
                              (index * Float32x4List.BYTES_PER_ELEMENT), value);
   }
 
   Iterator<Float32x4> get iterator {
     return new _TypedListIterator<Float32x4>(this);
   }
 
 
   // Method(s) implementing TypedData interface.
 
   int get elementSizeInBytes {
     return Float32x4List.BYTES_PER_ELEMENT;
   }
 
 
   // Internal utility methods.
 
   Float32x4List _createList(int length) {
     return new Float32x4List(length);
   }
 }
 
 
 class _ByteDataView implements ByteData {
   _ByteDataView(ByteBuffer _buffer, int _offsetInBytes, int _lengthInBytes)
-    : _typeddata = _buffer,  // _buffer is guaranteed to be a TypedData here.
+    : _typedData = _buffer,  // _buffer is guaranteed to be a TypedData here.
       _offset = _offsetInBytes,
       length = _lengthInBytes {
     _rangeCheck(_buffer.lengthInBytes, _offset, length);
   }
 
 
   // Method(s) implementing TypedData interface.
 
   ByteBuffer get buffer {
-    return _typeddata.buffer;
+    return _typedData.buffer;
   }
 
   int get lengthInBytes {
     return length;
   }
 
   int get offsetInBytes {
     return _offset;
   }
 
   // Method(s) implementing ByteData interface.
 
   int getInt8(int byteOffset) {
     if (byteOffset < 0 || byteOffset >= length) {
       _throwRangeError(byteOffset, length);
     }
-    return _typeddata._getInt8(_offset + byteOffset);
+    return _typedData._getInt8(_offset + byteOffset);
   }
   void setInt8(int byteOffset, int value) {
     if (byteOffset < 0 || byteOffset >= length) {
       _throwRangeError(byteOffset, length);
     }
-    _typeddata._setInt8(_offset + byteOffset, _toInt8(value));
+    _typedData._setInt8(_offset + byteOffset, _toInt8(value));
   }
 
   int getUint8(int byteOffset) {
     if (byteOffset < 0 || byteOffset >= length) {
       _throwRangeError(byteOffset, length);
     }
-    return _typeddata._getUint8(_offset + byteOffset);
+    return _typedData._getUint8(_offset + byteOffset);
   }
   void setUint8(int byteOffset, int value) {
     if (byteOffset < 0 || byteOffset >= length) {
       _throwRangeError(byteOffset, length);
     }
-    _typeddata._setUint8(_offset + byteOffset, _toUint8(value));
+    _typedData._setUint8(_offset + byteOffset, _toUint8(value));
   }
 
   int getInt16(int byteOffset, [Endianness endian = Endianness.BIG_ENDIAN]) {
     if (byteOffset < 0 || byteOffset >= length) {
       _throwRangeError(byteOffset, length);
     }
-    var result = _typeddata._getInt16(_offset + byteOffset);
+    var result = _typedData._getInt16(_offset + byteOffset);
     if (identical(endian, Endianness.HOST_ENDIAN)) {
       return result;
     }
     return _toEndianInt16(result, endian._littleEndian);
   }
   void setInt16(int byteOffset,
                 int value,
                 [Endianness endian = Endianness.BIG_ENDIAN]) {
     if (byteOffset < 0 || byteOffset >= length) {
       _throwRangeError(byteOffset, length);
     }
     var set_value = _toInt16(value);
     if (!identical(endian, Endianness.HOST_ENDIAN)) {
       set_value = _toEndianInt16(set_value, endian._littleEndian);
     }
-    _typeddata._setInt16(_offset + byteOffset, set_value);
+    _typedData._setInt16(_offset + byteOffset, set_value);
   }
 
   int getUint16(int byteOffset, [Endianness endian = Endianness.BIG_ENDIAN]) {
     if (byteOffset < 0 || byteOffset >= length) {
       _throwRangeError(byteOffset, length);
     }
-    var result = _typeddata._getUint16(_offset + byteOffset);
+    var result = _typedData._getUint16(_offset + byteOffset);
     if (identical(endian, Endianness.HOST_ENDIAN)) {
       return result;
     }
     return _toEndianUint16(result, endian._littleEndian);
   }
   void setUint16(int byteOffset,
                  int value,
                  [Endianness endian = Endianness.BIG_ENDIAN]) {
     if (byteOffset < 0 || byteOffset >= length) {
       _throwRangeError(byteOffset, length);
     }
     var set_value = _toUint16(value);
     if (!identical(endian, Endianness.HOST_ENDIAN)) {
       set_value = _toEndianUint16(set_value, endian._littleEndian);
     }
-    _typeddata._setUint16(_offset + byteOffset, set_value);
+    _typedData._setUint16(_offset + byteOffset, set_value);
   }
 
   int getInt32(int byteOffset, [Endianness endian = Endianness.BIG_ENDIAN]) {
     if (byteOffset < 0 || byteOffset >= length) {
       _throwRangeError(byteOffset, length);
     }
-    var result = _typeddata._getInt32(_offset + byteOffset);
+    var result = _typedData._getInt32(_offset + byteOffset);
     if (identical(endian, Endianness.HOST_ENDIAN)) {
       return result;
     }
     return _toEndianInt32(result, endian._littleEndian);
   }
   void setInt32(int byteOffset,
                 int value,
                 [Endianness endian = Endianness.BIG_ENDIAN]) {
     if (byteOffset < 0 || byteOffset >= length) {
       _throwRangeError(byteOffset, length);
     }
     var set_value = _toInt32(value);
     if (!identical(endian, Endianness.HOST_ENDIAN)) {
       set_value = _toEndianInt32(set_value, endian._littleEndian);
     }
-    _typeddata._setInt32(_offset + byteOffset, set_value);
+    _typedData._setInt32(_offset + byteOffset, set_value);
   }
 
   int getUint32(int byteOffset, [Endianness endian = Endianness.BIG_ENDIAN]) {
     if (byteOffset < 0 || byteOffset >= length) {
       _throwRangeError(byteOffset, length);
     }
-    var result = _typeddata._getUint32(_offset + byteOffset);
+    var result = _typedData._getUint32(_offset + byteOffset);
     if (identical(endian, Endianness.HOST_ENDIAN)) {
       return result;
     }
     return _toEndianUint32(result, endian._littleEndian);
   }
   void setUint32(int byteOffset,
                  int value,
                  [Endianness endian = Endianness.BIG_ENDIAN]) {
     if (byteOffset < 0 || byteOffset >= length) {
       _throwRangeError(byteOffset, length);
     }
     var set_value = _toUint32(value);
     if (!identical(endian, Endianness.HOST_ENDIAN)) {
       set_value = _toEndianUint32(set_value, endian._littleEndian);
     }
-    _typeddata._setUint32(_offset + byteOffset, set_value);
+    _typedData._setUint32(_offset + byteOffset, set_value);
   }
 
   int getInt64(int byteOffset, [Endianness endian = Endianness.BIG_ENDIAN]) {
     if (byteOffset < 0 || byteOffset >= length) {
       _throwRangeError(byteOffset, length);
     }
-    var result = _typeddata._getInt64(_offset + byteOffset);
+    var result = _typedData._getInt64(_offset + byteOffset);
     if (identical(endian, Endianness.HOST_ENDIAN)) {
       return result;
     }
     return _toEndianInt64(result, endian._littleEndian);
   }
   void setInt64(int byteOffset,
                 int value,
                 [Endianness endian = Endianness.BIG_ENDIAN]) {
     if (byteOffset < 0 || byteOffset >= length) {
       _throwRangeError(byteOffset, length);
     }
     var set_value = _toInt64(value);
     if (!identical(endian, Endianness.HOST_ENDIAN)) {
       set_value = _toEndianInt64(set_value, endian._littleEndian);
     }
-    _typeddata._setInt64(_offset + byteOffset, set_value);
+    _typedData._setInt64(_offset + byteOffset, set_value);
   }
 
   int getUint64(int byteOffset, [Endianness endian = Endianness.BIG_ENDIAN]) {
     if (byteOffset < 0 || byteOffset >= length) {
       _throwRangeError(byteOffset, length);
     }
-    var result = _typeddata._getUint64(_offset + byteOffset);
+    var result = _typedData._getUint64(_offset + byteOffset);
     if (identical(endian, Endianness.HOST_ENDIAN)) {
       return result;
     }
     return _toEndianUint64(result, endian._littleEndian);
   }
   void setUint64(int byteOffset,
                  int value,
                  [Endianness endian = Endianness.BIG_ENDIAN]) {
     if (byteOffset < 0 || byteOffset >= length) {
       _throwRangeError(byteOffset, length);
     }
     var set_value = _toUint64(value);
     if (!identical(endian, Endianness.HOST_ENDIAN)) {
       set_value = _toEndianUint64(set_value, endian._littleEndian);
     }
-    _typeddata._setUint64(_offset + byteOffset, set_value);
+    _typedData._setUint64(_offset + byteOffset, set_value);
   }
 
   double getFloat32(int byteOffset,
                     [Endianness endian = Endianness.BIG_ENDIAN]) {
     if (byteOffset < 0 || byteOffset >= length) {
       _throwRangeError(byteOffset, length);
     }
-    var result = _typeddata._getFloat32(_offset + byteOffset);
+    var result = _typedData._getFloat32(_offset + byteOffset);
     if (identical(endian, Endianness.HOST_ENDIAN)) {
       return result;
     }
     return _toEndianFloat32(result, endian._littleEndian);
   }
   void setFloat32(int byteOffset,
                   double value,
                   [Endianness endian = Endianness.BIG_ENDIAN]) {
     if (byteOffset < 0 || byteOffset >= length) {
       _throwRangeError(byteOffset, length);
     }
     var set_value = value;
     if (!identical(endian, Endianness.HOST_ENDIAN)) {
       set_value = _toEndianFloat32(set_value, endian._littleEndian);
     }
-    _typeddata._setFloat32(_offset + byteOffset, set_value);
+    _typedData._setFloat32(_offset + byteOffset, set_value);
   }
 
   double getFloat64(int byteOffset,
                     [Endianness endian = Endianness.BIG_ENDIAN]) {
     if (byteOffset < 0 || byteOffset >= length) {
       _throwRangeError(byteOffset, length);
     }
-    var result = _typeddata._getFloat64(_offset + byteOffset);
+    var result = _typedData._getFloat64(_offset + byteOffset);
     if (identical(endian, Endianness.HOST_ENDIAN)) {
       return result;
     }
     return _toEndianFloat64(result, endian._littleEndian);
   }
   void setFloat64(int byteOffset,
                   double value,
                   [Endianness endian = Endianness.BIG_ENDIAN]) {
     if (byteOffset < 0 || byteOffset >= length) {
       _throwRangeError(byteOffset, length);
     }
     var set_value = value;
     if (!identical(endian, Endianness.HOST_ENDIAN)) {
       set_value = _toEndianFloat64(set_value, endian._littleEndian);
     }
-    _typeddata._setFloat64(_offset + byteOffset, set_value);
+    _typedData._setFloat64(_offset + byteOffset, set_value);
   }
 
   Float32x4 getFloat32x4(int byteOffset,
                          [Endianness endian = Endianness.BIG_ENDIAN]) {
     if (byteOffset < 0 || byteOffset >= length) {
       _throwRangeError(byteOffset, length);
     }
     // TODO(johnmccutchan) : Need to resolve this for endianity.
-    return _typeddata._getFloat32x4(_offset + byteOffset);
+    return _typedData._getFloat32x4(_offset + byteOffset);
   }
   void setFloat32x4(int byteOffset,
                     Float32x4 value,
                     [Endianness endian = Endianness.BIG_ENDIAN]) {
     if (byteOffset < 0 || byteOffset >= length) {
       _throwRangeError(byteOffset, length);
     }
     // TODO(johnmccutchan) : Need to resolve this for endianity.
-    _typeddata._setFloat32x4(_offset + byteOffset, value);
+    _typedData._setFloat32x4(_offset + byteOffset, value);
 
   }
 
 
   // Internal utility methods.
 
   static int _toEndianInt16(int host_value, bool little_endian)
       native "ByteData_ToEndianInt16";
   static int _toEndianUint16(int host_value, bool little_endian)
       native "ByteData_ToEndianUint16";
   static int _toEndianInt32(int host_value, bool little_endian)
       native "ByteData_ToEndianInt32";
   static int _toEndianUint32(int host_value, bool little_endian)
       native "ByteData_ToEndianUint32";
   static int _toEndianInt64(int host_value, bool little_endian)
       native "ByteData_ToEndianInt64";
   static int _toEndianUint64(int host_value, bool little_endian)
       native "ByteData_ToEndianUint64";
   static double _toEndianFloat32(double host_value, bool little_endian)
       native "ByteData_ToEndianFloat32";
   static double _toEndianFloat64(double host_value, bool little_endian)
       native "ByteData_ToEndianFloat64";
 
 
-  final TypedData _typeddata;
+  final TypedData _typedData;
   final int _offset;
   final int length;
 }
 
 
 // Top level utility methods.
 int _toInt(int value, int mask) {
   value &= mask;
   if (value > (mask >> 1)) value -= mask + 1;
   return value;
@@ skipping 65 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);
 }