Code cleanup (mostly io lib and some http lib).

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._(int this._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".
    */
@@ skipping 267 matching lines @@
 }
 
 /**
  * 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;
+
   const SocketDirection._(this._value);
-  final _value;
 }
 
 /**
  * The [SocketOption] is used as a parameter to [Socket.setOption] and
  * [RawSocket.setOption] to set customize the behaviour of the underlying
  * socket.
  */
 class SocketOption {
   /**
    * Enable or disable no-delay on the socket. If TCP_NODELAY is enabled, the
    * socket will not buffer data internally, but instead write each data chunk
    * as an invidual TCP packet.
    *
    * TCP_NODELAY is disabled by default.
    */
   static const SocketOption TCP_NODELAY = const SocketOption._(0);
 
   static const SocketOption _IP_MULTICAST_LOOP = const SocketOption._(1);
   static const SocketOption _IP_MULTICAST_HOPS = const SocketOption._(2);
   static const SocketOption _IP_MULTICAST_IF = const SocketOption._(3);
   static const SocketOption _IP_BROADCAST = const SocketOption._(4);
+  final _value;
 
   const SocketOption._(this._value);
-  final _value;
 }
 
 /**
  * Events for the [RawSocket].
  */
 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);
-  final int _value;
   String toString() {
     return ['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]
+   * events. Default is [true].
+   */
+  bool readEventsEnabled;
+
+  /**
+   * Set or get, if the [RawSocket] should listen for [RawSocketEvent.WRITE]
+   * events. Default is [true].
+   * This is a one-shot listener, and writeEventsEnabled must be set
+   * to true again to receive another write event.
+   */
+  bool writeEventsEnabled;
+
+  /**
    * Creates a new socket connection to the host and port and returns a [Future]
    * that will complete with either a [RawSocket] once connected or an error
    * if the host-lookup or connection failed.
    *
    * [host] can either be a [String] or an [InternetAddress]. If [host] is a
    * [String], [connect] will perform a [InternetAddress.lookup] and use
    * the first value in the list.
    */
   external static Future<RawSocket> connect(host, int port);
 
@@ skipping 55 matching lines @@
 
   /**
    * Shutdown the socket in the [direction]. Calling [shutdown] will never
    * throw an exception and calling it several times is supported. Calling
    * shutdown with either [SocketDirection.BOTH] or [SocketDirection.RECEIVE]
    * can result in a [RawSocketEvent.READ_CLOSED] event.
    */
   void shutdown(SocketDirection direction);
 
   /**
-   * Set or get, if the [RawSocket] should listen for [RawSocketEvent.READ]
-   * events. Default is [true].
-   */
-  bool readEventsEnabled;
-
-  /**
-   * Set or get, if the [RawSocket] should listen for [RawSocketEvent.WRITE]
-   * events. Default is [true].
-   * This is a one-shot listener, and writeEventsEnabled must be set
-   * to true again to receive another write event.
-   */
-  bool writeEventsEnabled;
-
-  /**
    * Use [setOption] to customize the [RawSocket]. See [SocketOption] for
    * available options.
    *
    * Returns [true] if the option was set successfully, false otherwise.
    */
   bool setOption(SocketOption option, bool enabled);
 }
 
 /**
  * A high-level class for communicating over a TCP socket.
@@ skipping 70 matching lines @@
 /**
  * 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> {
   /**
-   * Creates a new raw datagram socket binding it to an address and
-   * port.
-   */
-  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;
-
-  /**
-   * Close the datagram socket.
-   */
-  void close();
-
-  /**
-   * Send a datagram.
-   *
-   * Returns the number of bytes written. This will always be either
-   * the size of [buffer] or `0`.
-   */
-  int send(List<int> buffer, InternetAddress address, int port);
-
-  /**
-   * Receive a datagram. If there are no datagrams available `null` is
-   * returned.
-   */
-  Datagram receive();
-
-  /**
-   * Join a multicast group.
-   *
-   * If an error occur when trying to join the multicast group an
-   * exception is thrown.
-   */
-  void joinMulticast(InternetAddress group, {NetworkInterface interface});
-
-  /**
-   * 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});
-
-  /**
    * Set or get, if the [RawDatagramSocket] should listen for
    * [RawSocketEvent.READ] events. Default is [true].
    */
   bool readEventsEnabled;
 
   /**
    * Set or get, if the [RawDatagramSocket] should listen for
    * [RawSocketEvent.WRITE] events. Default is [true].  This is a
    * one-shot listener, and writeEventsEnabled must be set to true
    * again to receive another write event.
@@ skipping 31 matching lines @@
   /**
    * Set or get, whether IPv4 broadcast is enabled.
    *
    * IPv4 broadcast needs to be enabled by the sender for sending IPv4
    * broadcast packages. By default IPv4 broadcast is disabled.
    *
    * 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});
+
+  /**
+   * Returns the port used by this socket.
+   */
+  int get port;
+
+  /**
+   * Returns the address used by this socket.
+   */
+  InternetAddress get address;
+
+  /**
+   * Close the datagram socket.
+   */
+  void close();
+
+  /**
+   * Send a datagram.
+   *
+   * Returns the number of bytes written. This will always be either
+   * the size of [buffer] or `0`.
+   */
+  int send(List<int> buffer, InternetAddress address, int port);
+
+  /**
+   * Receive a datagram. If there are no datagrams available `null` is
+   * returned.
+   */
+  Datagram receive();
+
+  /**
+   * Join a multicast group.
+   *
+   * If an error occur when trying to join the multicast group an
+   * exception is thrown.
+   */
+  void joinMulticast(InternetAddress group, {NetworkInterface interface});
+
+  /**
+   * 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(String this.message,
-                        {OSError this.osError,
-                         InternetAddress this.address,
-                         int this.port});
+  const SocketException(this.message, {this.osError, this.address, this.port});
 
   String toString() {
     StringBuffer sb = new StringBuffer();
     sb.write("SocketException");
     if (!message.isEmpty) {
       sb.write(": $message");
       if (osError != null) {
         sb.write(" ($osError)");
       }
     } else if (osError != null) {
       sb.write(": $osError");
     }
     if (address != null) {
       sb.write(", address = ${address.host}");
     }
     if (port != null) {
       sb.write(", port = $port");
     }
     return sb.toString();
   }
 }