Export UnmodifiableMapView from the Dart core libraries.

lib/src/unmodifiable_wrappers.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.
 
 /**
  * Wrappers that prevent a List, Set, or Map object from being modified.
  *
  * The [Set] and [Map] wrappers allow reading from the wrapped collection,
  * but prohibit writing.
  *
  * The [List] wrapper prevents changes to the length of the wrapped list,
  * but allows changes to the contents.
  */
-part of dart.pkg.collection.wrappers;
+library dart.pkg.collection.unmodifiable_wrappers;

[Lasse Reichstein Nielsen, 2015/08/25 07:43:48]

Feel free to change the name to collection.unmodifiable_wrappers.

[nweiz, 2015/08/25 19:45:54]

Done.

+
+import "dart:collection";
+
+import '../wrappers.dart';
+
+export "dart:collection" show UnmodifiableListView, UnmodifiableMapView;
 
 /**
  * A fixed-length list.
  *
  * A `NonGrowableListView` contains a [List] object and ensures that
  * its length does not change.
  * Methods that would change the length of the list,
  * such as [add] and [remove], throw an [UnsupportedError].
  * All other methods work directly on the underlying list.
  *
@@ skipping 161 matching lines @@
   void retainWhere(bool test(E element)) => _throw();
 
   /**
    * Throws an [UnsupportedError];
    * operations that change the set are disallowed.
    */
   void clear() => _throw();
 }
 
 /**
- * An unmodifiable map.
- *
- * An UnmodifiableMapView contains a [Map] object and ensures
- * that it does not change.
- * Methods that would change the map,
- * such as [addAll] and [remove], throw an [UnsupportedError].
- * Permitted operations defer to the wrapped map.
- */
-class UnmodifiableMapView<K, V> extends DelegatingMap<K, V>
-                                with UnmodifiableMapMixin<K, V> {
-  UnmodifiableMapView(Map<K, V> baseMap) : super(baseMap);
-}
-
-/**
  * Mixin class that implements a throwing version of all map operations that
  * change the Map.
  */
 abstract class UnmodifiableMapMixin<K, V> implements Map<K, V> {
   static _throw() {
     throw new UnsupportedError("Cannot modify an unmodifiable Map");
   }
 
   /**
    * Throws an [UnsupportedError];
@@ skipping 18 matching lines @@
    * operations that change the map are disallowed.
    */
   V remove(K key) => _throw();
 
   /**
    * Throws an [UnsupportedError];
    * operations that change the map are disallowed.
    */
   void clear() => _throw();
 }