Implement File.{readAsBytes, readAsText, readAsLines}.

runtime/bin/file_impl.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.
 
 class _FileInputStream extends _BaseDataInputStream implements InputStream {
   _FileInputStream(RandomAccessFile this._file, int this._length) {
     _streamMarkedClosed = true;
     _checkScheduleCallbacks();
   }
 
@@ skipping 747 matching lines @@
           "Mixed use of synchronous and asynchronous API");
     }
     String result = _FileUtils.checkedFullPath(_name);
     if (result == null) {
       throw new FileIOException("fullPath failed");
     }
     return result;
   }
 
   void openInputStream() {
+    _asyncUsed = true;
     // Create a new file object to handle the opening of the file for
     // creating an input stream. Currently the file input stream uses
     // synchronous calls on the opened file so we need to open it
     // synchronously.
     File file = new File(this._name);
     file.errorHandler = (String error) {
       if (_errorHandler != null) _errorHandler(error);
     };
     RandomAccessFile openedFile = file.openSync();
     InputStream stream =
         new _FileInputStream(openedFile, openedFile.lengthSync());
     new Timer(
         (Timer ignore) {
           if (_inputStreamHandler != null) _inputStreamHandler(stream);
         }, 0);
   }
 
   InputStream openInputStreamSync() {
     if (_asyncUsed) {
       throw new FileIOException(
           "Mixed use of synchronous and asynchronous API");
     }
     RandomAccessFile openedFile = openSync();
     return new _FileInputStream(openedFile, openedFile.lengthSync());
   }
 
   void openOutputStream([FileMode mode = FileMode.WRITE]) {
+    _asyncUsed = true;
     if (mode != FileMode.WRITE &&
         mode != FileMode.APPEND) {
       throw new FileIOException(
           "Wrong FileMode. Use FileMode.WRITE or FileMode.APPEND");
     }
     // Create a new file object to handle the opening of the file for
     // creating an input stream. Currently the file input stream uses
     // synchronous calls on the opened file so we need to open it
     // synchronously.
     File file = new File(this._name);
@@ skipping 15 matching lines @@
     }
     if (mode != FileMode.WRITE &&
         mode != FileMode.APPEND) {
       throw new FileIOException(
           "Wrong FileMode. Use FileMode.WRITE or FileMode.APPEND");
     }
     RandomAccessFile openedFile = openSync(mode);
     return new _FileOutputStream(openedFile);
   }
 
+  void readAsBytes() {
+    _asyncUsed = true;
+    var chunks = [];

[Søren Gjesse, 2012/02/24 07:24:51]

We have the class _BufferList in runtime/bin.

var chunks = new _BufferList()
chunks.add(...)
chunks.add(...)
...
List<int> all = chunks.readBytes(chunks.length);

[Mads Ager (google), 2012/02/24 13:11:17]

Done.

+    var resultLength = 0;
+    openInputStream();
+    inputStreamHandler = (inputStream) {
+      inputStream.closeHandler = () {
+        if (_readAsBytesHandler != null) {
+          var result = new ByteArray(resultLength);
+          var resultIndex = 0;
+          for (var i = 0; i < chunks.length; i++) {
+            var chunk = chunks[i];
+            result.setRange(resultIndex, chunk.length, chunk);
+            resultIndex += chunk.length;
+          }
+          _readAsBytesHandler(result);
+        }
+      };
+      inputStream.dataHandler = () {
+        var chunk = inputStream.read();
+        chunks.add(chunk);
+        resultLength += chunk.length;
+      };
+      inputStream.errorHandler = () {
+        if (_errorHandler != null) {
+          _errorHandler("Failed to read file as bytes: $_name");
+        }
+      };
+    };
+  }
+
+  List<int> readAsBytesSync() {
+    if (_asyncUsed) {
+      throw new FileIOException(
+          "Mixed use of synchronous and asynchronous API");
+    }
+    var opened = openSync();
+    var length = opened.lengthSync();
+    var result = new ByteArray(length);
+    var read = opened.readListSync(result, 0, length);
+    if (read != length) {
+      throw new FileIOException("Failed reading file as bytes: $_name");
+    }
+    return result;
+  }
+
+  _StringDecoder _getDecoder(encoding) {
+    if (encoding == "UTF-8") {
+      return new _UTF8Decoder();
+    } else if (_encoding == "ISO-8859-1") {
+      return new _Latin1Decoder();
+    } else if (_encoding == "ASCII") {
+      return new _AsciiDecoder();
+    }
+    throw new FileIOException("Unsupported encoding $_encoding");
+  }
+
+  void readAsText([String encoding = "UTF-8"]) {
+    _asyncUsed = true;
+    var decoder = _getDecoder(encoding);
+    readAsBytes();
+    readAsBytesHandler = (bytes) {
+      if (_readAsTextHandler != null) {
+        decoder.write(bytes);
+        _readAsTextHandler(decoder.decoded);
+      }
+    };
+  }
+
+  String readAsTextSync([String encoding = "UTF-8"]) {
+    if (_asyncUsed) {
+      throw new FileIOException(
+          "Mixed use of synchronous and asynchronous API");
+    }
+    var decoder = _getDecoder(encoding);
+    List<int> bytes = readAsBytesSync();
+    decoder.write(bytes);
+    return decoder.decoded;
+  }
+
+  List<String> _getDecodedLines(_StringDecoder decoder) {
+    List<String> result = [];
+    var line = decoder.decodedLine;
+    while (line != null) {
+      result.add(line);
+      line = decoder.decodedLine;
+    }
+    // If there is more data with no terminating line break we treat
+    // it as the last line.
+    var data = decoder.decoded;
+    if (data != null) {
+      result.add(data);
+    }
+    return result;
+  }
+
+  void readAsLines([String encoding = "UTF-8"]) {
+    _asyncUsed = true;
+    var decoder = _getDecoder(encoding);
+    readAsBytes();
+    readAsBytesHandler = (bytes) {
+      if (_readAsLinesHandler != null) {
+        decoder.write(bytes);
+        _readAsLinesHandler(_getDecodedLines(decoder));
+      }
+    };
+  }
+
+  List<String> readAsLinesSync([String encoding = "UTF-8"]) {
+    if (_asyncUsed) {
+      throw new FileIOException(
+          "Mixed use of synchronous and asynchronous API");
+    }
+    var decoder = _getDecoder(encoding);
+    List<int> bytes = readAsBytesSync();
+    decoder.write(bytes);
+    return _getDecodedLines(decoder);
+  }
+
   String get name() => _name;
 
   void set existsHandler(void handler(bool exists)) {
     _existsHandler = handler;
   }
 
   void set createHandler(void handler()) {
     _createHandler = handler;
   }
 
@@ skipping 10 matching lines @@
   }
 
   void set inputStreamHandler(void handler(InputStream stream)) {
     _inputStreamHandler = handler;
   }
 
   void set outputStreamHandler(void handler(OutputStream stream)) {
     _outputStreamHandler = handler;
   }
 
+  void set readAsBytesHandler(void handler(List<int> bytes)) {
+    _readAsBytesHandler = handler;
+  }
+
+  void set readAsTextHandler(void handler(String text)) {
+    _readAsTextHandler = handler;
+  }
+
+  void set readAsLinesHandler(void handler(List<String> lines)) {
+    _readAsLinesHandler = handler;
+  }
+
   void set fullPathHandler(void handler(String)) {
     _fullPathHandler = handler;
   }
 
   void set errorHandler(void handler(String error)) {
     _errorHandler = handler;
   }
 
   String _name;
   bool _asyncUsed;
 
   _FileOperationScheduler _scheduler;
 
   Function _existsHandler;
   Function _createHandler;
   Function _deleteHandler;
   Function _directoryHandler;
   Function _openHandler;
   Function _inputStreamHandler;
   Function _outputStreamHandler;
+  Function _readAsBytesHandler;
+  Function _readAsTextHandler;
+  Function _readAsLinesHandler;
   Function _fullPathHandler;
   Function _errorHandler;
 }
 
 
 class _RandomAccessFile implements RandomAccessFile {
   _RandomAccessFile(int this._id, String this._name)
     : _scheduler = new _FileOperationScheduler(),
       _asyncUsed = false;
 
@@ skipping 393 matching lines @@
   Function _readByteHandler;
   Function _readListHandler;
   Function _noPendingWriteHandler;
   Function _positionHandler;
   Function _setPositionHandler;
   Function _truncateHandler;
   Function _lengthHandler;
   Function _flushHandler;
   Function _errorHandler;
 }