| Index: sdk/lib/_internal/compiler/implementation/util/maplet.dart
|
| diff --git a/sdk/lib/_internal/compiler/implementation/util/maplet.dart b/sdk/lib/_internal/compiler/implementation/util/maplet.dart
|
| deleted file mode 100644
|
| index 455435bd91000def9828eccfc3c7a51591b3fd60..0000000000000000000000000000000000000000
|
| --- a/sdk/lib/_internal/compiler/implementation/util/maplet.dart
|
| +++ /dev/null
|
| @@ -1,280 +0,0 @@
|
| -// Copyright (c) 2014, 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.
|
| -
|
| -library dart2js.util.maplet;
|
| -
|
| -import 'dart:collection' show MapBase, IterableBase;
|
| -
|
| -class Maplet<K, V> extends MapBase<K, V> {
|
| - static const _MARKER = const _MapletMarker();
|
| - static const CAPACITY = 8;
|
| -
|
| -// The maplet can be in one of four states:
|
| - //
|
| - // * Empty (extra: null, key: marker, value: null)
|
| - // * Single element (extra: null, key: key, value: value)
|
| - // * List-backed (extra: length, key: list, value: null)
|
| - // * Map-backed (extra: marker, key: map, value: null)
|
| - //
|
| - // When the maplet is list-backed, the list has two sections: One
|
| - // for keys and one for values. The first [CAPACITY] entries are
|
| - // the keys and they may contain markers for deleted elements. After
|
| - // the keys there are [CAPACITY] entries for the values.
|
| -
|
| - var _key = _MARKER;
|
| - var _value;
|
| - var _extra;
|
| -
|
| - Maplet();
|
| -
|
| - Maplet.from(Maplet<K, V> other) {
|
| - other.forEach((K key, V value) {
|
| - this[key] = value;
|
| - });
|
| - }
|
| -
|
| - bool get isEmpty {
|
| - if (_extra == null) {
|
| - return _MARKER == _key;
|
| - } else if (_MARKER == _extra) {
|
| - return _key.isEmpty;
|
| - } else {
|
| - return _extra == 0;
|
| - }
|
| - }
|
| -
|
| - int get length {
|
| - if (_extra == null) {
|
| - return (_MARKER == _key) ? 0 : 1;
|
| - } else if (_MARKER == _extra) {
|
| - return _key.length;
|
| - } else {
|
| - return _extra;
|
| - }
|
| - }
|
| -
|
| - bool containsKey(K key) {
|
| - if (_extra == null) {
|
| - return _key == key;
|
| - } else if (_MARKER == _extra) {
|
| - return _key.containsKey(key);
|
| - } else {
|
| - for (int remaining = _extra, i = 0; remaining > 0 && i < CAPACITY; i++) {
|
| - var candidate = _key[i];
|
| - if (_MARKER == candidate) continue;
|
| - if (candidate == key) return true;
|
| - remaining--;
|
| - }
|
| - return false;
|
| - }
|
| - }
|
| -
|
| - V operator [](K key) {
|
| - if (_extra == null) {
|
| - return (_key == key) ? _value : null;
|
| - } else if (_MARKER == _extra) {
|
| - return _key[key];
|
| - } else {
|
| - for (int remaining = _extra, i = 0; remaining > 0 && i < CAPACITY; i++) {
|
| - var candidate = _key[i];
|
| - if (_MARKER == candidate) continue;
|
| - if (candidate == key) return _key[i + CAPACITY];
|
| - remaining--;
|
| - }
|
| - return null;
|
| - }
|
| - }
|
| -
|
| - void operator []=(K key, V value) {
|
| - if (_extra == null) {
|
| - if (_MARKER == _key) {
|
| - _key = key;
|
| - _value = value;
|
| - } else if (_key == key) {
|
| - _value = value;
|
| - } else {
|
| - List list = new List(CAPACITY * 2);
|
| - list[0] = _key;
|
| - list[1] = key;
|
| - list[CAPACITY] = _value;
|
| - list[CAPACITY + 1] = value;
|
| - _key = list;
|
| - _value = null;
|
| - _extra = 2; // Two elements.
|
| - }
|
| - } else if (_MARKER == _extra) {
|
| - _key[key] = value;
|
| - } else {
|
| - int remaining = _extra;
|
| - int index = 0;
|
| - int copyTo, copyFrom;
|
| - while (remaining > 0 && index < CAPACITY) {
|
| - var candidate = _key[index];
|
| - if (_MARKER == candidate) {
|
| - // Keep track of the last range of empty slots in the
|
| - // list. When we're done we'll move all the elements
|
| - // after those empty slots down, so that adding an element
|
| - // after that will preserve the insertion order.
|
| - if (copyFrom == index) {
|
| - copyFrom++;
|
| - } else {
|
| - copyTo = index;
|
| - copyFrom = index + 1;
|
| - }
|
| - } else if (candidate == key) {
|
| - _key[CAPACITY + index] = value;
|
| - return;
|
| - } else {
|
| - // Skipped an element that didn't match.
|
| - remaining--;
|
| - }
|
| - index++;
|
| - }
|
| - if (index < CAPACITY) {
|
| - _key[index] = key;
|
| - _key[CAPACITY + index] = value;
|
| - _extra++;
|
| - } else if (_extra < CAPACITY) {
|
| - // Move the last elements down into the last empty slots
|
| - // so that we have empty slots after the last element.
|
| - while (copyFrom < CAPACITY) {
|
| - _key[copyTo] = _key[copyFrom];
|
| - _key[CAPACITY + copyTo] = _key[CAPACITY + copyFrom];
|
| - copyTo++;
|
| - copyFrom++;
|
| - }
|
| - // Insert the new element as the last element.
|
| - _key[copyTo] = key;
|
| - _key[CAPACITY + copyTo] = value;
|
| - copyTo++;
|
| - // Add one to the length encoded in the extra field.
|
| - _extra++;
|
| - // Clear all elements after the new last elements to
|
| - // make sure we don't keep extra stuff alive.
|
| - while (copyTo < CAPACITY) {
|
| - _key[copyTo] = _key[CAPACITY + copyTo] = null;
|
| - copyTo++;
|
| - }
|
| - } else {
|
| - Map map = new Map();
|
| - forEach((eachKey, eachValue) => map[eachKey] = eachValue);
|
| - map[key] = value;
|
| - _key = map;
|
| - _extra = _MARKER;
|
| - }
|
| - }
|
| - }
|
| -
|
| - V remove(K key) {
|
| - if (_extra == null) {
|
| - if (_key != key) return null;
|
| - _key = _MARKER;
|
| - V result = _value;
|
| - _value = null;
|
| - return result;
|
| - } else if (_MARKER == _extra) {
|
| - return _key.remove(key);
|
| - } else {
|
| - for (int remaining = _extra, i = 0; remaining > 0 && i < CAPACITY; i++) {
|
| - var candidate = _key[i];
|
| - if (_MARKER == candidate) continue;
|
| - if (candidate == key) {
|
| - int valueIndex = CAPACITY + i;
|
| - var result = _key[valueIndex];
|
| - _key[i] = _MARKER;
|
| - _key[valueIndex] = null;
|
| - _extra--;
|
| - return result;
|
| - }
|
| - remaining--;
|
| - }
|
| - return null;
|
| - }
|
| - }
|
| -
|
| - void forEach(void action(K key, V value)) {
|
| - if (_extra == null) {
|
| - if (_MARKER != _key) action(_key, _value);
|
| - } else if (_MARKER == _extra) {
|
| - _key.forEach(action);
|
| - } else {
|
| - for (int remaining = _extra, i = 0; remaining > 0 && i < CAPACITY; i++) {
|
| - var candidate = _key[i];
|
| - if (_MARKER == candidate) continue;
|
| - action(candidate, _key[CAPACITY + i]);
|
| - remaining--;
|
| - }
|
| - }
|
| - }
|
| -
|
| - void clear() {
|
| - _key = _MARKER;
|
| - _value = _extra = null;
|
| - }
|
| -
|
| - Iterable<K> get keys => new _MapletKeyIterable<K>(this);
|
| -}
|
| -
|
| -class _MapletMarker {
|
| - const _MapletMarker();
|
| -}
|
| -
|
| -class _MapletKeyIterable<K> extends IterableBase<K> {
|
| - final Maplet<K, dynamic> maplet;
|
| -
|
| - _MapletKeyIterable(this.maplet);
|
| -
|
| - Iterator<K> get iterator {
|
| - if (maplet._extra == null) {
|
| - return new _MapletSingleIterator<K>(maplet._key);
|
| - } else if (Maplet._MARKER == maplet._extra) {
|
| - return maplet._key.keys.iterator;
|
| - } else {
|
| - return new _MapletListIterator<K>(maplet._key, maplet._extra);
|
| - }
|
| - }
|
| -}
|
| -
|
| -class _MapletSingleIterator<K> implements Iterator<K> {
|
| - var _element;
|
| - K _current;
|
| -
|
| - _MapletSingleIterator(this._element);
|
| -
|
| - K get current => _current;
|
| -
|
| - bool moveNext() {
|
| - if (Maplet._MARKER == _element) {
|
| - _current = null;
|
| - return false;
|
| - }
|
| - _current = _element;
|
| - _element = Maplet._MARKER;
|
| - return true;
|
| - }
|
| -}
|
| -
|
| -class _MapletListIterator<K> implements Iterator<K> {
|
| - final List _list;
|
| - int _remaining;
|
| - int _index = 0;
|
| - K _current;
|
| -
|
| - _MapletListIterator(this._list, this._remaining);
|
| -
|
| - K get current => _current;
|
| -
|
| - bool moveNext() {
|
| - while (_remaining > 0) {
|
| - var candidate = _list[_index++];
|
| - if (Maplet._MARKER != candidate) {
|
| - _current = candidate;
|
| - _remaining--;
|
| - return true;
|
| - }
|
| - }
|
| - _current = null;
|
| - return false;
|
| - }
|
| -}
|
|
|