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
@@ skipping 62 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`.

[Søren Gjesse, 2012/09/18 09:34:16]

No need for documentation of the default value.

[Mads Ager (google), 2012/09/18 10:46:39]

Done.

    */
-  StringInputStream(InputStream input, [Encoding encoding]);
+  factory StringInputStream(InputStream input,
+                            [Encoding encoding = Encoding.UTF_8]) {
+    return new _StringInputStream(input, encoding);
+  }
 
   /**
    * Reads as many characters as is available from the stream. If no data is
    * available null will be returned.
    */
   String read();
 
   /**
    * Reads the next line from the stream. The line ending characters
    * will not be part of the returned string. If a full line is not
@@ skipping 47 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;
 }