Add ByteArray interface and provide internal and external implementations.

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 default InternalByteArray {
+  ByteArray(int length);
+
+  int get length();
+
+  int getInt8(int byteOffset);
+
+  void setInt8(int byteOffset, int value);
+
+  int getUint8(int byteOffset);
+
+  void setUint8(int byteOffset, int value);
+
+  int getInt16(int byteOffset);
+
+  void setInt16(int byteOffset, int value);
+
+  int getUint16(int byteOffset);

[siva, 2012/01/20 22:51:04]

byteOffset is confusing? It is really byteOffset or index (appropriate scaling
done by the implementation))?

[Søren Gjesse, 2012/01/23 10:38:51]

I think that the index/offset should be sepcified in byes and it should be up to
the user to do any scaling. If the implementation does scaling writing byte
arrays with a mixture of different types becomes more difficult.

[Søren Gjesse, 2012/01/23 10:38:51]

Should it be possible to write in both little and big endian? node.js have both
on their Buffer object:
http://nodejs.org/docs/latest/api/buffers.html#buffer.readUInt16LE

[cshapiro, 2012/01/24 02:14:23]

It is possible although there is no support from the VM.  We could add that
feature, if need be.  It is not yet clear to me whether that functionality
belongs in the ByteArray class or in one of its subclasses.

[cshapiro, 2012/01/24 02:14:23]

It is a byte offset, not a scaled index.  The original implementation used a
scaled index.  That did not survive the code review and the byte offset approach
prevailed.

As an aside, the resolution was to put fast, pre-scaled get and set methods in
the TypedArray-like subclasses, such as Int16Array and Float64Array.  ByteArray
would contain byte oriented access methods.

[cshapiro, 2012/01/24 02:14:23]

For the record, we decided to provide an interface which is something similar to
DataView

https://developer.mozilla.org/en/JavaScript_typed_arrays/DataView

[siva, 2012/01/25 17:22:47]

Ok got it. 

On 2012/01/24 02:14:23, cshapiro wrote:

+
+  void setUint16(int byteOffset, int value);
+
+  int getInt32(int byteOffset);
+
+  void setInt32(int byteOffset, int value);
+
+  int getUint32(int byteOffset);
+
+  void setUint32(int byteOffset, int value);
+
+  int getInt64(int byteOffset);
+
+  void setInt64(int byteOffset, int value);
+
+  int getUint64(int byteOffset);
+
+  void setUint64(int byteOffset, int value);
+
+  double getFloat32(int byteOffset);
+
+  void setFloat32(int byteOffset, double value);
+
+  double getFloat64(int byteOffset);
+
+  void setFloat64(int byteOffset, double value);
+}
+
+
+class ByteArrayBase {

[Søren Gjesse, 2012/01/23 10:38:51]

Shouldn't there be an "implements Iteratable, List" here?

[cshapiro, 2012/01/24 02:14:23]

Effectively, yes.  The version of this file that was uploaded was behind a
revision.  What I should have shown has the following signature

  interface ByteArray extends List default InternalByteArray {

I think Iterable and Collection are implicitly inherited by way of List.  So, we
should be okay.

+
+  // Iterable interface
+
+  Iterator iterator() {
+    return new ByteArrayIterator(this);
+  }
+
+  // Collection interface
+
+  int get length() {
+    return _length();
+  }
+
+  bool every(bool f(int element)) {
+    return Collections.every(this, f);
+  }
+
+  Collection map(f(int element)) {

[Søren Gjesse, 2012/01/23 10:38:51]

Long line.

[cshapiro, 2012/01/24 02:14:23]

Fixed.

+    return Collections.map(this, new GrowableObjectArray.withCapacity(length), f);
+  }
+
+  Collection filter(bool f(int element)) {
+    return Collections.filter(this, new GrowableObjectArray(), f);
+  }
+
+  void forEach(f(int element)) {
+    Collections.forEach(this, f);
+  }
+
+  bool isEmpty() {
+    return this.length === 0;
+  }
+
+  bool some(bool f(int element)) {
+    return Collections.some(this, f);
+  }
+
+  // List interface
+
+  int operator[](int index) {
+    return getUint8(index);
+  }
+
+  void operator[]=(int index, int value) {
+    setUint8(index, value);
+  }
+
+  void set length(int newLength) {
+    throw const UnsupportedOperationException("Cannot add to a byte array");
+  }
+
+  void add(int element) {
+    throw const UnsupportedOperationException("Cannot add to a byte array");
+  }
+
+  void addLast(int element) {
+    add(element);

[siva, 2012/01/20 22:51:04]

why not throw here instead of calling 'add'.

[cshapiro, 2012/01/24 02:14:23]

Good point.  I like the idea of throwing rather than calling add.  The error
message will be more descriptive.  I will go ahead and make the change.

+  }
+
+  void addAll(Collection elements) {
+    throw const UnsupportedOperationException("Cannot add to a byte array");
+  }
+
+  void sort(int compare(int a,  b)) {
+    DualPivotQuicksort.sort(this, compare);
+  }
+
+  int indexOf(int element, [int start = 0]) {
+    return Arrays.indexOf(this, element, start, this.length);
+  }
+
+  int lastIndexOf(int element, [int start = null]) {
+    if (start === null) start = length - 1;
+    return Arrays.lastIndexOf(this, element, start);
+  }
+
+  void clear() {
+    throw const UnsupportedOperationException("Cannot clear a byte array");
+  }
+
+  int removeLast() {
+    throw const UnsupportedOperationException(
+      "Cannot remove from a byte array");
+  }
+
+  int last() {
+    return this[length - 1];
+  }
+
+  // Implementation
+
+  int _length() native "ByteArray_getLength";
+}
+
+
+class ByteArrayIterator implements Iterator {
+  ByteArrayIterator(List byteArray)
+      : _byteArray = byteArray, _length = byteArray.length, _pos = 0 {
+    assert(byteArray is ByteArray);
+  }
+
+  bool hasNext() {
+   return _length > _pos;
+  }
+
+  int next() {
+    if (!hasNext()) {
+      throw const NoMoreElementsException();
+    }
+    return _byteArray[_pos++];
+  }
+
+  final List _byteArray;
+
+  final int _length;
+
+  int _pos;
+}
+
+
+class InternalByteArray extends ByteArrayBase implements ByteArray {
+  factory InternalByteArray(int length) {
+    return _allocate(length);
+  }
+
+  // ByteArray interface
+
+  int getInt8(int byteOffset) {
+    return _getInt8(byteOffset);
+  }
+
+  void setInt8(int byteOffset, int value) {

[siva, 2012/01/20 22:51:04]

why do we need these dart wrappers here, why not just declare
setInt8 as a native method?

It might make sense if you did the range and type check etc. here and throw
exceptions instead of in the native implementation. You could just assert in the
native implementation.

[cshapiro, 2012/01/24 02:14:23]

This was Ivan's suggestion.  I may have misunderstood him, but my recollection
was to keep the implementation methods separate from the public interface
methods.

[siva, 2012/01/25 17:22:47]

I agree with Ivan's premise that native methods should not be public we should
make them all private. I was just pointing out that we have a public dart method
and we could do all the type checks and range checks etc. here in dart code and
throw exceptions instead of doing the checks in the native implementation. The
native implementations could just assert for these.

On 2012/01/24 02:14:23, cshapiro wrote:

+    _setInt8(byteOffset, value);
+  }
+
+  int getUint8(int byteOffset) {
+    return _getUint8(byteOffset);
+  }
+
+  void setUint8(int byteOffset, int value) {
+    _setUint8(byteOffset, value);
+  }
+
+  int getInt16(int byteOffset) {
+    return _getInt16(byteOffset);
+  }
+
+  void setInt16(int byteOffset, int value) {
+    _setInt16(byteOffset, value);
+  }
+
+  int getUint16(int byteOffset) {
+    return _getInt16(byteOffset);
+  }
+
+  void setUint16(int byteOffset, int value) {
+    _setUint16(byteOffset, value);
+  }
+
+  int getInt32(int byteOffset) {
+    return _getInt32(byteOffset);
+  }
+
+  void setInt32(int byteOffset, int value) {
+    _setInt32(byteOffset, value);
+  }
+
+  int getUint32(int byteOffset) {
+    return _getUint32(byteOffset);
+  }
+
+  void setUint32(int byteOffset, int value) {
+    _setUint32(byteOffset, value);
+  }
+
+  int getInt64(int byteOffset) {
+    return _getInt64(byteOffset);
+  }
+
+  void setInt64(int byteOffset, int value) {
+    _setInt64(byteOffset, value);
+  }
+
+  int getUint64(int byteOffset) {
+    return _getUint64(byteOffset);
+  }
+
+  void setUint64(int byteOffset, int value) {
+    _setUint64(byteOffset, value);
+  }
+
+  double getFloat32(int byteOffset) {
+    return _getFloat32(byteOffset);
+  }
+
+  void setFloat32(int byteOffset, double value) {
+    _setFloat32(byteOffset, value);
+  }
+
+  double getFloat64(int byteOffset) {
+    return _getFloat64(byteOffset);
+  }
+
+  void setFloat64(int byteOffset, double value) {
+    _setFloat64(byteOffset, value);
+  }
+
+  // Implementation
+
+  static InternalByteArray _allocate(int length)
+    native "InternalByteArray_allocate";
+
+  int _getInt8(int byteOffset)
+    native "InternalByteArray_getInt8";
+
+  void _setInt8(int byteOffset, int value)
+    native "InternalByteArray_setInt8";
+
+  int _getUint8(int byteOffset)
+    native "InternalByteArray_getUint8";
+
+  void _setUint8(int byteOffset, int value)
+    native "InternalByteArray_setUint8";
+
+  int _getInt16(int byteOffset)
+    native "InternalByteArray_getInt16";
+
+  void _setInt16(int byteOffset, int value)
+    native "InternalByteArray_setInt16";
+
+  int _getUint16(int byteOffset)
+    native "InternalByteArray_getUint16";
+
+  void _setUint16(int byteOffset, int value)
+    native "InternalByteArray_setUint16";
+
+  int _getInt32(int byteOffset)
+    native "InternalByteArray_getInt32";
+
+  void _setInt32(int byteOffset, int value)
+    native "InternalByteArray_setInt32";
+
+  int _getUint32(int byteOffset)
+    native "InternalByteArray_getUint32";
+
+  void _setUint32(int byteOffset, int value)
+    native "InternalByteArray_setUint32";
+
+  int _getInt64(int byteOffset)
+    native "InternalByteArray_getInt64";
+
+  void _setInt64(int byteOffset, int value)
+    native "InternalByteArray_setInt64";
+
+  int _getUint64(int byteOffset)
+    native "InternalByteArray_getUint64";
+
+  void _setUint64(int byteOffset, int value)
+    native "InternalByteArray_setUint64";
+
+  double _getFloat32(int byteOffset)
+    native "InternalByteArray_getFloat32";
+
+  void _setFloat32(int byteOffset, double value)
+    native "InternalByteArray_setFloat32";
+
+  double _getFloat64(int byteOffset)
+    native "InternalByteArray_getFloat64";
+
+  void _setFloat64(int byteOffset, double value)
+    native "InternalByteArray_setFloat64";
+}
+
+
+class ExternalByteArray extends ByteArrayBase implements ByteArray {
+  // Collection interface
+
+  int get length() {
+    return _length();
+  }
+
+  // List interface
+
+  int operator[](int index) {
+    return _getUint8(index);
+  }
+
+  void operator[]=(int index, int value) {
+    _setUint8(index, value);
+  }
+
+  // ByteArray interface
+
+  int getInt8(int byteOffset) {
+    return _getInt8(byteOffset);
+  }
+
+  void setInt8(int byteOffset, int value) {
+    _setInt8(byteOffset, value);
+  }
+
+  int getUint8(int byteOffset) {
+    return _getUint8(byteOffset);
+  }
+
+  void setUint8(int byteOffset, int value) {
+    _setUint8(byteOffset, value);
+  }
+
+  int getInt16(int byteOffset) {
+    return _getInt16(byteOffset);
+  }
+
+  void setInt16(int byteOffset, int value) {
+    _setInt16(byteOffset, value);
+  }
+
+  int getUint16(int byteOffset) {
+    return _getInt16(byteOffset);
+  }
+
+  void setUint16(int byteOffset, int value) {
+    _setUint16(byteOffset, value);
+  }
+
+  int getInt32(int byteOffset) {
+    return _getInt32(byteOffset);
+  }
+
+  void setInt32(int byteOffset, int value) {
+    _setInt32(byteOffset, value);
+  }
+
+  int getUint32(int byteOffset) {
+    return _getUint32(byteOffset);
+  }
+
+  void setUint32(int byteOffset, int value) {
+    _setUint32(byteOffset, value);
+  }
+
+  int getInt64(int byteOffset) {
+    return _getInt64(byteOffset);
+  }
+
+  void setInt64(int byteOffset, int value) {
+    _setInt64(byteOffset, value);
+  }
+
+  int getUint64(int byteOffset) {
+    return _getUint64(byteOffset);
+  }
+
+  void setUint64(int byteOffset, int value) {
+    _setUint64(byteOffset, value);
+  }
+
+  double getFloat32(int byteOffset) {
+    return _getFloat32(byteOffset);
+  }
+
+  void setFloat32(int byteOffset, double value) {
+    _setFloat32(byteOffset, value);
+  }
+
+  double getFloat64(int byteOffset) {
+    return _getFloat64(byteOffset);
+  }
+
+  void setFloat64(int byteOffset, double value) {
+    _setFloat64(byteOffset, value);
+  }
+
+  // Implementation
+
+  int _getInt8(int byteOffset)
+    native "ExternalByteArray_getInt8";
+
+  void _setInt8(int byteOffset, int value)
+    native "ExternalByteArray_setInt8";
+
+  int _getUint8(int byteOffset)
+    native "ExternalByteArray_getUint8";
+
+  void _setUint8(int byteOffset, int value)
+    native "ExternalByteArray_setUint8";
+
+  int _getInt16(int byteOffset)
+    native "ExternalByteArray_getInt16";
+
+  void _setInt16(int byteOffset, int value)
+    native "ExternalByteArray_setInt16";
+
+  int _getUint16(int byteOffset)
+    native "ExternalByteArray_getUint16";
+
+  void _setUint16(int byteOffset, int value)
+    native "ExternalByteArray_setUint16";
+
+  int _getInt32(int byteOffset)
+    native "ExternalByteArray_getInt32";
+
+  void _setInt32(int byteOffset, int value)
+    native "ExternalByteArray_setInt32";
+
+  int _getUint32(int byteOffset)
+    native "ExternalByteArray_getUint32";
+
+  void _setUint32(int byteOffset, int value)
+    native "ExternalByteArray_setUint32";
+
+  int _getInt64(int byteOffset)
+    native "ExternalByteArray_getInt64";
+
+  void _setInt64(int byteOffset, int value)
+    native "ExternalByteArray_setInt64";
+
+  int _getUint64(int byteOffset)
+    native "ExternalByteArray_getUint64";
+
+  void _setUint64(int byteOffset, int value)
+    native "ExternalByteArray_setUint64";
+
+  double _getFloat32(int byteOffset)
+    native "ExternalByteArray_getFloat32";
+
+  void _setFloat32(int byteOffset, double value)
+    native "ExternalByteArray_setFloat32";
+
+  double _getFloat64(int byteOffset)
+    native "ExternalByteArray_getFloat64";
+
+  void _setFloat64(int byteOffset, double value)
+    native "ExternalByteArray_setFloat64";
+}