Format all dart: library files

sdk/lib/io/socket.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;
 
-
 /**
  * [InternetAddressType] is the type an [InternetAddress]. Currently,
  * IP version 4 (IPv4) and IP version 6 (IPv6) are supported.
  */
 class InternetAddressType {
   static const InternetAddressType IP_V4 = const InternetAddressType._(0);
   static const InternetAddressType IP_V6 = const InternetAddressType._(1);
   static const InternetAddressType ANY = const InternetAddressType._(-1);
 
   final int _value;
 
   const InternetAddressType._(this._value);
 
   factory InternetAddressType._from(int value) {
     if (value == 0) return IP_V4;
     if (value == 1) return IP_V6;
     throw new ArgumentError("Invalid type: $value");
   }
 
   /**
    * Get the name of the type, e.g. "IP_V4" or "IP_V6".
    */
   String get name {
     switch (_value) {
-      case -1: return "ANY";
-      case 0: return "IP_V4";
-      case 1: return "IP_V6";
-      default: throw new ArgumentError("Invalid InternetAddress");
+      case -1:
+        return "ANY";
+      case 0:
+        return "IP_V4";
+      case 1:
+        return "IP_V6";
+      default:
+        throw new ArgumentError("Invalid InternetAddress");
     }
   }
 
   String toString() => "InternetAddressType: $name";
 }
 
-
 /**
  * An internet address.
  *
  * This object holds an internet address. If this internet address
  * is the result of a DNS lookup, the address also holds the hostname
  * used to make the lookup.
  * An Internet address combined with a port number represents an
  * endpoint to which a socket can connect or a listening socket can
  * bind.
  */
@@ skipping 79 matching lines @@
 
   /**
    * Lookup a host, returning a Future of a list of
    * [InternetAddress]s. If [type] is [InternetAddressType.ANY], it
    * will lookup both IP version 4 (IPv4) and IP version 6 (IPv6)
    * addresses. If [type] is either [InternetAddressType.IP_V4] or
    * [InternetAddressType.IP_V6] it will only lookup addresses of the
    * specified type. The order of the list can, and most likely will,
    * change over time.
    */
-  external static Future<List<InternetAddress>> lookup(
-      String host, {InternetAddressType type: InternetAddressType.ANY});
+  external static Future<List<InternetAddress>> lookup(String host,
+      {InternetAddressType type: InternetAddressType.ANY});
 
   /**
    * Clones the given [address] with the new [host].
    *
    * The [address] must be an [InternetAddress] that was created with one
    * of the static methods of this class.
    */
   external static InternetAddress _cloneWithNewHost(
       InternetAddress address, String host);
 }
 
-
 /**
  * A [NetworkInterface] represents an active network interface on the current
  * system. It contains a list of [InternetAddress]es that are bound to the
  * interface.
  */
 abstract class NetworkInterface {
   /**
    * Get the name of the [NetworkInterface].
    */
   String get name;
@@ skipping 22 matching lines @@
    * If [includeLoopback] is `true`, the returned list will include the
    * loopback device. Default is `false`.
    *
    * If [includeLinkLocal] is `true`, the list of addresses of the returned
    * [NetworkInterface]s, may include link local addresses. Default is `false`.
    *
    * If [type] is either [InternetAddressType.IP_V4] or
    * [InternetAddressType.IP_V6] it will only lookup addresses of the
    * specified type. Default is [InternetAddressType.ANY].
    */
-  external static Future<List<NetworkInterface>> list({
-      bool includeLoopback: false,
+  external static Future<List<NetworkInterface>> list(
+      {bool includeLoopback: false,
       bool includeLinkLocal: false,
       InternetAddressType type: InternetAddressType.ANY});
 }
 
-
 /**
  * A [RawServerSocket] represents a listening socket, and provides a
  * stream of low-level [RawSocket] objects, one for each connection
  * made to the listening socket.
  *
  * See [RawSocket] for more info.
  */
 abstract class RawServerSocket implements Stream<RawSocket> {
   /**
    * Returns a future for a [:RawServerSocket:]. When the future
@@ skipping 25 matching lines @@
    * value of [:0:] (the default) a reasonable value will be chosen by
    * the system.
    *
    * The optional argument [shared] specifies whether additional RawServerSocket
    * objects can bind to the same combination of `address`, `port` and `v6Only`.
    * If `shared` is `true` and more `RawServerSocket`s from this isolate or
    * other isolates are bound to the port, then the incoming connections will be
    * distributed among all the bound `RawServerSocket`s. Connections can be
    * distributed over multiple isolates this way.
    */
-  external static Future<RawServerSocket> bind(address,
-                                               int port,
-                                               {int backlog: 0,
-                                                bool v6Only: false,
-                                                bool shared: false});
+  external static Future<RawServerSocket> bind(address, int port,
+      {int backlog: 0, bool v6Only: false, bool shared: false});
 
   /**
    * Returns the port used by this socket.
    */
   int get port;
 
   /**
    * Returns the address used by this socket.
    */
   InternetAddress get address;
 
   /**
    * Closes the socket. The returned future completes when the socket
    * is fully closed and is no longer bound.
    */
   Future<RawServerSocket> close();
 }
 
-
 /**
  * A [ServerSocket] represents a listening socket, and provides a
  * stream of [Socket] objects, one for each connection made to the
  * listening socket.
  *
  * See [Socket] for more info.
  */
 abstract class ServerSocket implements Stream<Socket> {
   /**
    * Returns a future for a [:ServerSocket:]. When the future
@@ skipping 25 matching lines @@
    * value of [:0:] (the default) a reasonable value will be chosen by
    * the system.
    *
    * The optional argument [shared] specifies whether additional ServerSocket
    * objects can bind to the same combination of `address`, `port` and `v6Only`.
    * If `shared` is `true` and more `ServerSocket`s from this isolate or other
    * isolates are bound to the port, then the incoming connections will be
    * distributed among all the bound `ServerSocket`s. Connections can be
    * distributed over multiple isolates this way.
    */
-  external static Future<ServerSocket> bind(address,
-                                            int port,
-                                            {int backlog: 0,
-                                             bool v6Only: false,
-                                             bool shared: false});
+  external static Future<ServerSocket> bind(address, int port,
+      {int backlog: 0, bool v6Only: false, bool shared: false});
 
   /**
    * Returns the port used by this socket.
    */
   int get port;
 
   /**
    * Returns the address used by this socket.
    */
   InternetAddress get address;
 
   /**
    * Closes the socket. The returned future completes when the socket
    * is fully closed and is no longer bound.
    */
   Future<ServerSocket> close();
 }
 
-
 /**
  * The [SocketDirection] is used as a parameter to [Socket.close] and
  * [RawSocket.close] to close a socket in the specified direction(s).
  */
 class SocketDirection {
   static const SocketDirection RECEIVE = const SocketDirection._(0);
   static const SocketDirection SEND = const SocketDirection._(1);
   static const SocketDirection BOTH = const SocketDirection._(2);
   final _value;
 
@@ skipping 29 matching lines @@
  */
 class RawSocketEvent {
   static const RawSocketEvent READ = const RawSocketEvent._(0);
   static const RawSocketEvent WRITE = const RawSocketEvent._(1);
   static const RawSocketEvent READ_CLOSED = const RawSocketEvent._(2);
   static const RawSocketEvent CLOSED = const RawSocketEvent._(3);
   final int _value;
 
   const RawSocketEvent._(this._value);
   String toString() {
-    return const ['RawSocketEvent:READ',
-                  'RawSocketEvent:WRITE',
-                  'RawSocketEvent:READ_CLOSED',
-                  'RawSocketEvent:CLOSED'][_value];
+    return const [
+      'RawSocketEvent:READ',
+      'RawSocketEvent:WRITE',
+      'RawSocketEvent:READ_CLOSED',
+      'RawSocketEvent:CLOSED'
+    ][_value];
   }
 }
 
 /**
  * The [RawSocket] is a low-level interface to a socket, exposing the raw
  * events signaled by the system. It's a [Stream] of [RawSocketEvent]s.
  */
 abstract class RawSocket implements Stream<RawSocketEvent> {
   /**
    * Set or get, if the [RawSocket] should listen for [RawSocketEvent.READ]
@@ skipping 161 matching lines @@
   /**
    * Returns the remote [InternetAddress] connected to by this socket.
    */
   InternetAddress get remoteAddress;
 
   Future<Socket> close();
 
   Future<Socket> get done;
 }
 
-
 /**
  * Datagram package. Data send to and received from datagram sockets
  * contains the internet address and port of the destination or source
  * togeter with the data.
  */
 class Datagram {
   List<int> data;
   InternetAddress address;
   int port;
 
   Datagram(this.data, this.address, this.port);
 }
 
-
 /**
  * The [RawDatagramSocket] is a low-level interface to an UDP socket,
  * exposing the raw events signaled by the system. It's a [Stream] of
  * [RawSocketEvent]s.
  *
  * Note that the event [RawSocketEvent.READ_CLOSED] will never be
  * received as an UDP socket cannot be closed by a remote peer.
  */
 abstract class RawDatagramSocket extends Stream<RawSocketEvent> {
   /**
@@ skipping 46 matching lines @@
    *
    * For IPv6 there is no general broadcast mechanism. Use multicast
    * instead.
    */
   bool broadcastEnabled;
 
   /**
    * Creates a new raw datagram socket binding it to an address and
    * port.
    */
-  external static Future<RawDatagramSocket> bind(
-      host, int port, {bool reuseAddress: true});
+  external static Future<RawDatagramSocket> bind(host, int port,
+      {bool reuseAddress: true});
 
   /**
    * Returns the port used by this socket.
    */
   int get port;
 
   /**
    * Returns the address used by this socket.
    */
   InternetAddress get address;
@@ skipping 29 matching lines @@
 
   /**
    * Leave a multicast group.
    *
    * If an error occur when trying to join the multicase group an
    * exception is thrown.
    */
   void leaveMulticast(InternetAddress group, {NetworkInterface interface});
 }
 
-
 class SocketException implements IOException {
   final String message;
   final OSError osError;
   final InternetAddress address;
   final int port;
 
   const SocketException(this.message, {this.osError, this.address, this.port});
   const SocketException.closed()
       : message = 'Socket has been closed',
         osError = null,
@@ skipping 13 matching lines @@
     }
     if (address != null) {
       sb.write(", address = ${address.host}");
     }
     if (port != null) {
       sb.write(", port = $port");
     }
     return sb.toString();
   }
 }