Avoid parsing path and query string more than once

sdk/lib/core/uri.dart

 // Copyright (c) 2012, 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.core;
 
 /**
  * A parsed URI, as specified by RFC-3986, http://tools.ietf.org/html/rfc3986.
  */
 class Uri {
@@ skipping 64 matching lines @@
 
   /**
    * Returns the fragment identifier component.
    *
    * Returns the empty string if there is no fragment identifier
    * component.
    */
   final String fragment;
 
   /**
+   * Cache the computed return value of [pathSegements].
+   */
+  List<String> _pathSegments;
+
+  /**
+   * Cache the computed return value of [queryParameters].
+   */
+  Map<String, String> _queryParameters;
+
+  /**
    * Creates a new URI object by parsing a URI string.
    */
   static Uri parse(String uri) => new Uri._fromMatch(_splitRe.firstMatch(uri));
 
   Uri._fromMatch(Match m) :
     this(scheme: _emptyIfNull(m[_COMPONENT_SCHEME]),
          userInfo: _emptyIfNull(m[_COMPONENT_USER_INFO]),
          host: _eitherOf(
          m[_COMPONENT_HOST], m[_COMPONENT_HOST_IPV6]),
          port: _parseIntOrZero(m[_COMPONENT_PORT]),
@@ skipping 65 matching lines @@
       _port = 0;
     } else {
       _port = port;
     }
   }
 
   /*
    * Returns the URI path split into its segments. Each of the
    * segments in the returned list have been decoded. If the path is
    * empty the empty list will be returned.
+   *
+   * The returned list is immutable and will throw [StateError] on any
+   * calls that would mutate it.
    */
   List<String> get pathSegments {
-    if (path == "") return const<String>[];
-    return path.split("/").map(Uri.decodeComponent).toList(growable: false);
+    if (_pathSegments == null) {
+      _pathSegments = new _ImmutableList(
+        path == "" ? const<String>[]
+                   : path.split("/")
+                         .map(Uri.decodeComponent)
+                         .toList(growable: false));
+    }
+    return _pathSegments;
   }
 
   /*
    * Returns the URI query split into a map according to the rules
    * specified for FORM post in the HTML 4.01 specification. Each key
    * and value in the returned map have been decoded. If there is no
    * query the empty map will be returned.
+   *
+   * The returned map is immutable and will throw [StateError] on any
+   * calls that would mutate it.
    */
   Map<String, String> get queryParameters {
-    return query.split("&").fold({}, (map, element) {
+    if (_queryParameters == null) {
+      var map;
+      map = query.split("&").fold({}, (map, element) {
         int index = element.indexOf("=");
         if (index == -1) {
           if (!element.isEmpty) map[element] = "";
         } else if (index != 0) {
           var key = element.substring(0, index);
           var value = element.substring(index + 1);
           map[Uri.decodeQueryComponent(key)] = decodeQueryComponent(value);
         }
         return map;
-    });
+      });
+      _queryParameters = new _ImmutableMap(map);
+    }
+    return _queryParameters;
   }
 
   static String _makeScheme(String scheme) {
     bool isSchemeLowerCharacter(int ch) {
       return ch < 128 &&
              ((_schemeLowerTable[ch >> 4] & (1 << (ch & 0x0f))) != 0);
     }
 
     bool isSchemeCharacter(int ch) {
       return ch < 128 && ((_schemeTable[ch >> 4] & (1 << (ch & 0x0f))) != 0);
@@ skipping 733 matching lines @@
       0xafff,   // 0x30 - 0x3f  1111111111110101
                 //              @ABCDEFGHIJKLMNO
       0xffff,   // 0x40 - 0x4f  1111111111111111
                 //              PQRSTUVWXYZ    _
       0x87ff,   // 0x50 - 0x5f  1111111111100001
                 //               abcdefghijklmno
       0xfffe,   // 0x60 - 0x6f  0111111111111111
                 //              pqrstuvwxyz   ~
       0x47ff];  // 0x70 - 0x7f  1111111111100010
 }
+

[Lasse Reichstein Nielsen, 2013/06/03 07:54:27]

dart:collections has an UnmodifiableListView you can use for this
(it uses the internal UnmodifiableListMixin)

We use "unmodifiable" instead of "immutable", because the latter can carry a
connotation of deep immutablility, which we are not guaranteeing.

[Søren Gjesse, 2013/06/03 09:18:15]

Thanks - I missed that.

+class _ImmutableList<E> implements List<E> {
+  final List _list;
+  const _ImmutableList(this._list);
+
+  E operator [](int index) => _list[index];
+  void operator []=(int index, E value) {
+    throw new StateError("Immutable list");
+  }
+  int get length => _list.length;
+  void set length(int newLength) => throw new StateError("Immutable list");
+  void add(E value) => throw new StateError("Immutable list");
+  void addAll(Iterable<E> iterable) => throw new StateError("Immutable list");
+  Iterable<E> get reversed => _list.reversed;
+  void sort([int compare(E a, E b)]) => throw new StateError("Immutable list");
+  int indexOf(E element, [int start = 0]) => _list.indexOf(element, start);
+  int lastIndexOf(E element, [int start]) => _list.lastIndexOf(element, start);
+  void clear() => throw new StateError("Immutable list");
+  void insert(int index, E element) => throw new StateError("Immutable list");
+  void insertAll(int index, Iterable<E> iterable) {
+    throw new StateError("Immutable list");
+  }
+  void setAll(int index, Iterable<E> iterable) {
+    throw new StateError("Immutable list");
+  }
+  bool remove(Object value) => throw new StateError("Immutable list");
+  E removeAt(int index) => throw new StateError("Immutable list");
+  E removeLast() => throw new StateError("Immutable list");
+  void removeWhere(bool test(E element)) {
+    throw new StateError("Immutable list");
+  }
+  void retainWhere(bool test(E element)) {
+    throw new StateError("Immutable list");
+  }
+  List<E> sublist(int start, [int end]) => _list.sublist(start, end);
+  Iterable<E> getRange(int start, int end) => _list.getRange(start, end);
+  void setRange(int start, int end, Iterable<E> iterable, [int skipCount = 0]) {
+    throw new StateError("Immutable list");
+  }
+  void removeRange(int start, int end) => throw new StateError("Immutable list");
+  void fillRange(int start, int end, [E fillValue]) {
+    throw new StateError("Immutable list");
+  }
+  void replaceRange(int start, int end, Iterable<E> iterable) {
+    throw new StateError("Immutable list");
+  }
+  Map<int, E> asMap() => _list.asMap();
+}
+
+class _ImmutableMap<K, V> implements Map<K, V> {

[Lasse Reichstein Nielsen, 2013/06/03 07:54:27]

No UnmodifiableMapView, sorry :(
We probably should have one, but we also need Map mixins and base classes.

[Søren Gjesse, 2013/06/03 09:18:15]

OK, keeping this (renaming to _UnmodifiableMap).

+  final Map _map;
+  const _ImmutableMap(this._map);
+
+  bool containsValue(V value) => _map.containsValue(value);
+  bool containsKey(K key) => _map.containsKey(key);
+  V operator [](K key) => _map[key];
+  void operator []=(K key, V value) => throw new StateError("Immutable map");

[Lasse Reichstein Nielsen, 2013/06/03 07:54:27]

UnsupportedError

[Søren Gjesse, 2013/06/03 09:18:15]

Done.

+  V putIfAbsent(K key, V ifAbsent()) => throw new StateError("Immutable map");
+  V remove(K key) => throw new StateError("Immutable map");
+  void clear() => throw new StateError("Immutable 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;
+}