Int switch

sdk/lib/io/http_headers.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;
 
 class _HttpHeaders implements HttpHeaders {
   final Map<String, List<String>> _headers;
   final String protocolVersion;
 
@@ skipping 230 matching lines @@
     } else {
       return null;
     }
   }
 
   void set contentType(ContentType contentType) {
     _checkMutable();
     _set(HttpHeaders.CONTENT_TYPE, contentType.toString());
   }
 
-  static void _addContentLength(_HttpHeaders headers, String name, value) {
+  // [name] must be a lower-case version of the name.
+  void _add(String name, value) {
+    assert(name == name.toLowerCase());
+    // Use the length as index on what method to call. This is notable
+    // faster than computing hash and looking up in a hash-map.
+    switch (name.length) {
+      case 4:
+        if (HttpHeaders.DATE == name) {
+          _addDate(name, value);
+          return;
+        }
+        if (HttpHeaders.HOST == name) {
+          _addHost(name, value);
+          return;
+        }
+        break;
+      case 7:
+        if (HttpHeaders.EXPIRES == name) {
+          _addExpires(name, value);
+          return;
+        }
+        break;
+      case 10:
+        if (HttpHeaders.CONNECTION == name) {
+          _addConnection(name, value);
+          return;
+        }
+        break;
+      case 12:
+        if (HttpHeaders.CONTENT_TYPE == name) {
+          _addContentType(name, value);
+          return;
+        }
+        break;
+      case 14:
+        if (HttpHeaders.CONTENT_LENGTH == name) {
+          _addContentLength(name, value);
+          return;
+        }
+        break;
+      case 17:
+        if (HttpHeaders.TRANSFER_ENCODING == name) {
+          _addTransferEncoding(name, value);
+          return;
+        }
+        if (HttpHeaders.IF_MODIFIED_SINCE == name) {
+          _addIfModifiedSince(name, value);
+          return;
+        }
+    }
+    _addValue(name, value);
+  }
+
+  void _addContentLength(String name, value) {

[Lasse Reichstein Nielsen, 2014/04/23 12:31:06]

Do you need to pass the name?
It should always be HttpHeaders.CONTENT_LENGTH here (and it isn't even used in
this function).

[Anders Johnsen, 2014/04/23 12:33:00]

Yes, but as we use it a lot (see exception), it's cleaner to pass it.

     if (value is int) {
-      headers.contentLength = value;
+      contentLength = value;
     } else if (value is String) {
-      headers.contentLength = int.parse(value);
+      contentLength = int.parse(value);
     } else {
       throw new HttpException("Unexpected type for header named $name");
     }
   }
 
-  static void _addTransferEncoding(_HttpHeaders headers, String name, value) {
+  void _addTransferEncoding(String name, value) {

[Lasse Reichstein Nielsen, 2014/04/23 12:31:06]

Consider sorting functions by name?

     if (value == "chunked") {
-      headers.chunkedTransferEncoding = true;
+      chunkedTransferEncoding = true;
     } else {
-      headers._addValue(HttpHeaders.TRANSFER_ENCODING, value);
+      _addValue(HttpHeaders.TRANSFER_ENCODING, value);
     }
   }
 
-  static void _addDate(_HttpHeaders headers, String name, value) {
+  void _addDate(String name, value) {
     if (value is DateTime) {
-      headers.date = value;
+      date = value;
     } else if (value is String) {
-      headers._set(HttpHeaders.DATE, value);
+      _set(HttpHeaders.DATE, value);
     } else {
       throw new HttpException("Unexpected type for header named $name");
     }
   }
 
-  static void _addExpires(_HttpHeaders headers, String name, value) {
+  void _addExpires(String name, value) {
     if (value is DateTime) {
-      headers.expires = value;
+      expires = value;
     } else if (value is String) {
-      headers._set(HttpHeaders.EXPIRES, value);
+      _set(HttpHeaders.EXPIRES, value);
     } else {
       throw new HttpException("Unexpected type for header named $name");
     }
   }
 
-  static void _addIfModifiedSince(_HttpHeaders headers, String name, value) {
+  void _addIfModifiedSince(String name, value) {
     if (value is DateTime) {
-      headers.ifModifiedSince = value;
+      ifModifiedSince = value;
     } else if (value is String) {
-      headers._set(HttpHeaders.IF_MODIFIED_SINCE, value);
+      _set(HttpHeaders.IF_MODIFIED_SINCE, value);
     } else {
       throw new HttpException("Unexpected type for header named $name");
     }
   }
 
-  static void _addHost(_HttpHeaders headers, String name, value) {
+  void _addHost(String name, value) {
     if (value is String) {
       int pos = value.indexOf(":");
       if (pos == -1) {
-        headers._host = value;
-        headers._port = HttpClient.DEFAULT_HTTP_PORT;
+        _host = value;
+        _port = HttpClient.DEFAULT_HTTP_PORT;
       } else {
         if (pos > 0) {
-          headers._host = value.substring(0, pos);
+          _host = value.substring(0, pos);
         } else {
-          headers._host = null;
+          _host = null;
         }
         if (pos + 1 == value.length) {
-          headers._port = HttpClient.DEFAULT_HTTP_PORT;
+          _port = HttpClient.DEFAULT_HTTP_PORT;
         } else {
           try {
-            headers._port = int.parse(value.substring(pos + 1));
+            _port = int.parse(value.substring(pos + 1));
           } on FormatException catch (e) {
-            headers._port = null;
+            _port = null;
           }
         }
       }
-      headers._set(HttpHeaders.HOST, value);
+      _set(HttpHeaders.HOST, value);
     } else {
       throw new HttpException("Unexpected type for header named $name");
     }
   }
 
-  static void _addConnection(_HttpHeaders headers, String name, value) {
+  void _addConnection(String name, value) {
     var lowerCaseValue = value.toLowerCase();
     if (lowerCaseValue == 'close') {
-      headers._persistentConnection = false;
+      _persistentConnection = false;
     } else if (lowerCaseValue == 'keep-alive') {
-      headers._persistentConnection = true;
-    }
-    headers._addValue(name, value);
-  }
-
-  static void _addContentType(_HttpHeaders headers, String name, value) {
-    headers._set(HttpHeaders.CONTENT_TYPE, value);
-  }
-
-  // TODO(ajohnsen): Change to const map, once const maps are faster.
-  static final _addMap = {
-    HttpHeaders.CONTENT_LENGTH: _addContentLength,
-    HttpHeaders.TRANSFER_ENCODING: _addTransferEncoding,
-    HttpHeaders.DATE: _addDate,
-    HttpHeaders.EXPIRES: _addExpires,
-    HttpHeaders.IF_MODIFIED_SINCE: _addIfModifiedSince,
-    HttpHeaders.HOST: _addHost,
-    HttpHeaders.CONNECTION: _addConnection,
-    HttpHeaders.CONTENT_TYPE: _addContentType
-  };
-
-  // [name] must be a lower-case version of the name.
-  void _add(String name, value) {
-    assert(name == name.toLowerCase());
-    var method = _addMap[name];
-    if (method != null) {
-      method(this, name, value);
-      return;
+      _persistentConnection = true;
     }
     _addValue(name, value);
   }
 
+  void _addContentType(String name, value) {
+    _set(HttpHeaders.CONTENT_TYPE, value);
+  }
+
   void _addValue(String name, Object value) {
     List<String> values = _headers[name];
     if (values == null) {
       values = new List<String>();
       _headers[name] = values;
     }
     if (value is DateTime) {
       values.add(HttpDate.format(value));
     } else {
       values.add(value.toString());
@@ skipping 532 matching lines @@
   void clear() {
     throw new UnsupportedError("Cannot modify an unmodifiable map");
   }
   void forEach(void f(K key, V value)) => _map.forEach(f);
   Iterable<K> get keys => _map.keys;
   Iterable<V> get values => _map.values;
   int get length => _map.length;
   bool get isEmpty => _map.isEmpty;
   bool get isNotEmpty => _map.isNotEmpty;
 }