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 {
   ByteArray(int length);
 
   int get length();
 
   int getInt8(int byteOffset);
@@ skipping 78 matching lines @@
     return Collections.some(this, f);
   }
 
   // List interface
 
   int operator[](int index) {
     return getUint8(index);
   }
 
   void operator[]=(int index, int value) {
-    setUint8(index, value);
+    if (value is int && value >= 0 && value <= 255) {

[Ivan Posva, 2012/02/01 01:05:27]

Why this semantic change?

[Anders Johnsen, 2012/02/01 02:12:11]

Are you meaning why to move the 

if(!...) throw; setUint8 

into

if(...) setUint8 else throw;

it's due to readability (if I interpreted Carl's feedback correctly). If not,
please specify. :)

+      setUint8(index, value);
+    } else {
+      throw const IllegalArgumentException(
+          "value is not an integer in byte range");
+    }
   }
 
   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");
   }
 
@@ skipping 24 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(from, startFrom, start, length);
+    } 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(this, start, 0, length);
+    return list;
+  }
+
+
   // Implementation
 
   int _length() native "ByteArray_getLength";
+
+  void _setRange(ByteArray src,

[Ivan Posva, 2012/02/01 01:05:27]

It is very confusing to have two methods with essentially the same name have
different argument lists. Please fix this before committing.

You should either add a private static method _copy which mirrors the
Arrays.copy method or mirror the setRange arguments here, without the
optionality of startFrom as it would not be needed.

[Anders Johnsen, 2012/02/01 02:12:11]

I absolutely agree, very good observation. I've update the argument order.

+                 int srcStart,
+                 int dstStart,
+                 int count)
+      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";
 }