Add endian parameter to the get/set functions in ByteData.

runtime/lib/typeddata.dart

Index: runtime/lib/typeddata.dart
===================================================================
--- runtime/lib/typeddata.dart	(revision 21661)
+++ runtime/lib/typeddata.dart	(working copy)
@@ -2874,127 +2874,190 @@
     if (byteOffset < 0 || byteOffset >= length) {
       _throwRangeError(byteOffset, length);
     }
-    _typeddata._setUint8(_offset + byteOffset,_toUint8( value));
+    _typeddata._setUint8(_offset + byteOffset, _toUint8(value));
   }
 
-  int getInt16(int byteOffset) {
+  int getInt16(int byteOffset, [Endianness endian = Endianness.BIG_ENDIAN]) {
     if (byteOffset < 0 || byteOffset >= length) {
       _throwRangeError(byteOffset, length);
     }
-    return _typeddata._getInt16(_offset + byteOffset);
+    var result = _typeddata._getInt16(_offset + byteOffset);
+    return _ToEndianInt16(result, endian.little_endian);
   }
-  void setInt16(int byteOffset, int value) {
+  void setInt16(int byteOffset,
+                int value,
+                [Endianness endian = Endianness.BIG_ENDIAN]) {
     if (byteOffset < 0 || byteOffset >= length) {
       _throwRangeError(byteOffset, length);
     }
-    _typeddata._setInt16(_offset + byteOffset, _toInt16(value));
+    _typeddata._setInt16(_offset + byteOffset,
+                         _ToEndianInt16(_toInt16(value), endian.little_endian));
   }
 
-  int getUint16(int byteOffset) {
+  int getUint16(int byteOffset, [Endianness endian = Endianness.BIG_ENDIAN]) {
     if (byteOffset < 0 || byteOffset >= length) {
       _throwRangeError(byteOffset, length);
     }
-    return _typeddata._getUint16(_offset + byteOffset);
+    var result = _typeddata._getUint16(_offset + byteOffset);
+    return _ToEndianUint16(result, endian.little_endian);
   }
-  void setUint16(int byteOffset, int value) {
+  void setUint16(int byteOffset,
+                 int value,
+                 [Endianness endian = Endianness.BIG_ENDIAN]) {
     if (byteOffset < 0 || byteOffset >= length) {
       _throwRangeError(byteOffset, length);
     }
-    _typeddata._setUint16(_offset + byteOffset, _toUint16(value));
+    _typeddata._setUint16(
+        _offset + byteOffset,
+        _ToEndianUint16(_toUint16(value), endian.little_endian));
   }
 
-  int getInt32(int byteOffset) {
+  int getInt32(int byteOffset, [Endianness endian = Endianness.BIG_ENDIAN]) {
     if (byteOffset < 0 || byteOffset >= length) {
       _throwRangeError(byteOffset, length);
     }
-    return _typeddata._getInt32(_offset + byteOffset);
+    var result = _typeddata._getInt32(_offset + byteOffset);
+    return _ToEndianInt32(result, endian.little_endian);
   }
-  void setInt32(int byteOffset, int value) {
+  void setInt32(int byteOffset,
+                int value,
+                [Endianness endian = Endianness.BIG_ENDIAN]) {
     if (byteOffset < 0 || byteOffset >= length) {
       _throwRangeError(byteOffset, length);
     }
-    _typeddata._setInt32(_offset + byteOffset, _toInt32(value));
+    _typeddata._setInt32(_offset + byteOffset,
+                         _ToEndianInt32(_toInt32(value), endian.little_endian));
   }
 
-  int getUint32(int byteOffset) {
+  int getUint32(int byteOffset, [Endianness endian = Endianness.BIG_ENDIAN]) {
     if (byteOffset < 0 || byteOffset >= length) {
       _throwRangeError(byteOffset, length);
     }
-    return _typeddata._getUint32(_offset + byteOffset);
+    var result = _typeddata._getUint32(_offset + byteOffset);
+    return _ToEndianUint32(result, endian.little_endian);
   }
-  void setUint32(int byteOffset, int value) {
+  void setUint32(int byteOffset,
+                 int value,
+                 [Endianness endian = Endianness.BIG_ENDIAN]) {
     if (byteOffset < 0 || byteOffset >= length) {
       _throwRangeError(byteOffset, length);
     }
-    _typeddata._setUint32(_offset + byteOffset, _toUint32(value));
+    _typeddata._setUint32(
+        _offset + byteOffset,
+        _ToEndianUint32(_toUint32(value), endian.little_endian));
   }
 
-  int getInt64(int byteOffset) {
+  int getInt64(int byteOffset, [Endianness endian = Endianness.BIG_ENDIAN]) {
     if (byteOffset < 0 || byteOffset >= length) {
       _throwRangeError(byteOffset, length);
     }
-    return _typeddata._getInt64(_offset + byteOffset);
+    var result = _typeddata._getInt64(_offset + byteOffset);
+    return _ToEndianInt64(result, endian.little_endian);
   }
-  void setInt64(int byteOffset, int value) {
+  void setInt64(int byteOffset,
+                int value,
+                [Endianness endian = Endianness.BIG_ENDIAN]) {
     if (byteOffset < 0 || byteOffset >= length) {
       _throwRangeError(byteOffset, length);
     }
-    _typeddata._setInt64(_offset + byteOffset, _toInt64(value));
+    _typeddata._setInt64(_offset + byteOffset,
+                         _ToEndianInt64(_toInt64(value), endian.little_endian));
   }
 
-  int getUint64(int byteOffset) {
+  int getUint64(int byteOffset, [Endianness endian = Endianness.BIG_ENDIAN]) {
     if (byteOffset < 0 || byteOffset >= length) {
       _throwRangeError(byteOffset, length);
     }
-    return _typeddata._getUint64(_offset + byteOffset);
+    var result = _typeddata._getUint64(_offset + byteOffset);
+    return _ToEndianUint64(result, endian.little_endian);
   }
-  void setUint64(int byteOffset, int value) {
+  void setUint64(int byteOffset,
+                 int value,
+                 [Endianness endian = Endianness.BIG_ENDIAN]) {
     if (byteOffset < 0 || byteOffset >= length) {
       _throwRangeError(byteOffset, length);
     }
-    _typeddata._setUint64(_offset + byteOffset, _toUint64(value));
+    _typeddata._setUint64(
+        _offset + byteOffset,
+        _ToEndianUint64(_toUint64(value), endian.little_endian));
   }
 
-  double getFloat32(int byteOffset) {
+  double getFloat32(int byteOffset,
+                    [Endianness endian = Endianness.BIG_ENDIAN]) {
     if (byteOffset < 0 || byteOffset >= length) {
       _throwRangeError(byteOffset, length);
     }
-    return _typeddata._getFloat32(_offset + byteOffset);
+    var result = _typeddata._getFloat32(_offset + byteOffset);
+    return _ToEndianFloat32(result, endian.little_endian);
   }
-  void setFloat32(int byteOffset, double value) {
+  void setFloat32(int byteOffset,
+                  double value,
+                  [Endianness endian = Endianness.BIG_ENDIAN]) {
     if (byteOffset < 0 || byteOffset >= length) {
       _throwRangeError(byteOffset, length);
     }
-    _typeddata._setFloat32(_offset + byteOffset, value);
+    _typeddata._setFloat32(_offset + byteOffset,
+                           _ToEndianFloat32(value, endian.little_endian));
   }
 
-  double getFloat64(int byteOffset) {
+  double getFloat64(int byteOffset,
+                    [Endianness endian = Endianness.BIG_ENDIAN]) {
     if (byteOffset < 0 || byteOffset >= length) {
       _throwRangeError(byteOffset, length);
     }
-    return _typeddata._getFloat64(_offset + byteOffset);
+    var result = _typeddata._getFloat64(_offset + byteOffset);
+    return _ToEndianFloat64(result, endian.little_endian);
   }
-  void setFloat64(int byteOffset, double value) {
+  void setFloat64(int byteOffset,
+                  double value,
+                  [Endianness endian = Endianness.BIG_ENDIAN]) {
     if (byteOffset < 0 || byteOffset >= length) {
       _throwRangeError(byteOffset, length);
     }
-    _typeddata._setFloat64(_offset + byteOffset, value);
+    _typeddata._setFloat64(_offset + byteOffset,
+                           _ToEndianFloat64(value, endian.little_endian));
   }
 
-  Float32x4 getFloat32x4(int byteOffset) {
+  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);
   }
-  void setFloat32x4(int byteOffset, Float32x4 value) {
+  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);
 
   }
 
+
+  // Internal utility methods.
+
+  static int _ToEndianInt16(int host_value, bool little_endian)

[Mads Ager (google), 2013/04/18 08:10:44]

I think we usually start with a lower-case letter for the dart methods.
_toEndianXYZ.

[siva, 2013/04/18 17:17:47]

Done.

+      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 int _offset;
   final int length;