Format all dart: library files

sdk/lib/io/stdio.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;
 
 const int _STDIO_HANDLE_TYPE_TERMINAL = 0;
 const int _STDIO_HANDLE_TYPE_PIPE = 1;
 const int _STDIO_HANDLE_TYPE_FILE = 2;
 const int _STDIO_HANDLE_TYPE_SOCKET = 3;
 const int _STDIO_HANDLE_TYPE_OTHER = 4;
 
-
 class _StdStream extends Stream<List<int>> {
   final Stream<List<int>> _stream;
 
   _StdStream(this._stream);
 
   StreamSubscription<List<int>> listen(void onData(List<int> event),
-                                       {Function onError,
-                                        void onDone(),
-                                        bool cancelOnError}) {
-    return _stream.listen(
-        onData,
-        onError: onError,
-        onDone: onDone,
-        cancelOnError: cancelOnError);
+      {Function onError, void onDone(), bool cancelOnError}) {
+    return _stream.listen(onData,
+        onError: onError, onDone: onDone, cancelOnError: cancelOnError);
   }
 }
 
-
 /**
  * [Stdin] allows both synchronous and asynchronous reads from the standard
  * input stream.
  *
  * Mixing synchronous and asynchronous reads is undefined.
  */
 class Stdin extends _StdStream implements Stream<List<int>> {
   Stdin._(Stream<List<int>> stream) : super(stream);
 
   /**
    * Synchronously read a line from stdin. This call will block until a full
    * line is available.
    *
    * The argument [encoding] can be used to changed how the input should be
    * decoded. Default is [SYSTEM_ENCODING].
    *
    * If [retainNewlines] is `false`, the returned String will not contain the
    * final newline. If `true`, the returned String will contain the line
    * terminator. Default is `false`.
    *
    * If end-of-file is reached after any bytes have been read from stdin,
    * that data is returned.
    * Returns `null` if no bytes preceded the end of input.
    */
-  String readLineSync({Encoding encoding: SYSTEM_ENCODING,
-                       bool retainNewlines: false}) {
+  String readLineSync(
+      {Encoding encoding: SYSTEM_ENCODING, bool retainNewlines: false}) {
     const CR = 13;
     const LF = 10;
     final List<int> line = <int>[];
     // On Windows, if lineMode is disabled, only CR is received.
     bool crIsNewline = Platform.isWindows &&
         (stdioType(stdin) == StdioType.TERMINAL) &&
         !lineMode;
     if (retainNewlines) {
       int byte;
       do {
@@ skipping 12 matching lines @@
         int byte = readByteSync();
         if (byte < 0) {
           if (line.isEmpty) return null;
           break;
         }
         if (byte == LF || byte == CR) break;
         line.add(byte);
       }
     } else {
       // Case having to handel CR LF as a single unretained line terminator.
-      outer: while (true) {
+      outer:
+      while (true) {
         int byte = readByteSync();
         if (byte == LF) break;
         if (byte == CR) {
           do {
             byte = readByteSync();
             if (byte == LF) break outer;
 
             line.add(CR);
           } while (byte == CR);
           // Fall through and handle non-CR character.
@@ skipping 43 matching lines @@
 
   /**
    * Synchronously read a byte from stdin. This call will block until a byte is
    * available.
    *
    * If at end of file, -1 is returned.
    */
   external int readByteSync();
 }
 
-
 /**
  * [Stdout] represents the [IOSink] for either `stdout` or `stderr`.
  *
  * It provides a *blocking* `IOSink`, so using this to write will block until
  * the output is written.
  *
  * In some situations this blocking behavior is undesirable as it does not
  * provide the same non-blocking behavior as dart:io in general exposes.
  * Use the property [nonBlocking] to get an `IOSink` which has the non-blocking
  * behavior.
@@ skipping 36 matching lines @@
    * Get a non-blocking `IOSink`.
    */
   IOSink get nonBlocking {
     if (_nonBlocking == null) {
       _nonBlocking = new IOSink(new _FileStreamConsumer.fromStdio(_fd));
     }
     return _nonBlocking;
   }
 }
 
-
 class StdoutException implements IOException {
   final String message;
   final OSError osError;
 
   const StdoutException(this.message, [this.osError]);
 
   String toString() {
     return "StdoutException: $message${osError == null ? "" : ", $osError"}";
   }
 }
 
-
 class StdinException implements IOException {
   final String message;
   final OSError osError;
 
   const StdinException(this.message, [this.osError]);
 
   String toString() {
     return "StdinException: $message${osError == null ? "" : ", $osError"}";
   }
 }
 
-
 class _StdConsumer implements StreamConsumer<List<int>> {
   final _file;
 
   _StdConsumer(int fd) : _file = _File._openStdioSync(fd);
 
   Future addStream(Stream<List<int>> stream) {
     var completer = new Completer();
     var sub;
-    sub = stream.listen(
-        (data) {
-          try {
-            _file.writeFromSync(data);
-          } catch (e, s) {
-            sub.cancel();
-            completer.completeError(e, s);
-          }
-        },
+    sub = stream.listen((data) {
+      try {
+        _file.writeFromSync(data);
+      } catch (e, s) {
+        sub.cancel();
+        completer.completeError(e, s);
+      }
+    },
         onError: completer.completeError,
         onDone: completer.complete,
         cancelOnError: true);
     return completer.future;
   }
 
   Future close() {
     _file.closeSync();
     return new Future.value();
   }
@@ skipping 15 matching lines @@
       _IOSinkImpl sink = _sink;
       _StdConsumer target = sink._target;
       target._file.translation = t;
     }
   }
 
   void write(object) {
     _translation = _FileTranslation.text;
     _sink.write(object);
   }
-  void writeln([object = "" ]) {
+
+  void writeln([object = ""]) {
     _translation = _FileTranslation.text;
     _sink.writeln(object);
   }
+
   void writeAll(objects, [sep = ""]) {
     _translation = _FileTranslation.text;
     _sink.writeAll(objects, sep);
   }
+
   void add(List<int> data) {
     _translation = _FileTranslation.binary;
     _sink.add(data);
   }
+
   void addError(error, [StackTrace stackTrace]) {
     _sink.addError(error, stackTrace);
   }
+
   void writeCharCode(int charCode) {
     _translation = _FileTranslation.text;
     _sink.writeCharCode(charCode);
   }
+
   Future addStream(Stream<List<int>> stream) {
     _translation = _FileTranslation.binary;
     return _sink.addStream(stream);
   }
+
   Future flush() => _sink.flush();
   Future close() => _sink.close();
   Future get done => _sink.done;
 }
 
 class _StdFileSink extends _StdSinkHelper {
   // The target of `sink` is expected to be a _StdConsumer.
   _StdFileSink(IOSink sink) : super(sink, true);
 }
 
 class _StdSocketSink extends _StdSinkHelper {
   _StdSocketSink(IOSink sink) : super(sink, false);
 }
 
 /// The type of object a standard IO stream is attached to.
 class StdioType {
   static const StdioType TERMINAL = const StdioType._("terminal");
   static const StdioType PIPE = const StdioType._("pipe");
   static const StdioType FILE = const StdioType._("file");
   static const StdioType OTHER = const StdioType._("other");
   final String name;
   const StdioType._(this.name);
   String toString() => "StdioType: $name";
 }
 
-
 Stdin _stdin;
 Stdout _stdout;
 Stdout _stderr;
 
-
 /// The standard input stream of data read by this program.
 Stdin get stdin {
   if (_stdin == null) {
     _stdin = _StdIOUtils._getStdioInputStream();
   }
   return _stdin;
 }
 
-
 /// The standard output stream of data written by this program.
 Stdout get stdout {
   if (_stdout == null) {
     _stdout = _StdIOUtils._getStdioOutputStream(1);
   }
   return _stdout;
 }
 
-
 /// The standard output stream of errors written by this program.
 Stdout get stderr {
   if (_stderr == null) {
     _stderr = _StdIOUtils._getStdioOutputStream(2);
   }
   return _stderr;
 }
 
-
 /// For a stream, returns whether it is attached to a file, pipe, terminal, or
 /// something else.
 StdioType stdioType(object) {
   if (object is _StdStream) {
     object = object._stream;
   } else if (object == stdout || object == stderr) {
     switch (_StdIOUtils._getStdioHandleType(object == stdout ? 1 : 2)) {
-      case _STDIO_HANDLE_TYPE_TERMINAL: return StdioType.TERMINAL;
-      case _STDIO_HANDLE_TYPE_PIPE: return StdioType.PIPE;
-      case _STDIO_HANDLE_TYPE_FILE:  return StdioType.FILE;
+      case _STDIO_HANDLE_TYPE_TERMINAL:
+        return StdioType.TERMINAL;
+      case _STDIO_HANDLE_TYPE_PIPE:
+        return StdioType.PIPE;
+      case _STDIO_HANDLE_TYPE_FILE:
+        return StdioType.FILE;
     }
   }
   if (object is _FileStream) {
     return StdioType.FILE;
   }
   if (object is Socket) {
     int socketType = _StdIOUtils._socketType(object);
     if (socketType == null) return StdioType.OTHER;
     switch (socketType) {
       case _STDIO_HANDLE_TYPE_TERMINAL:
         return StdioType.TERMINAL;
       case _STDIO_HANDLE_TYPE_PIPE:
         return StdioType.PIPE;
       case _STDIO_HANDLE_TYPE_FILE:
         return StdioType.FILE;
     }
   }
   if (object is _IOSinkImpl) {
     try {
       if (object._target is _FileStreamConsumer) {
         return StdioType.FILE;
       }
     } catch (e) {
       // Only the interface implemented, _sink not available.
     }
   }
   return StdioType.OTHER;
 }
 
-
 class _StdIOUtils {
   external static _getStdioOutputStream(int fd);
   external static Stdin _getStdioInputStream();
+
   /// Returns the socket type or `null` if [socket] is not a builtin socket.
   external static int _socketType(Socket socket);
   external static _getStdioHandleType(int fd);
 }