Add both sync and async methods for getting streams for a File

runtime/bin/file.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.
 
 
 /**
  * FileMode describes the modes in which a file can be opened.
  */
 class FileMode {
   static final READ = const FileMode(0);
@@ skipping 78 matching lines @@
    * By default mode is FileMode.READ.
    */
   void open([FileMode mode]);
 
   /**
    * Synchronously open the file for random access operations. The
    * result is a RandomAccessFile on which random access operations
    * can be performed. Opened RandomAccessFiles must be closed using
    * the [close] method.
    *
-   * Files can be opened in three modes:
-   *
-   * FileMode.READ: open the file for reading. If the file does not
-   * exist the [errorHandler] is called.
-   *
-   * FileMode.WRITE: open the file for both reading and writing and
-   * truncate the file to length zero. If the file does not exist the
-   * file is created.
-   *
-   * FileMode.APPEND: same as FileMode.WRITE except that the file is
-   * not truncated and the position is set to the end of the file.
-   *
-   * By default mode is FileMode.READ.
+   * See [open] for information on the [:mode:] argument.
    */
   RandomAccessFile openSync([FileMode mode]);
 
   /**
    * Get the canonical full path corresponding to the file name. The
    * [fullPathHandler] is called with the result when the fullPath
    * operation completes.
    */
   void fullPath();
 
   /**
    * Synchronously get the canonical full path corresponding to the file name.
    */
   String fullPathSync();
 
   /**
    * Create a new independent input stream for the file. The file
-   * input stream must be closed when no longer used to free up
-   * system resources.
+   * input stream must be closed when no longer used to free up system
+   * resources.  The [inputStreamHandler] is called with the result
+   * when the openInputStream operation completes.
    */
   InputStream openInputStream();
 
   /**
+   * Synchronously create a new independent input stream for the
+   * file. The file input stream must be closed when no longer used to
+   * free up system resources.
+   *
+   * Even though this call to open the input stream is synchronous
+   * then the input stream itself will be asynchronous as is the case

[Mads Ager (google), 2012/02/22 13:20:20]

is synchronous then the ... will be ..
=>
is synchronous the ... is ...

[Søren Gjesse, 2012/02/22 14:03:18]

Done.

+   * for all input streams.
+   */
+  InputStream openInputStreamSync();
+
+  /**
    * Creates a new independent output stream for the file. The file
    * output stream must be closed when no longer used to free up
    * system resources.
    *
    * An output stream can be opened in two modes:
    *
    * FileMode.WRITE: create the stream and truncate the underlying
    * file to length zero.
    *
    * FileMode.APPEND: create the stream and set the position to the end of
    * the underlying file.
    *
    * By default the mode is FileMode.WRITE.
    */
   OutputStream openOutputStream([FileMode mode]);
 
   /**
+   * Synchronously creates a new independent output stream for the
+   * file. The file output stream must be closed when no longer used
+   * to free up system resources.
+   *
+   * See [openOutputStream] for information on the [:mode:] argument.
+   *
+   * Even though this call to open the output stream is synchronous
+   * then the output stream itself will be asynchronous as is the case

[Mads Ager (google), 2012/02/22 13:20:20]

Ditto.

[Søren Gjesse, 2012/02/22 14:03:18]

Done.

+   * for all output streams.
+   */
+  OutputStream openOutputStreamSync([FileMode mode]);
+
+  /**
    * Get the name of the file.
    */
   String get name();
 
   /**
    * Sets the handler that gets called when an [exists] operation
    * completes.
    */
   void set existsHandler(void handler(bool exists));
 
   /**
    * Sets the handler that gets called when a [create] operation
    * completes.
    */
   void set createHandler(void handler());
 
   /**
    * Sets the handler that gets called when a [delete] operation
    * completes.
    */
   void set deleteHandler(void handler());
 
   /**
    * Sets the handler that gets called when an [open] operation
    * completes.
    */
   void set openHandler(void handler(RandomAccessFile openedFile));
 
   /**
+   * Sets the handler that gets called when an [openInputStream]
+   * operation completes.
+   */
+  void set inputStreamHandler(void handler(InputStream stream));
+
+  /**
+   * Sets the handler that gets called when an [openOutputStream]
+   * operation completes.
+   */
+  void set outputStreamHandler(void handler(OutputStream stream));
+
+  /**
    * Sets the handler that gets called when a [fullPath] operation
    * completes.
    */
   void set fullPathHandler(void handler(String path));
 
   /**
    * Sets the handler that gets called when errors occur during
    * operations on this file.
    */
   void set errorHandler(void handler(String error));
@@ skipping 202 matching lines @@
    */
   void set errorHandler(void handler(String error));
 }
 
 
 class FileIOException implements Exception {
   const FileIOException([String this.message = ""]);
   String toString() => "FileIOException: $message";
   final String message;
 }