Switch from interfaces to abstract classes in dart:io.

runtime/bin/input_stream.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.
 
 /**
  * Basic input stream which supplies binary data.
  *
  * Input streams are used to read data sequentially from some data
  * source. All input streams are non-blocking. They each have a number
  * of read calls which will always return without any IO related
@@ skipping 13 matching lines @@
  *
  * If for some reason the data from an input stream cannot be handled
  * by the application immediately setting the data handler to `null`
  * will avoid further callbacks until it is set to a function
  * again. While the data handler is not active system flow control
  * will be used to avoid buffering more data than needed.
  *
  * Always set up appropriate handlers when using input streams.
  *
  */
-interface InputStream {
+abstract class InputStream {
   /**
    * Reads data from the stream. Returns a system allocated buffer
    * with up to [len] bytes. If no value is passed for [len] all
    * available data will be returned. If no data is available null will
    * be returned.
    */
   List<int> read([int len]);
 
   /**
    * Reads up to [len] bytes into buffer [buffer] starting at offset
    * [offset]. Returns the number of bytes actually read which might
    * be zero. If [offset] is not specified 0 is used. If [len] is not
    * specified the length of [buffer] is used.
    */
   int readInto(List<int> buffer, [int offset, int len]);
 
   /**
    * Returns the number of bytes available for immediate reading.
    */
   int available();
 
   /**
    * Pipe the content of this input stream directly to the output
    * stream [output]. The default behavior is to close the output when
    * all the data from the input stream have been written. Specifying
    * `false` for the optional argument [close] keeps the output
-   * stream open after writing all data from the input stream. The
-   * default value for [close] is `true`.
+   * stream open after writing all data from the input stream.
    */
-  void pipe(OutputStream output, [bool close]);
+  void pipe(OutputStream output, [bool close = true]);
 
   /**
    * Close the underlying communication channel to avoid getting any
    * more data. In normal situations, where all data is read from the
    * stream until the close handler is called, calling [close] is not
    * required. When [close] is used the close handler will still be
    * called.
    */
   void close();
 
@@ skipping 32 matching lines @@
   const Encoding._internal(String this.name);
   final String name;
 }
 
 
 /**
  * A string input stream wraps a basic input stream and supplies
  * string data. This data can be read either as string chunks or as
  * lines separated by line termination character sequences.
  */
-interface StringInputStream default _StringInputStream {
+abstract class StringInputStream {
   /**
    * Decodes a binary input stream into characters using the specified
-   * encoding. The default encoding is UTF-8 - `Encoding.UTF_8`.
+   * encoding.
    */
-  StringInputStream(InputStream input, [Encoding encoding]);
+  factory StringInputStream(InputStream input,
+                            [Encoding encoding = Encoding.UTF_8]) {
+    return new _StringInputStream(input, encoding);
+  }
 
   /**
    * Reads up to [len] characters from the stream. if [len] is not
    * specified reads as many characters as is available from the
    * stream. If no data is available null will be returned.
    */
   String read([int len]);
 
   /**
    * Reads the next line from the stream. The line ending characters
@@ skipping 48 matching lines @@
    * communication channel gets into some kind of error situation.
    */
   void set onError(void callback(e));
 }
 
 
 /**
  * A chunked input stream wraps a basic input stream and supplies
  * binary data in configurable chunk sizes.
  */
-interface ChunkedInputStream default _ChunkedInputStream {
+abstract class ChunkedInputStream {
   /**
    * Adds buffering to an input stream and provide the ability to read
    * the data in known size chunks.
    */
-  ChunkedInputStream(InputStream input, [int chunkSize]);
+  factory ChunkedInputStream(InputStream input, [int chunkSize = 0]) {
+    return new _ChunkedInputStream(input, chunkSize);
+  }
 
   /**
    * Reads [chunkSize] bytes from the stream. If [chunkSize] bytes are
    * not currently available null is returned. When the stream is
    * closed the last call can return with less than [chunkSize] bytes.
    */
   List<int> read();
 
   /**
    * Returns whether the stream has been closed. There might still be
@@ skipping 31 matching lines @@
   void set onError(void callback(e));
 }
 
 
 class StreamException implements Exception {
   const StreamException([String this.message = ""]);
   const StreamException.streamClosed() : message = "Stream closed";
   String toString() => "StreamException: $message";
   final String message;
 }