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

sdk/lib/typeddata/typeddata.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.
 
 library dart.typeddata;
 
 import 'dart:collection';
 import 'dart:_collection-dev';
 
 /**
@@ skipping 31 matching lines @@
   int get lengthInBytes;
 
   /**
    * Returns the byte buffer associated with this object.
    */
   ByteBuffer get buffer;
 }
 
 
 /**
+ * Describes endianness to be used when accessing or updating a
+ * sequence of bytes.
+ */
+class Endianness {
+  const Endianness(this.little_endian);

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

Maybe we should make sure that the user cannot create extra values of this type
by making the constructor private?

const Endianness._(this._littleEndian);

Since the value is a boolean it doesn't really matter in this case though.

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

Done.

+
+  static const Endianness BIG_ENDIAN = const Endianness(false);
+  static const Endianness LITTLE_ENDIAN = const Endianness(true);
+  static final Endianness HOST_ENDIAN =
+    (new ByteData.view(new Uint16List.fromList([1]).buffer)).getInt8(0) == 1 ?
+    LITTLE_ENDIAN : BIG_ENDIAN;
+
+  final bool little_endian;

[vsm, 2013/04/18 04:06:56]

Can we make this private?  Also, standard Dart style would be _littleEndian.

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

Done.

+}
+
+
+/**
  * A fixed-length, random-access sequence of bytes that also provides random
  * and unaligned access to the fixed-width integers and floating point
  * numbers represented by those bytes.
  * ByteData may be used to pack and unpack data from external sources
  * (such as networks or files systems), and to process large quantities
  * of numerical data more efficiently than would be possible
  * with ordinary [List] implementations. ByteData can save space, by
  * eliminating the need for object headers, and time, by eliminating the
  * need for data copies. Finally, ByteData may be used to intentionally
  * reinterpret the bytes representing one arithmetic type as another.
@@ skipping 72 matching lines @@
   /**
    * Returns the (possibly negative) integer represented by the two bytes at
    * the specified [byteOffset] in this object, in two's complement binary
    * form.
    * The return value will be between 2<sup>15</sup> and 2<sup>15</sup> - 1,
    * inclusive.
    *
    * Throws [RangeError] if [byteOffset] is negative, or
    * `byteOffset + 2` is greater than the length of this object.
    */
-  int getInt16(int byteOffset);
+  int getInt16(int byteOffset, [Endianness endian = Endianness.BIG_ENDIAN]);

[Søren Gjesse, 2013/04/18 07:04:36]

How about adding a property endianess to ByteData to set the default endianess
used?

Then

ByteData bd = ...
db.endianess = Endianness.LITTLE_ENDIAN;
db.setInt16(1);
db.setInt32(2);
db.setInt64(1);

would be equal to

ByteData bd = ...
db.setInt16(1, Endianness.LITTLE_ENDIAN);
db.setInt32(2, Endianness.LITTLE_ENDIAN);
db.setInt64(1, Endianness.LITTLE_ENDIAN);

The default value for the endian argument should then just be null, and if null
pick the value from the endianess property which should default to
Endianness.BIG_ENDIAN.

When not using BIG_ENDIAN this would save writing Endianness.LITTLE_ENDIAN all
over the place.

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

Seems like a good idea. I will defer this proposal to another CL. Maybe first
get feedback to see if dart2js will not have any issues implementing it this
way.

On 2013/04/18 07:04:36, Søren Gjesse wrote:

 
   /**
    * Sets the two bytes starting at the specified [byteOffset] in this
    * object to the two's complement binary representation of the specified
    * [value], which must fit in two bytes. In other words, [value] must lie
    * between 2<sup>15</sup> and 2<sup>15</sup> - 1, inclusive.
    *
    * Throws [RangeError] if [byteOffset] is negative, or
    * `byteOffset + 2` is greater than the length of this object.
    */
-  void setInt16(int byteOffset, int value);
+  void setInt16(int byteOffset,
+                int value,
+                [Endianness endian = Endianness.BIG_ENDIAN]);
 
   /**
    * Returns the positive integer represented by the two bytes starting
    * at the specified [byteOffset] in this object, in unsigned binary
    * form.
    * The return value will be between 0 and  2<sup>16</sup> - 1, inclusive.
    *
    * Throws [RangeError] if [byteOffset] is negative, or
    * `byteOffset + 2` is greater than the length of this object.
    */
-  int getUint16(int byteOffset);
+  int getUint16(int byteOffset, [Endianness endian = Endianness.BIG_ENDIAN]);
 
   /**
    * Sets the two bytes starting at the specified [byteOffset] in this object
    * to the unsigned binary representation of the specified [value],
    * which must fit in two bytes. in other words, [value] must be between
    * 0 and 2<sup>16</sup> - 1, inclusive.
    *
    * Throws [RangeError] if [byteOffset] is negative, or
    * `byteOffset + 2` is greater than the length of this object.
    */
-  void setUint16(int byteOffset, int value);
+  void setUint16(int byteOffset,
+                 int value,
+                 [Endianness endian = Endianness.BIG_ENDIAN]);
 
   /**
    * Returns the (possibly negative) integer represented by the four bytes at
    * the specified [byteOffset] in this object, in two's complement binary
    * form.
    * The return value will be between 2<sup>31</sup> and 2<sup>31</sup> - 1,
    * inclusive.
    *
    * Throws [RangeError] if [byteOffset] is negative, or
    * `byteOffset + 4` is greater than the length of this object.
    */
-  int getInt32(int byteOffset);
+  int getInt32(int byteOffset, [Endianness endian = Endianness.BIG_ENDIAN]);
 
   /**
    * Sets the four bytes starting at the specified [byteOffset] in this
    * object to the two's complement binary representation of the specified
    * [value], which must fit in four bytes. In other words, [value] must lie
    * between 2<sup>31</sup> and 2<sup>31</sup> - 1, inclusive.
    *
    * Throws [RangeError] if [byteOffset] is negative, or
    * `byteOffset + 4` is greater than the length of this object.
    */
-  void setInt32(int byteOffset, int value);
+  void setInt32(int byteOffset,
+                int value,
+                [Endianness endian = Endianness.BIG_ENDIAN]);
 
   /**
    * Returns the positive integer represented by the four bytes starting
    * at the specified [byteOffset] in this object, in unsigned binary
    * form.
    * The return value will be between 0 and  2<sup>32</sup> - 1, inclusive.
    *
    */
-  int getUint32(int byteOffset);
+  int getUint32(int byteOffset, [Endianness endian = Endianness.BIG_ENDIAN]);
 
   /**
    * Sets the four bytes starting at the specified [byteOffset] in this object
    * to the unsigned binary representation of the specified [value],
    * which must fit in four bytes. in other words, [value] must be between
    * 0 and 2<sup>32</sup> - 1, inclusive.
    *
    * Throws [RangeError] if [byteOffset] is negative, or
    * `byteOffset + 4` is greater than the length of this object.
    */
-  void setUint32(int byteOffset, int value);
+  void setUint32(int byteOffset,
+                 int value,
+                 [Endianness endian = Endianness.BIG_ENDIAN]);
 
   /**
    * Returns the (possibly negative) integer represented by the eight bytes at
    * the specified [byteOffset] in this object, in two's complement binary
    * form.
    * The return value will be between 2<sup>63</sup> and 2<sup>63</sup> - 1,
    * inclusive.
    *
    * Throws [RangeError] if [byteOffset] is negative, or
    * `byteOffset + 8` is greater than the length of this object.
    */
-  int getInt64(int byteOffset);
+  int getInt64(int byteOffset, [Endianness endian = Endianness.BIG_ENDIAN]);
 
   /**
    * Sets the eight bytes starting at the specified [byteOffset] in this
    * object to the two's complement binary representation of the specified
    * [value], which must fit in eight bytes. In other words, [value] must lie
    * between 2<sup>63</sup> and 2<sup>63</sup> - 1, inclusive.
    *
    * Throws [RangeError] if [byteOffset] is negative, or
    * `byteOffset + 8` is greater than the length of this object.
    */
-  void setInt64(int byteOffset, int value);
+  void setInt64(int byteOffset,
+                int value,
+                [Endianness endian = Endianness.BIG_ENDIAN]);
 
   /**
    * Returns the positive integer represented by the eight bytes starting
    * at the specified [byteOffset] in this object, in unsigned binary
    * form.
    * The return value will be between 0 and  2<sup>64</sup> - 1, inclusive.
    *
    * Throws [RangeError] if [byteOffset] is negative, or
    * `byteOffset + 8` is greater than the length of this object.
    */
-  int getUint64(int byteOffset);
+  int getUint64(int byteOffset, [Endianness endian = Endianness.BIG_ENDIAN]);
 
   /**
    * Sets the eight bytes starting at the specified [byteOffset] in this object
    * to the unsigned binary representation of the specified [value],
    * which must fit in eight bytes. in other words, [value] must be between
    * 0 and 2<sup>64</sup> - 1, inclusive.
    *
    * Throws [RangeError] if [byteOffset] is negative, or
    * `byteOffset + 8` is greater than the length of this object.
    */
-  void setUint64(int byteOffset, int value);
+  void setUint64(int byteOffset,
+                 int value,
+                 [Endianness endian = Endianness.BIG_ENDIAN]);
 
   /**
    * Returns the floating point number represented by the four bytes at
    * the specified [byteOffset] in this object, in IEEE 754
    * single-precision binary floating-point format (binary32).
    *
    * Throws [RangeError] if [byteOffset] is negative, or
    * `byteOffset + 4` is greater than the length of this object.
    */
-  double getFloat32(int byteOffset);
+  double getFloat32(int byteOffset,
+                    [Endianness endian = Endianness.BIG_ENDIAN]);
 
   /**
    * Sets the four bytes starting at the specified [byteOffset] in this
    * object to the IEEE 754 single-precision binary floating-point
    * (binary32) representation of the specified [value].
    *
    * **Note that this method can lose precision.** The input [value] is
    * a 64-bit floating point value, which will be converted to 32-bit
    * floating point value by IEEE 754 rounding rules before it is stored.
    * If [value] cannot be represented exactly as a binary32, it will be
    * converted to the nearest binary32 value.  If two binary32 values are
    * equally close, the one whose least significant bit is zero will be used.
    * Note that finite (but large) values can be converted to infinity, and
    * small non-zero values can be converted to zero.
    *
    * Throws [RangeError] if [byteOffset] is negative, or
    * `byteOffset + 4` is greater than the length of this object.
    */
-  void setFloat32(int byteOffset, double value);
+  void setFloat32(int byteOffset,
+                  double value,
+                  [Endianness endian = Endianness.BIG_ENDIAN]);
 
   /**
    * Returns the floating point number represented by the eight bytes at
    * the specified [byteOffset] in this object, in IEEE 754
    * double-precision binary floating-point format (binary64).
    *
    * Throws [RangeError] if [byteOffset] is negative, or
    * `byteOffset + 8` is greater than the length of this object.
    */
-  double getFloat64(int byteOffset);
+  double getFloat64(int byteOffset,
+                    [Endianness endian = Endianness.BIG_ENDIAN]);
 
   /**
    * Sets the eight bytes starting at the specified [byteOffset] in this
    * object to the IEEE 754 double-precision binary floating-point
    * (binary64) representation of the specified [value].
    *
    * Throws [RangeError] if [byteOffset] is negative, or
    * `byteOffset + 8` is greater than the length of this object.
    */
-  void setFloat64(int byteOffset, double value);
+  void setFloat64(int byteOffset,
+                  double value,
+                  [Endianness endian = Endianness.BIG_ENDIAN]);
 }
 
 
 /**
  * A fixed-length list of 8-bit signed integers.
  * For long lists, this implementation can be considerably
  * more space- and time-efficient than the default [List] implementation.
  */
 abstract class Int8List implements List<int>, TypedData {
   /**
@@ skipping 601 matching lines @@
   Uint32x4 withFlagW(bool w);
 
   /// Merge [trueValue] and [falseValue] based on [this]' bit mask:
   /// Select bit from [trueValue] when bit in [this] is on.
   /// Select bit from [falseValue] when bit in [this] is off.
   Float32x4 select(Float32x4 trueValue, Float32x4 falseValue);
 
   /// Returns a bit-wise copy of [this] as a [Float32x4].
   Float32x4 toFloat32x4();
 }