Format all dart: library files

sdk/lib/io/file.dart

 // Copyright (c) 2013, 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.
 
 part of dart.io;
 
 /**
  * The modes in which a File can be opened.
  */
 class FileMode {
   /// The mode for opening a file only for reading.
   static const READ = const FileMode._internal(0);
+
   /// Mode for opening a file for reading and writing. The file is
   /// overwritten if it already exists. The file is created if it does not
   /// already exist.
   static const WRITE = const FileMode._internal(1);
+
   /// Mode for opening a file for reading and writing to the
   /// end of it. The file is created if it does not already exist.
   static const APPEND = const FileMode._internal(2);
+
   /// Mode for opening a file for writing *only*. The file is
   /// overwritten if it already exists. The file is created if it does not
   /// already exist.
   static const WRITE_ONLY = const FileMode._internal(3);
+
   /// Mode for opening a file for writing *only* to the
   /// end of it. The file is created if it does not already exist.
   static const WRITE_ONLY_APPEND = const FileMode._internal(4);
   final int _mode;
 
   const FileMode._internal(this._mode);
 }
 
 /// The mode for opening a file only for reading.
 const READ = FileMode.READ;
+
 /// The mode for opening a file for reading and writing. The file is
 /// overwritten if it already exists. The file is created if it does not
 /// already exist.
 const WRITE = FileMode.WRITE;
+
 /// The mode for opening a file for reading and writing to the
 /// end of it. The file is created if it does not already exist.
 const APPEND = FileMode.APPEND;
+
 /// Mode for opening a file for writing *only*. The file is
 /// overwritten if it already exists. The file is created if it does not
 /// already exist.
 const WRITE_ONLY = FileMode.WRITE_ONLY;
+
 /// Mode for opening a file for writing *only* to the
 /// end of it. The file is created if it does not already exist.
 const WRITE_ONLY_APPEND = FileMode.WRITE_ONLY_APPEND;
 
-
 /// Type of lock when requesting a lock on a file.
 enum FileLock {
   /// Shared file lock.
   SHARED,
+
   /// Exclusive file lock.
   EXCLUSIVE,
+
   /// Blocking shared file lock.
   BLOCKING_SHARED,
+
   /// Blocking exclusive file lock.
   BLOCKING_EXCLUSIVE,
 }
 
 /**
  * A reference to a file on the file system.
  *
  * A File instance is an object that holds a [path] on which operations can
  * be performed.
  * You can get the parent directory of the file using the getter [parent],
@@ skipping 182 matching lines @@
   /**
    * Renames this file. Returns a `Future<File>` that completes
    * with a [File] instance for the renamed file.
    *
    * If [newPath] identifies an existing file, that file is
    * replaced. If [newPath] identifies an existing directory, the
    * operation fails and the future completes with an exception.
    */
   Future<File> rename(String newPath);
 
-   /**
+  /**
    * Synchronously renames this file. Returns a [File]
    * instance for the renamed file.
    *
    * If [newPath] identifies an existing file, that file is
    * replaced. If [newPath] identifies an existing directory the
    * operation fails and an exception is thrown.
    */
   File renameSync(String newPath);
 
   /**
    * Copy this file. Returns a `Future<File>` that completes
    * with a [File] instance for the copied file.
    *
    * If [newPath] identifies an existing file, that file is
    * replaced. If [newPath] identifies an existing directory, the
    * operation fails and the future completes with an exception.
    */
   Future<File> copy(String newPath);
 
-   /**
+  /**
    * Synchronously copy this file. Returns a [File]
    * instance for the copied file.
    *
    * If [newPath] identifies an existing file, that file is
    * replaced. If [newPath] identifies an existing directory the
    * operation fails and an exception is thrown.
    */
   File copySync(String newPath);
 
   /**
@@ skipping 143 matching lines @@
    *
    * * [FileMode.WRITE]: truncates the file to length zero.
    * * [FileMode.APPEND]: sets the initial write position to the end
    *   of the file.
    *
    *  When writing strings through the returned [IOSink] the encoding
    *  specified using [encoding] will be used. The returned [IOSink]
    *  has an `encoding` property which can be changed after the
    *  [IOSink] has been created.
    */
-  IOSink openWrite({FileMode mode: FileMode.WRITE,
-                    Encoding encoding: UTF8});
+  IOSink openWrite({FileMode mode: FileMode.WRITE, Encoding encoding: UTF8});
 
   /**
    * 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.
@@ skipping 44 matching lines @@
    * the entire operation has completed.
    *
    * By default [writeAsBytes] creates the file for writing and truncates the
    * file if it already exists. In order to append the bytes to an existing
    * file, pass [FileMode.APPEND] as the optional mode parameter.
    *
    * If the argument [flush] is set to `true`, the data written will be
    * flushed to the file system before the returned future completes.
    */
   Future<File> writeAsBytes(List<int> bytes,
-                            {FileMode mode: FileMode.WRITE,
-                             bool flush: false});
+      {FileMode mode: FileMode.WRITE, bool flush: false});
 
   /**
    * Synchronously write a list of bytes to a file.
    *
    * Opens the file, writes the list of bytes to it and closes the file.
    *
    * By default [writeAsBytesSync] creates the file for writing and truncates
    * the file if it already exists. In order to append the bytes to an existing
    * file, pass [FileMode.APPEND] as the optional mode parameter.
    *
    * If the [flush] argument is set to `true` data written will be
    * flushed to the file system before returning.
    *
    * Throws a [FileSystemException] if the operation fails.
    */
   void writeAsBytesSync(List<int> bytes,
-                        {FileMode mode: FileMode.WRITE,
-                         bool flush: false});
+      {FileMode mode: FileMode.WRITE, bool flush: false});
 
   /**
    * Write a string to a file.
    *
    * Opens the file, writes the string in the given encoding, and closes the
    * file. Returns a `Future<File>` that completes with this [File] object
    * once the entire operation has completed.
    *
    * By default [writeAsString] creates the file for writing and truncates the
    * file if it already exists. In order to append the bytes to an existing
    * file, pass [FileMode.APPEND] as the optional mode parameter.
    *
    * If the argument [flush] is set to `true`, the data written will be
    * flushed to the file system before the returned future completes.
    *
    */
   Future<File> writeAsString(String contents,
-                             {FileMode mode: FileMode.WRITE,
-                              Encoding encoding: UTF8,
-                              bool flush: false});
+      {FileMode mode: FileMode.WRITE,
+      Encoding encoding: UTF8,
+      bool flush: false});
 
   /**
    * Synchronously write a string to a file.
    *
    * Opens the file, writes the string in the given encoding, and closes the
    * file.
    *
    * By default [writeAsStringSync] creates the file for writing and
    * truncates the file if it already exists. In order to append the bytes
    * to an existing file, pass [FileMode.APPEND] as the optional mode
    * parameter.
    *
    * If the [flush] argument is set to `true` data written will be
    * flushed to the file system before returning.
    *
    * Throws a [FileSystemException] if the operation fails.
    */
   void writeAsStringSync(String contents,
-                         {FileMode mode: FileMode.WRITE,
-                          Encoding encoding: UTF8,
-                          bool flush: false});
+      {FileMode mode: FileMode.WRITE,
+      Encoding encoding: UTF8,
+      bool flush: false});
 
   /**
    * Get the path of the file.
    */
   String get path;
 }
 
-
 /**
  * `RandomAccessFile` provides random access to the data in a
  * file.
  *
  * `RandomAccessFile` objects are obtained by calling the
  * `open` method on a [File] object.
  *
  * A `RandomAccessFile` have both asynchronous and synchronous
  * methods. The asynchronous methods all return a `Future`
  * whereas the synchronous methods will return the result directly,
@@ skipping 85 matching lines @@
   int writeByteSync(int value);
 
   /**
    * Writes from a [List<int>] to the file. It will read the buffer from index
    * [start] to index [end]. If [start] is omitted, it'll start from index 0.
    * If [end] is omitted, it will write to end of [buffer].
    *
    * Returns a `Future<RandomAccessFile>` that completes with this
    * [RandomAccessFile] when the write completes.
    */
-  Future<RandomAccessFile> writeFrom(
-      List<int> buffer, [int start = 0, int end]);
+  Future<RandomAccessFile> writeFrom(List<int> buffer,
+      [int start = 0, int end]);
 
   /**
    * Synchronously writes from a [List<int>] to the file. It will read the
    * buffer from index [start] to index [end]. If [start] is omitted, it'll
    * start from index 0. If [end] is omitted, it will write to the end of
    * [buffer].
    *
    * Throws a [FileSystemException] if the operation fails.
    */
   void writeFromSync(List<int> buffer, [int start = 0, int end]);
 
   /**
    * Writes 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: UTF8});
+      {Encoding encoding: UTF8});
 
   /**
    * Synchronously writes a single string to the file using the given
    * [Encoding].
    *
    * Throws a [FileSystemException] if the operation fails.
    */
-  void writeStringSync(String string,
-                       {Encoding encoding: UTF8});
+  void writeStringSync(String string, {Encoding encoding: UTF8});
 
   /**
    * Gets the current byte position in the file. Returns a
    * `Future<int>` that completes with the position.
    */
   Future<int> position();
 
   /**
    * Synchronously gets the current byte position in the file.
    *
@@ skipping 169 matching lines @@
    * Returns a human-readable string for this RandomAccessFile instance.
    */
   String toString();
 
   /**
    * Gets the path of the file underlying this RandomAccessFile.
    */
   String get path;
 }
 
-
 /**
  * Exception thrown when a file operation fails.
  */
 class FileSystemException implements IOException {
   /**
    * Message describing the error. This does not include any detailed
    * information form the underlying OS error. Check [osError] for
    * that information.
    */
   final String message;
@@ skipping 32 matching lines @@
       sb.write(": $osError");
       if (path != null) {
         sb.write(", path = '$path'");
       }
     } else if (path != null) {
       sb.write(": $path");
     }
     return sb.toString();
   }
 }