Use ByteArray's native for Socket and File.

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 extends List default _InternalByteArray {

[jat, 2012/02/01 23:09:29]

How will this interoperate with WebGL buffers?  Can an instance of this be
passed directly, or will it have to be copied?  Likewise with XHR/WebSocket.

[Anders Johnsen, 2012/02/01 23:19:30]

I believe that an ExternalByteArray could be used for such buffers. It will be
able to encapsulate any provided byte-buffer, without the need for copying.
Depending on how you want to handle WebSocket, InternalByteArray may be just
fine. Maybe Carl may have some better answers here.

[Ivan Posva, 2012/02/02 08:26:43]

The plan was that if an internal ByteArray is handed to the WebGL bindings, then
we do either copy the contents or convert it to an external ByteArray (for
reference please see how the V8 bindings can convert heap allocated strings to
external strings to avoid further copies).

Handing out raw pointers into garbage collected heaps to graphics cards
guarantees crashes, long debugging sessions and I will get another plaque.

   ByteArray(int length);
 
   int get length();
 

[jat, 2012/02/01 23:09:29]

Should there be some method for encoding/decoding arbitrary precision integers?

[Anders Johnsen, 2012/02/01 23:19:30]

One could create a class to operate on top of a ByteArray, to do such
operations. I'm unsure if the responsibility should be placed here.

   int getInt8(int byteOffset);
 
   void setInt8(int byteOffset, int value);
 
   int getUint8(int byteOffset);
 
   void setUint8(int byteOffset, int value);
 
   int getInt16(int byteOffset);
 
@@ skipping 114 matching lines @@
 
   int removeLast() {
     throw const UnsupportedOperationException(
       "Cannot remove from a byte array");
   }
 
   int last() {
     return this[length - 1];
   }
 
+  void setRange(int start, int length, List<int> from, [int startFrom = 0]) {
+    if (length < 0) {
+      throw new IllegalArgumentException("negative length $length");
+    }
+    if (from is ByteArray) {
+      _setRange(start, length, from, startFrom);
+    } else {
+      Arrays.copy(from, startFrom, this, start, length);
+    }
+  }
+  
+  List getRange(int start, int length) {
+    if (length == 0) return [];
+    Arrays.rangeCheck(this, start, length);
+    ByteArray list = new ByteArray(length);
+    list._setRange(0, length, this, start);
+    return list;
+  }
+
+
   // Implementation
 
   int _length() native "ByteArray_getLength";
+
+  void _setRange(int start, int length, ByteArray from, int startFrom)
+      native "ByteArray_setRange";
+
 }
 
 
 class _ByteArrayIterator implements Iterator {
   _ByteArrayIterator(List byteArray)
       : _byteArray = byteArray, _length = byteArray.length, _pos = 0 {
     assert(byteArray is ByteArray);
   }
 
   bool hasNext() {
@@ skipping 323 matching lines @@
 
   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";
 }