mirror of
https://github.com/dart-lang/sdk
synced 2024-09-20 00:01:59 +00:00
2a8581a238
It contained a bug anyway: _GrowableList does not have a 0 arguments constructor. R=fschneider@google.com BUG= Review URL: https://codereview.chromium.org/2163173003 .
360 lines
10 KiB
Dart
360 lines
10 KiB
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.
|
|
|
|
class _GrowableList<T> extends ListBase<T> {
|
|
|
|
void insert(int index, T element) {
|
|
if ((index < 0) || (index > length)) {
|
|
throw new RangeError.range(index, 0, length);
|
|
}
|
|
if (index == this.length) {
|
|
add(element);
|
|
return;
|
|
}
|
|
int oldLength = this.length;
|
|
// We are modifying the length just below the is-check. Without the check
|
|
// Array.copy could throw an exception, leaving the list in a bad state
|
|
// (with a length that has been increased, but without a new element).
|
|
if (index is! int) throw new ArgumentError(index);
|
|
this.length++;
|
|
Lists.copy(this, index, this, index + 1, oldLength - index);
|
|
this[index] = element;
|
|
}
|
|
|
|
T removeAt(int index) {
|
|
var result = this[index];
|
|
int newLength = this.length - 1;
|
|
if (index < newLength) {
|
|
Lists.copy(this, index + 1, this, index, newLength - index);
|
|
}
|
|
this.length = newLength;
|
|
return result;
|
|
}
|
|
|
|
bool remove(Object element) {
|
|
for (int i = 0; i < this.length; i++) {
|
|
if (this[i] == element) {
|
|
removeAt(i);
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
void insertAll(int index, Iterable<T> iterable) {
|
|
if (index < 0 || index > length) {
|
|
throw new RangeError.range(index, 0, length);
|
|
}
|
|
// TODO(floitsch): we can probably detect more cases.
|
|
if (iterable is! List && iterable is! Set && iterable is! SubListIterable) {
|
|
iterable = iterable.toList();
|
|
}
|
|
int insertionLength = iterable.length;
|
|
// There might be errors after the length change, in which case the list
|
|
// will end up being modified but the operation not complete. Unless we
|
|
// always go through a "toList" we can't really avoid that.
|
|
this.length += insertionLength;
|
|
setRange(index + insertionLength, this.length, this, index);
|
|
setAll(index, iterable);
|
|
}
|
|
|
|
void setAll(int index, Iterable<T> iterable) {
|
|
if (iterable is List) {
|
|
setRange(index, index + iterable.length, iterable);
|
|
} else {
|
|
for (T element in iterable) {
|
|
this[index++] = element;
|
|
}
|
|
}
|
|
}
|
|
|
|
void removeRange(int start, int end) {
|
|
RangeError.checkValidRange(start, end, this.length);
|
|
Lists.copy(this, end, this, start, this.length - end);
|
|
this.length = this.length - (end - start);
|
|
}
|
|
|
|
List<T> sublist(int start, [int end]) {
|
|
end = RangeError.checkValidRange(start, end, this.length);
|
|
int length = end - start;
|
|
if (length == 0) return <T>[];
|
|
List list = new _List(length);
|
|
for (int i = 0; i < length; i++) {
|
|
list[i] = this[start + i];
|
|
}
|
|
var result = new _GrowableList<T>.withData(list);
|
|
result._setLength(length);
|
|
return result;
|
|
}
|
|
|
|
static const int _kDefaultCapacity = 2;
|
|
|
|
factory _GrowableList(int length) {
|
|
var data = new _List((length == 0) ? _kDefaultCapacity : length);
|
|
var result = new _GrowableList<T>.withData(data);
|
|
if (length > 0) {
|
|
result._setLength(length);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
factory _GrowableList.withCapacity(int capacity) {
|
|
var data = new _List((capacity == 0)? _kDefaultCapacity : capacity);
|
|
return new _GrowableList<T>.withData(data);
|
|
}
|
|
|
|
factory _GrowableList.withData(_List data)
|
|
native "GrowableList_allocate";
|
|
|
|
int get _capacity native "GrowableList_getCapacity";
|
|
|
|
int get length native "GrowableList_getLength";
|
|
|
|
void set length(int new_length) {
|
|
int new_capacity = (new_length == 0) ? _kDefaultCapacity : new_length;
|
|
if (new_capacity > _capacity) {
|
|
_grow(new_capacity);
|
|
_setLength(new_length);
|
|
return;
|
|
}
|
|
// We are shrinking. Pick the method which has fewer writes.
|
|
// In the shrink-to-fit path, we write |new_capacity + new_length| words
|
|
// (null init + copy).
|
|
// In the non-shrink-to-fit path, we write |length - new_length| words
|
|
// (null overwrite).
|
|
final bool shouldShrinkToFit =
|
|
(new_capacity + new_length) < (length - new_length);
|
|
if (shouldShrinkToFit) {
|
|
_shrink(new_capacity, new_length);
|
|
} else {
|
|
for (int i = new_length; i < length; i++) {
|
|
this[i] = null;
|
|
}
|
|
}
|
|
_setLength(new_length);
|
|
}
|
|
|
|
void _setLength(int new_length) native "GrowableList_setLength";
|
|
|
|
void _setData(_List array) native "GrowableList_setData";
|
|
|
|
T operator [](int index) native "GrowableList_getIndexed";
|
|
|
|
void operator []=(int index, T value) native "GrowableList_setIndexed";
|
|
|
|
// The length of this growable array. It is always less than or equal to the
|
|
// length of the object array, which itself is always greater than 0, so that
|
|
// grow() does not have to check for a zero length object array before
|
|
// doubling its size.
|
|
void add(T value) {
|
|
var len = length;
|
|
if (len == _capacity) {
|
|
_grow(len * 2);
|
|
}
|
|
_setLength(len + 1);
|
|
this[len] = value;
|
|
}
|
|
|
|
void addAll(Iterable<T> iterable) {
|
|
var len = length;
|
|
final cid = ClassID.getID(iterable);
|
|
final isVMList =
|
|
(cid == ClassID.cidArray) ||
|
|
(cid == ClassID.cidGrowableObjectArray) ||
|
|
(cid == ClassID.cidImmutableArray);
|
|
if (isVMList || (iterable is EfficientLength)) {
|
|
var cap = _capacity;
|
|
// Pregrow if we know iterable.length.
|
|
var iterLen = iterable.length;
|
|
var newLen = len + iterLen;
|
|
if (newLen > cap) {
|
|
do {
|
|
cap *= 2;
|
|
} while (newLen > cap);
|
|
_grow(cap);
|
|
}
|
|
if (isVMList) {
|
|
if (identical(iterable, this)) {
|
|
throw new ConcurrentModificationError(this);
|
|
}
|
|
this._setLength(newLen);
|
|
for (int i = 0; i < iterLen; i++) {
|
|
this[len++] = iterable[i];
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
Iterator it = iterable.iterator;
|
|
if (!it.moveNext()) return;
|
|
do {
|
|
while (len < _capacity) {
|
|
int newLen = len + 1;
|
|
this._setLength(newLen);
|
|
this[len] = it.current;
|
|
if (!it.moveNext()) return;
|
|
if (this.length != newLen) throw new ConcurrentModificationError(this);
|
|
len = newLen;
|
|
}
|
|
_grow(_capacity * 2);
|
|
} while (true);
|
|
}
|
|
|
|
T removeLast() {
|
|
var len = length - 1;
|
|
var elem = this[len];
|
|
this[len] = null;
|
|
_setLength(len);
|
|
return elem;
|
|
}
|
|
|
|
T get first {
|
|
if (length > 0) return this[0];
|
|
throw IterableElementError.noElement();
|
|
}
|
|
|
|
T get last {
|
|
if (length > 0) return this[length - 1];
|
|
throw IterableElementError.noElement();
|
|
}
|
|
|
|
T get single {
|
|
if (length == 1) return this[0];
|
|
if (length == 0) throw IterableElementError.noElement();
|
|
throw IterableElementError.tooMany();;
|
|
}
|
|
|
|
void _grow(int new_capacity) {
|
|
var new_data = new _List(new_capacity);
|
|
for (int i = 0; i < length; i++) {
|
|
new_data[i] = this[i];
|
|
}
|
|
_setData(new_data);
|
|
}
|
|
|
|
void _shrink(int new_capacity, int new_length) {
|
|
var new_data = new _List(new_capacity);
|
|
for (int i = 0; i < new_length; i++) {
|
|
new_data[i] = this[i];
|
|
}
|
|
_setData(new_data);
|
|
}
|
|
|
|
// Iterable interface.
|
|
|
|
void forEach(f(T element)) {
|
|
int initialLength = length;
|
|
for (int i = 0; i < length; i++) {
|
|
f(this[i]);
|
|
if (length != initialLength) throw new ConcurrentModificationError(this);
|
|
}
|
|
}
|
|
|
|
String join([String separator = ""]) {
|
|
final int length = this.length;
|
|
if (length == 0) return "";
|
|
if (length == 1) return "${this[0]}";
|
|
if (separator.isNotEmpty) return _joinWithSeparator(separator);
|
|
var i = 0;
|
|
var codeUnitCount = 0;
|
|
while (i < length) {
|
|
final element = this[i];
|
|
final int cid = ClassID.getID(element);
|
|
// While list contains one-byte strings.
|
|
if (ClassID.cidOneByteString == cid) {
|
|
codeUnitCount += element.length;
|
|
i++;
|
|
// Loop back while strings are one-byte strings.
|
|
continue;
|
|
}
|
|
// Otherwise, never loop back to the outer loop, and
|
|
// handle the remaining strings below.
|
|
|
|
// Loop while elements are strings,
|
|
final int firstNonOneByteStringLimit = i;
|
|
var nextElement = element;
|
|
while (nextElement is String) {
|
|
i++;
|
|
if (i == length) {
|
|
return _StringBase._concatRangeNative(this, 0, length);
|
|
}
|
|
nextElement = this[i];
|
|
}
|
|
|
|
// Not all elements are strings, so allocate a new backing array.
|
|
final list = new _List(length);
|
|
for (int copyIndex = 0; copyIndex < i; copyIndex++) {
|
|
list[copyIndex] = this[copyIndex];
|
|
}
|
|
// Is non-zero if list contains a non-onebyte string.
|
|
var onebyteCanary = i - firstNonOneByteStringLimit;
|
|
while (true) {
|
|
final String elementString = "$nextElement";
|
|
onebyteCanary |=
|
|
(ClassID.getID(elementString) ^ ClassID.cidOneByteString);
|
|
list[i] = elementString;
|
|
codeUnitCount += elementString.length;
|
|
i++;
|
|
if (i == length) break;
|
|
nextElement = this[i];
|
|
}
|
|
if (onebyteCanary == 0) {
|
|
// All elements returned a one-byte string from toString.
|
|
return _OneByteString._concatAll(list, codeUnitCount);
|
|
}
|
|
return _StringBase._concatRangeNative(list, 0, length);
|
|
}
|
|
// All elements were one-byte strings.
|
|
return _OneByteString._concatAll(this, codeUnitCount);
|
|
}
|
|
|
|
String _joinWithSeparator(String separator) {
|
|
StringBuffer buffer = new StringBuffer();
|
|
buffer.write(this[0]);
|
|
for (int i = 1; i < this.length; i++) {
|
|
buffer.write(separator);
|
|
buffer.write(this[i]);
|
|
}
|
|
return buffer.toString();
|
|
}
|
|
|
|
T elementAt(int index) {
|
|
return this[index];
|
|
}
|
|
|
|
bool get isEmpty {
|
|
return this.length == 0;
|
|
}
|
|
|
|
bool get isNotEmpty => !isEmpty;
|
|
|
|
void clear() {
|
|
this.length = 0;
|
|
}
|
|
|
|
String toString() => ListBase.listToString(this);
|
|
|
|
Iterator<T> get iterator {
|
|
return new ListIterator<T>(this);
|
|
}
|
|
|
|
List<T> toList({ bool growable: true }) {
|
|
var length = this.length;
|
|
if (length > 0) {
|
|
List list = growable ? new _List(length) : new _List<T>(length);
|
|
for (int i = 0; i < length; i++) {
|
|
list[i] = this[i];
|
|
}
|
|
if (!growable) return list;
|
|
var result = new _GrowableList<T>.withData(list);
|
|
result._setLength(length);
|
|
return result;
|
|
}
|
|
return growable ? <T>[] : new List<T>(0);
|
|
}
|
|
|
|
Set<T> toSet() {
|
|
return new Set<T>.from(this);
|
|
}
|
|
}
|