Add chunked input stream

runtime/bin/buffer_list.dart

 // Copyright (c) 2011, 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.
 
 /**
  * Utility class that holds a number of byte buffers and can deliver
  * the bytes either one by one or in chunks.
  */
 class _BufferList {
   _BufferList() {
@@ skipping 36 matching lines @@
   int next() {
     int value = _buffers.first()[_index++];
     _length--;
     if (_index == _buffers.first().length) {
       _buffers.removeFirst();
       _index = 0;
     }
     return value;
   }
 
+  /*

[Mads Ager (google), 2011/12/06 14:05:02]

Do you want to use DartDoc style here: '/**'?

Half of the methods here seem to have DartDoc style comments and the rest do
not.

[Søren Gjesse, 2011/12/07 07:58:29]

I am not realy sure. This is an internal class. Made them all DartDoc style for
now.

+   * Read [count] bytes from the buffer list. If the number of bytes
+   * requested is not available null will be returned.
+   */
+  List<int> readBytes(int count) {
+    List<int> result;
+    if (_length == 0 || _length < count) return null;
+    if (_index == 0 && _buffers.first().length == count) {
+      result = _buffers.first();
+      _buffers.removeFirst();
+      _index = 0;
+      _length -= count;
+      return result;
+    } else {
+      int firstRemaining = _buffers.first().length - _index;
+      if (firstRemaining >= count) {
+        result = _buffers.first().getRange(_index, count);
+        _index += count;
+        _length -= count;
+        return result;
+      } else {
+        result = new List<int>(count);
+        int remaining = count;
+        while (remaining > 0) {
+          int bytesInFirst = _buffers.first().length - _index;
+          if (bytesInFirst <= remaining) {
+            result.setRange(count - remaining,
+                            bytesInFirst,
+                            _buffers.first(),
+                            _index);
+            _buffers.removeFirst();
+            _index = 0;
+            _length -= bytesInFirst;
+            remaining -= bytesInFirst;
+          } else {
+            result.setRange(count - remaining,
+                            remaining,
+                            _buffers.first(),
+                            _index);
+            _index = remaining;
+            _length -= remaining;
+            remaining = 0;
+            assert(_index < _buffers.first().length);
+          }
+        }
+        return result;
+      }
+    }
+  }
+
   /**
    * Remove a number of bytes from the buffer list. Currently the
    * number of bytes to remove must be confined to the first buffer.
    */
   void removeBytes(int count) {
     int firstRemaining = first.length - _index;
     assert(count <= firstRemaining);
     if (count == firstRemaining) {
       _buffers.removeFirst();
       _index = 0;
@@ skipping 21 matching lines @@
   void clear() {
     _index = 0;
     _length = 0;
     _buffers = new Queue();
   }
 
   int _length;  // Total number of bytes remaining in the buffers.
   Queue<List<int>> _buffers;  // List of data buffers.
   int _index;  // Index of the next byte in the first buffer.
 }