| OLD | NEW |
| (Empty) |
| 1 // Copyright (c) 2013, the Dart project authors. Please see the AUTHORS file | |
| 2 // for details. All rights reserved. Use of this source code is governed by a | |
| 3 // BSD-style license that can be found in the LICENSE file. | |
| 4 | |
| 5 part of dart._collection.dev; | |
| 6 | |
| 7 /** | |
| 8 * Mixin that throws on the length changing operations of [List]. | |
| 9 * | |
| 10 * Intended to mix-in on top of [ListMixin] for fixed-length lists. | |
| 11 */ | |
| 12 abstract class FixedLengthListMixin<E> { | |
| 13 /** This operation is not supported by a fixed length list. */ | |
| 14 void set length(int newLength) { | |
| 15 throw new UnsupportedError( | |
| 16 "Cannot change the length of a fixed-length list"); | |
| 17 } | |
| 18 | |
| 19 /** This operation is not supported by a fixed length list. */ | |
| 20 void add(E value) { | |
| 21 throw new UnsupportedError( | |
| 22 "Cannot add to a fixed-length list"); | |
| 23 } | |
| 24 | |
| 25 /** This operation is not supported by a fixed length list. */ | |
| 26 void insert(int index, E value) { | |
| 27 throw new UnsupportedError( | |
| 28 "Cannot add to a fixed-length list"); | |
| 29 } | |
| 30 | |
| 31 /** This operation is not supported by a fixed length list. */ | |
| 32 void insertAll(int at, Iterable<E> iterable) { | |
| 33 throw new UnsupportedError( | |
| 34 "Cannot add to a fixed-length list"); | |
| 35 } | |
| 36 | |
| 37 /** This operation is not supported by a fixed length list. */ | |
| 38 void addAll(Iterable<E> iterable) { | |
| 39 throw new UnsupportedError( | |
| 40 "Cannot add to a fixed-length list"); | |
| 41 } | |
| 42 | |
| 43 /** This operation is not supported by a fixed length list. */ | |
| 44 bool remove(Object element) { | |
| 45 throw new UnsupportedError( | |
| 46 "Cannot remove from a fixed-length list"); | |
| 47 } | |
| 48 | |
| 49 /** This operation is not supported by a fixed length list. */ | |
| 50 void removeWhere(bool test(E element)) { | |
| 51 throw new UnsupportedError( | |
| 52 "Cannot remove from a fixed-length list"); | |
| 53 } | |
| 54 | |
| 55 /** This operation is not supported by a fixed length list. */ | |
| 56 void retainWhere(bool test(E element)) { | |
| 57 throw new UnsupportedError( | |
| 58 "Cannot remove from a fixed-length list"); | |
| 59 } | |
| 60 | |
| 61 /** This operation is not supported by a fixed length list. */ | |
| 62 void clear() { | |
| 63 throw new UnsupportedError( | |
| 64 "Cannot clear a fixed-length list"); | |
| 65 } | |
| 66 | |
| 67 /** This operation is not supported by a fixed length list. */ | |
| 68 E removeAt(int index) { | |
| 69 throw new UnsupportedError( | |
| 70 "Cannot remove from a fixed-length list"); | |
| 71 } | |
| 72 | |
| 73 /** This operation is not supported by a fixed length list. */ | |
| 74 E removeLast() { | |
| 75 throw new UnsupportedError( | |
| 76 "Cannot remove from a fixed-length list"); | |
| 77 } | |
| 78 | |
| 79 /** This operation is not supported by a fixed length list. */ | |
| 80 void removeRange(int start, int end) { | |
| 81 throw new UnsupportedError( | |
| 82 "Cannot remove from a fixed-length list"); | |
| 83 } | |
| 84 | |
| 85 /** This operation is not supported by a fixed length list. */ | |
| 86 void replaceRange(int start, int end, Iterable<E> iterable) { | |
| 87 throw new UnsupportedError( | |
| 88 "Cannot remove from a fixed-length list"); | |
| 89 } | |
| 90 } | |
| 91 | |
| 92 /** | |
| 93 * Mixin for an unmodifiable [List] class. | |
| 94 * | |
| 95 * This overrides all mutating methods with methods that throw. | |
| 96 * This mixin is intended to be mixed in on top of [ListMixin] on | |
| 97 * unmodifiable lists. | |
| 98 */ | |
| 99 abstract class UnmodifiableListMixin<E> implements List<E> { | |
| 100 | |
| 101 /** This operation is not supported by an unmodifiable list. */ | |
| 102 void operator []=(int index, E value) { | |
| 103 throw new UnsupportedError( | |
| 104 "Cannot modify an unmodifiable list"); | |
| 105 } | |
| 106 | |
| 107 /** This operation is not supported by an unmodifiable list. */ | |
| 108 void set length(int newLength) { | |
| 109 throw new UnsupportedError( | |
| 110 "Cannot change the length of an unmodifiable list"); | |
| 111 } | |
| 112 | |
| 113 /** This operation is not supported by an unmodifiable list. */ | |
| 114 void setAll(int at, Iterable<E> iterable) { | |
| 115 throw new UnsupportedError( | |
| 116 "Cannot modify an unmodifiable list"); | |
| 117 } | |
| 118 | |
| 119 /** This operation is not supported by an unmodifiable list. */ | |
| 120 void add(E value) { | |
| 121 throw new UnsupportedError( | |
| 122 "Cannot add to an unmodifiable list"); | |
| 123 } | |
| 124 | |
| 125 /** This operation is not supported by an unmodifiable list. */ | |
| 126 E insert(int index, E value) { | |
| 127 throw new UnsupportedError( | |
| 128 "Cannot add to an unmodifiable list"); | |
| 129 } | |
| 130 | |
| 131 /** This operation is not supported by an unmodifiable list. */ | |
| 132 void insertAll(int at, Iterable<E> iterable) { | |
| 133 throw new UnsupportedError( | |
| 134 "Cannot add to an unmodifiable list"); | |
| 135 } | |
| 136 | |
| 137 /** This operation is not supported by an unmodifiable list. */ | |
| 138 void addAll(Iterable<E> iterable) { | |
| 139 throw new UnsupportedError( | |
| 140 "Cannot add to an unmodifiable list"); | |
| 141 } | |
| 142 | |
| 143 /** This operation is not supported by an unmodifiable list. */ | |
| 144 bool remove(Object element) { | |
| 145 throw new UnsupportedError( | |
| 146 "Cannot remove from an unmodifiable list"); | |
| 147 } | |
| 148 | |
| 149 /** This operation is not supported by an unmodifiable list. */ | |
| 150 void removeWhere(bool test(E element)) { | |
| 151 throw new UnsupportedError( | |
| 152 "Cannot remove from an unmodifiable list"); | |
| 153 } | |
| 154 | |
| 155 /** This operation is not supported by an unmodifiable list. */ | |
| 156 void retainWhere(bool test(E element)) { | |
| 157 throw new UnsupportedError( | |
| 158 "Cannot remove from an unmodifiable list"); | |
| 159 } | |
| 160 | |
| 161 /** This operation is not supported by an unmodifiable list. */ | |
| 162 void sort([Comparator<E> compare]) { | |
| 163 throw new UnsupportedError( | |
| 164 "Cannot modify an unmodifiable list"); | |
| 165 } | |
| 166 | |
| 167 /** This operation is not supported by an unmodifiable list. */ | |
| 168 void shuffle([Random random]) { | |
| 169 throw new UnsupportedError( | |
| 170 "Cannot modify an unmodifiable list"); | |
| 171 } | |
| 172 | |
| 173 /** This operation is not supported by an unmodifiable list. */ | |
| 174 void clear() { | |
| 175 throw new UnsupportedError( | |
| 176 "Cannot clear an unmodifiable list"); | |
| 177 } | |
| 178 | |
| 179 /** This operation is not supported by an unmodifiable list. */ | |
| 180 E removeAt(int index) { | |
| 181 throw new UnsupportedError( | |
| 182 "Cannot remove from an unmodifiable list"); | |
| 183 } | |
| 184 | |
| 185 /** This operation is not supported by an unmodifiable list. */ | |
| 186 E removeLast() { | |
| 187 throw new UnsupportedError( | |
| 188 "Cannot remove from an unmodifiable list"); | |
| 189 } | |
| 190 | |
| 191 /** This operation is not supported by an unmodifiable list. */ | |
| 192 void setRange(int start, int end, Iterable<E> iterable, [int skipCount = 0]) { | |
| 193 throw new UnsupportedError( | |
| 194 "Cannot modify an unmodifiable list"); | |
| 195 } | |
| 196 | |
| 197 /** This operation is not supported by an unmodifiable list. */ | |
| 198 void removeRange(int start, int end) { | |
| 199 throw new UnsupportedError( | |
| 200 "Cannot remove from an unmodifiable list"); | |
| 201 } | |
| 202 | |
| 203 /** This operation is not supported by an unmodifiable list. */ | |
| 204 void replaceRange(int start, int end, Iterable<E> iterable) { | |
| 205 throw new UnsupportedError( | |
| 206 "Cannot remove from an unmodifiable list"); | |
| 207 } | |
| 208 | |
| 209 /** This operation is not supported by an unmodifiable list. */ | |
| 210 void fillRange(int start, int end, [E fillValue]) { | |
| 211 throw new UnsupportedError( | |
| 212 "Cannot modify an unmodifiable list"); | |
| 213 } | |
| 214 } | |
| 215 | |
| 216 /** | |
| 217 * Abstract implementation of a fixed-length list. | |
| 218 * | |
| 219 * All operations are defined in terms of `length`, `operator[]` and | |
| 220 * `operator[]=`, which need to be implemented. | |
| 221 */ | |
| 222 abstract class FixedLengthListBase<E> = | |
| 223 ListBase<E> with FixedLengthListMixin<E>; | |
| 224 | |
| 225 /** | |
| 226 * Abstract implementation of an unmodifiable list. | |
| 227 * | |
| 228 * All operations are defined in terms of `length` and `operator[]`, | |
| 229 * which need to be implemented. | |
| 230 */ | |
| 231 abstract class UnmodifiableListBase<E> = | |
| 232 ListBase<E> with UnmodifiableListMixin<E>; | |
| 233 | |
| 234 class _ListIndicesIterable extends ListIterable<int> { | |
| 235 List _backedList; | |
| 236 | |
| 237 _ListIndicesIterable(this._backedList); | |
| 238 | |
| 239 int get length => _backedList.length; | |
| 240 int elementAt(int index) { | |
| 241 if (index < 0 || index >= length) { | |
| 242 throw new RangeError.range(index, 0, length); | |
| 243 } | |
| 244 return index; | |
| 245 } | |
| 246 } | |
| 247 | |
| 248 class ListMapView<E> implements Map<int, E> { | |
| 249 List<E> _values; | |
| 250 | |
| 251 ListMapView(this._values); | |
| 252 | |
| 253 E operator[] (int key) => containsKey(key) ? _values[key] : null; | |
| 254 int get length => _values.length; | |
| 255 | |
| 256 Iterable<E> get values => new SubListIterable<E>(_values, 0, null); | |
| 257 Iterable<int> get keys => new _ListIndicesIterable(_values); | |
| 258 | |
| 259 bool get isEmpty => _values.isEmpty; | |
| 260 bool get isNotEmpty => _values.isNotEmpty; | |
| 261 bool containsValue(Object value) => _values.contains(value); | |
| 262 bool containsKey(int key) => key is int && key >= 0 && key < length; | |
| 263 | |
| 264 void forEach(void f(int key, E value)) { | |
| 265 int length = _values.length; | |
| 266 for (int i = 0; i < length; i++) { | |
| 267 f(i, _values[i]); | |
| 268 if (length != _values.length) { | |
| 269 throw new ConcurrentModificationError(_values); | |
| 270 } | |
| 271 } | |
| 272 } | |
| 273 | |
| 274 /** This operation is not supported by an unmodifiable map. */ | |
| 275 void operator[]= (int key, E value) { | |
| 276 throw new UnsupportedError("Cannot modify an unmodifiable map"); | |
| 277 } | |
| 278 | |
| 279 /** This operation is not supported by an unmodifiable map. */ | |
| 280 E putIfAbsent(int key, E ifAbsent()) { | |
| 281 throw new UnsupportedError("Cannot modify an unmodifiable map"); | |
| 282 } | |
| 283 | |
| 284 /** This operation is not supported by an unmodifiable map. */ | |
| 285 E remove(int key) { | |
| 286 throw new UnsupportedError("Cannot modify an unmodifiable map"); | |
| 287 } | |
| 288 | |
| 289 /** This operation is not supported by an unmodifiable map. */ | |
| 290 void clear() { | |
| 291 throw new UnsupportedError("Cannot modify an unmodifiable map"); | |
| 292 } | |
| 293 | |
| 294 /** This operation is not supported by an unmodifiable map. */ | |
| 295 void addAll(Map<int, E> other) { | |
| 296 throw new UnsupportedError("Cannot modify an unmodifiable map"); | |
| 297 } | |
| 298 } | |
| 299 | |
| 300 class ReversedListIterable<E> extends ListIterable<E> { | |
| 301 Iterable<E> _source; | |
| 302 ReversedListIterable(this._source); | |
| 303 | |
| 304 int get length => _source.length; | |
| 305 | |
| 306 E elementAt(int index) => _source.elementAt(_source.length - 1 - index); | |
| 307 } | |
| OLD | NEW |