Switch from interfaces to abstract classes in dart:io.

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 const READ = const FileMode._internal(0);
   static const WRITE = const FileMode._internal(1);
   static const APPEND = const FileMode._internal(2);
   const FileMode._internal(int this._mode);
   final int _mode;
 }
 
 
 /**
  * [File] objects are references to files.
  *
  * To operate on the underlying file data you need to either get
  * streams using [openInputStream] and [openOutputStream] or open the
  * file for random access operations using [open].
  */
-interface File default _File {
+abstract class File {
   /**
    * Create a File object.
    */
-  File(String name);
+  factory File(String name) => new _File(name);
 
   /**
    * Create a File object from a Path object.
    */
-  File.fromPath(Path path);
+  factory File.fromPath(Path path) => new _File.fromPath(path);
 
   /**
    * Check if the file exists. Does not block and returns a
    * [:Future<bool>:].
    */
   Future<bool> exists();
 
   /**
    * Synchronously check if the file exists.
    */
@@ skipping 73 matching lines @@
    * Files can be opened in three modes:
    *
    * FileMode.READ: open the file for reading.
    *
    * 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.
-   *
-   * The default value for [mode] is [:FileMode.READ:].
    */
-  Future<RandomAccessFile> open([FileMode mode]);
+  Future<RandomAccessFile> open([FileMode mode = FileMode.READ]);
 
   /**
    * 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.
    *
-   * The default value for [mode] is [:FileMode.READ:].
-   *
    * See [open] for information on the [mode] argument.
    */
-  RandomAccessFile openSync([FileMode mode]);
+  RandomAccessFile openSync([FileMode mode = FileMode.READ]);
 
   /**
    * Get the canonical full path corresponding to the file name.
    * Returns a [:Future<String>:] that completes with the path.
    */
   Future<String> fullPath();
 
   /**
    * Synchronously get the canonical full path corresponding to the file name.
    */
@@ skipping 11 matching lines @@
    * 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]);
+  OutputStream openOutputStream([FileMode mode = FileMode.WRITE]);
 
   /**
    * Read the entire file contents as a list of bytes. Returns a
    * [:Future<List<int>>:] that completes with the list of bytes that
    * is the contents of the file.
    */
   Future<List<int>> readAsBytes();
 
   /**
    * Synchronously read the entire file contents as a list of bytes.
    */
   List<int> readAsBytesSync();
 
   /**
    * Read the entire file contents as text using the given
-   * [encoding]. The default encoding is [:Encoding.UTF_8:].
+   * [encoding].
    *
    * Returns a [:Future<String>:] that completes with the string once
    * the file contents has been read.
    */
-  Future<String> readAsText([Encoding encoding]);
+  Future<String> readAsText([Encoding encoding = Encoding.UTF_8]);
 
   /**
    * Synchronously read the entire file contents as text using the
-   * given [encoding]. The default encoding is [:Encoding.UTF_8:].
+   * given [encoding].
    */
-  String readAsTextSync([Encoding encoding]);
+  String readAsTextSync([Encoding encoding = Encoding.UTF_8]);
 
   /**
    * Read the entire file contents as lines of text using the give
-   * [encoding]. The default encoding is [:Encoding.UTF_8:].
+   * [encoding].
    *
    * Returns a [:Future<List<String>>:] that completes with the lines
    * once the file contents has been read.
    */
-  Future<List<String>> readAsLines([Encoding encoding]);
+  Future<List<String>> readAsLines([Encoding encoding = Encoding.UTF_8]);
 
   /**
    * Synchronously read the entire file contents as lines of text
-   * using the given [encoding] The default encoding is
-   * [:Encoding.UTF_8:].
+   * using the given [encoding].
    */
-  List<String> readAsLinesSync([Encoding encoding]);
+  List<String> readAsLinesSync([Encoding encoding = Encoding.UTF_8]);
 
   /**
    * Get the name of the file.
    */
   String get name;
 }
 
 
 /**
  * [RandomAccessFile] provides random access to the data in a
  * file. [RandomAccessFile] objects are obtained by calling the
  * [:open:] method on a [File] object.
  */
-interface RandomAccessFile {
+abstract class RandomAccessFile {
   /**
    * Close the file. Returns a [:Future<RandomAccessFile>:] that
    * completes with this RandomAccessFile when it has been closed.
    */
   Future<RandomAccessFile> close();
 
   /**
    * Synchronously close the file.
    */
   void closeSync();
@@ skipping 42 matching lines @@
    */
   Future<RandomAccessFile> writeList(List<int> buffer, int offset, int bytes);
 
   /**
    * Synchronously write a List<int> to the file. Returns the number
    * of bytes successfully written.
    */
   int writeListSync(List<int> buffer, int offset, int bytes);
 
   /**
-   * Write a string to the file using the given [encoding]. The
-   * default encoding is UTF-8 - [:Encoding.UTF_8:]. Returns a
+   * Write a string to the file using the given [encoding]. Returns a
    * [:Future<RandomAccessFile>:] that completes with this
    * RandomAccessFile when the write completes.
    */
-  Future<RandomAccessFile> writeString(String string, [Encoding encoding]);
+  Future<RandomAccessFile> writeString(String string,
+                                       [Encoding encoding = Encoding.UTF_8]);
 
   /**
    * Synchronously write a single string to the file using the given
    * [encoding]. Returns the number of characters successfully
-   * written. The default encoding is UTF-8 - [:Encoding.UTF_8:].
+   * written.
    */
-  int writeStringSync(String string, [Encoding encoding]);
+  int writeStringSync(String string,
+                      [Encoding encoding = Encoding.UTF_8]);
 
   /**
    * Get the current byte position in the file. Returns a
    * [:Future<int>:] that completes with the position.
    */
   Future<int> position();
 
   /**
    * Synchronously get the current byte position in the file.
    */
@@ skipping 65 matching lines @@
         sb.add(" ($osError)");
       }
     } else if (osError != null) {
       sb.add(": osError");
     }
     return sb.toString();
   }
   final String message;
   final OSError osError;
 }