Growable typed data buffers.

pkg/collection_helpers/lib/typed_buffers.dart

Index: pkg/collection_helpers/lib/typed_buffers.dart
diff --git a/pkg/collection_helpers/lib/typed_buffers.dart b/pkg/collection_helpers/lib/typed_buffers.dart
new file mode 100644
index 0000000000000000000000000000000000000000..0a2710614a6990cd4974f8f3e82b9b496252b3a8
--- /dev/null
+++ b/pkg/collection_helpers/lib/typed_buffers.dart
@@ -0,0 +1,236 @@
+// 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.
+
+/**
+ * Growable typed-data lists.
+ *
+ * These lists works just as a typed-data list, except that they are growable.
+ * They use an underlying buffer, and when that buffer becomes too small, it
+ * is replaced by a new buffer.
+ *
+ * That means that using the [TypedDataView.buffer] getter is not guaranteed
+ * to return the same result each time it is used, and that the buffer may
+ * be larger than what the list is using.
+ */
+library dart.collection_helpers.typed_buffers;
+
+import "dart:collection" show ListBase;
+import "dart:typed_data";
+
+abstract class _TypedDataBuffer<E> extends ListBase<E>
+                                   implements TypedData, List<E> {

[sra1, 2013/11/18 22:16:35]

Is it possible to do this without implementing TypedData?

Implementing TypedData (which in dart2js's dart:typed_data maps to DOM typed
ArrayBufferView) means that serialization code can no longer detect typed arrays
with "is TypeData", and objects that answer "is TypedData" will have surprising
bugs when used with IndexDB or postMessage.

This is the same issue that I pointed out with implementing Int8List, just with
the parent class.

[Lasse Reichstein Nielsen, 2013/11/19 10:31:24]

Ofcourse I can do that, but isn't it a problem that user code cannot implement
TypedData?
I don't expect myself to be the only one who would want to do it, so eventually
somebody will do it anyway, and stuff will break.

Or, in other words, if you need to detect the exact classes for any reason, I
don't think using a public interface is safe. Have you considered having an
internal "_RealTypedData" interface instead?

I've removed "TypedData" from the interface, but retained the fields. 
I wouldn't mind adding it again later, if we can find an amicable way to do it
without complicating dart2js too much.

+  static const int INITIAL_LENGTH = 8;
+
+  /// This is an Uint8List for Uint8Buffer. It's both a List<E> and a TypedData,

[floitsch, 2013/11/18 18:03:40]

a Uint8List

[Lasse Reichstein Nielsen, 2013/11/19 10:31:24]

Good catch.

+  /// which we don't have a type for here.
+  var _buffer;
+  /// The length of the list being built.
+  int _length;
+
+  _TypedDataBuffer(List<E> buffer)
+      : this._buffer = buffer, this._length = buffer.length;
+
+  int get length => _length;
+  E operator[](int index) {
+    if (index >= length) throw new RangeError.range(index, 0, length - 1);
+    return _buffer[index];
+  }
+
+  void operator[]=(int index, E value) {
+    if (index >= length) throw new RangeError.range(index, 0, length - 1);
+    _buffer[index] = value;
+  }
+
+  void set length(int newLength) {
+    if (newLength < _length) {
+      E defaultValue = _defaultValue;
+      for (int i = newLength; i < _length; i++) {
+        _buffer[i] = defaultValue;
+      }
+    } else if (newLength > _buffer.length) {
+      List<E> newBuffer;
+      if (_buffer.length == 0) {
+        newBuffer = _createBuffer(newLength);
+      } else {
+        newBuffer = _createBiggerBuffer(newLength);
+      }
+      newBuffer.setRange(0, _length, _buffer);
+      _buffer = newBuffer;
+    }
+    _length = newLength;
+  }
+
+  void _add(E value) {
+    if (_length == _buffer.length) _grow();
+    _buffer[_length++] = value;
+  }
+
+  // We override the default implementation of `add` and `addAll` because
+  // they grow by setting the length in increments of one. We want to grow
+  // by doubling capacity in most cases.
+  void add(E value) { _add(value); }
+
+  void addAll(Iterable<E> values) {
+    for (E value in values) _add(value);
+  }
+
+  void insert(int index, E element) {
+    if (index < 0 || index > _length) {
+      throw new RangeError.range(index, 0, _length);
+    }
+    if (_length < _buffer.length) {
+      _buffer.setRange(index + 1, _length + 1, _buffer, index);
+      _buffer[index] = element;
+      _length++;
+      return;
+    }
+    List<E> newBuffer = _createBiggerBuffer(null);
+    newBuffer.setRange(0, index, _buffer);
+    newBuffer.setRange(index + 1, _length + 1, _buffer, index);
+    newBuffer[index] = element;
+    _length++;
+    _buffer = newBuffer;
+  }
+
+  /**
+   * Create a bigger buffer.
+   *
+   * This method determines how much bigger a bigger buffer should
+   * be. If [requiredLength] is not null, it will be at least that
+   * size. It will always have at least have double the capacity of
+   * the current buffer.
+   */
+  List<E> _createBiggerBuffer(int requiredLength) {
+    int newLength = _buffer.length * 2;
+    if (requiredLength != null && newLength < requiredLength) {
+      newLength = requiredLength;
+    } else if (newLength < INITIAL_LENGTH) {
+      newLength = INITIAL_LENGTH;
+    }
+    return _createBuffer(newLength);
+  }
+
+  void _grow() {
+    _buffer = _createBiggerBuffer(null)..setRange(0, _length, _buffer);

[floitsch, 2013/11/18 18:03:40]

Please split.

[sra1, 2013/11/18 22:16:35]

Why? then you need a temporary to hold one of (old)buffer or (new)buffer.
The cascade expresses in one line what would take three otherwise.

+  }
+
+  void setRange(int start, int end, Iterable source, [int skipCount = 0]) {
+    if (end > _length) throw new RangeError.range(end, 0, _length);
+    if (!identical(source, this)) {

[floitsch, 2013/11/18 18:03:40]

You could also use an is-check against _TypedDataBuffer.

[Lasse Reichstein Nielsen, 2013/11/19 10:31:24]

That could work, yes. 

+      _buffer.setRange(start, end, source, skipCount);
+    } else {
+      // Make internal moves work correctly.
+      _buffer.setRange(start, end, _buffer, skipCount);
+    }
+  }
+
+  // TypedData.
+
+  int get elementSizeInBytes => _buffer.elementSizeInBytes;
+
+  int get lengthInBytes => _length * _buffer.elementSizeInBytes;
+
+  int get offsetInBytes => _buffer.offsetInBytes;
+
+  /**
+    * Returns the underlying [ByteBuffer].
+    *
+    * The returned buffer may be replaced by operations that change the [length]
+    * of this list.
+    *
+    * The buffer may be larger than [lengthInBytes] bytes, but never smaller.
+    */
+  ByteBuffer get buffer => _buffer.buffer;
+
+  // Specialization for the specific type.
+
+  // Return zero for integers, 0.0 for floats, etc.
+  // Used to fill buffer when changing length.
+  E get _defaultValue;
+
+  // Create a new typed list to use as buffer.
+  List<E> _createBuffer(int size);
+}
+
+abstract class _IntBuffer extends _TypedDataBuffer<int> {
+  _IntBuffer(buffer): super(buffer);
+  int get _defaultValue => 0;
+}
+
+abstract class _FloatBuffer extends _TypedDataBuffer<double> {
+  _FloatBuffer(buffer): super(buffer);
+  double get _defaultValue => 0.0;
+}
+
+class Uint8Buffer extends _IntBuffer {
+  Uint8Buffer([int initialLength = 0]) : super(new Uint8List(initialLength));
+  Uint8List _createBuffer(int size) => new Uint8List(size);
+}
+
+class Int8Buffer extends _IntBuffer {
+  Int8Buffer([int initialLength = 0]) : super(new Int8List(initialLength));
+  Int8List _createBuffer(int size) => new Int8List(size);
+}
+
+class Uint8ClampedBuffer extends _IntBuffer {
+  Uint8ClampedBuffer([int initialLength = 0])
+      : super(new Uint8ClampedList(initialLength));
+  Uint8ClampedList _createBuffer(int size) => new Uint8ClampedList(size);
+}
+
+class Uint16Buffer extends _IntBuffer {
+  Uint16Buffer([int initialLength = 0]) : super(new Uint16List(initialLength));
+  Uint16List _createBuffer(int size) => new Uint16List(size);
+}
+
+class Int16Buffer extends _IntBuffer {
+  Int16Buffer([int initialLength = 0]) : super(new Int16List(initialLength));
+  Int16List _createBuffer(int size) => new Int16List(size);
+}
+
+class Uint32Buffer extends _IntBuffer {
+  Uint32Buffer([int initialLength = 0]) : super(new Uint32List(initialLength));
+  Uint32List _createBuffer(int size) => new Uint32List(size);
+}
+
+class Int32Buffer extends _IntBuffer {
+  Int32Buffer([int initialLength = 0]) : super(new Int32List(initialLength));
+  Int32List _createBuffer(int size) => new Int32List(size);
+}
+
+class Uint64Buffer extends _IntBuffer {
+  Uint64Buffer([int initialLength = 0]) : super(new Uint64List(initialLength));
+  Uint64List _createBuffer(int size) => new Uint64List(size);
+}
+
+class Int64Buffer extends _IntBuffer {
+  Int64Buffer([int initialLength = 0]) : super(new Int64List(initialLength));
+  Int64List _createBuffer(int size) => new Int64List(size);
+}
+
+class Float32Buffer extends _FloatBuffer {
+  Float32Buffer([int initialLength = 0])
+      : super(new Float32List(initialLength));
+  Float32List _createBuffer(int size) => new Float32List(size);
+}
+
+class Float64Buffer extends _FloatBuffer {
+  Float64Buffer([int initialLength = 0])
+      : super(new Float64List(initialLength));
+  Float64List _createBuffer(int size) => new Float64List(size);
+}
+
+class Int32x4Buffer extends _TypedDataBuffer<Int32x4> {
+  Int32x4Buffer([int initialLength = 0])
+      : super(new Int32x4List(initialLength));
+  Int32x4 get _defaultValue => new Int32x4(0, 0, 0, 0);
+  Int32x4List _createBuffer(int size) => new Int32x4List(size);
+}
+
+class Float32x4Buffer extends _TypedDataBuffer<Float32x4> {
+  Float32x4Buffer([int initialLength = 0])
+      : super(new Float32x4List(initialLength));
+  Float32x4 get _defaultValue => new Float32x4.zero();
+  Float32x4List _createBuffer(int size) => new Float32x4List(size);
+}