SequenceList<E> class
An unmodifiable List backed by a Sequence.
class SequenceList<E> extends SequenceCollection<E> implements List<E> { Sequence<E> sequence; SequenceList(this.sequence); int get length => sequence.length; T operator[](int index) => sequence[index]; int indexOf(E value, [int start = 0]) { for (int i = start; i < sequence.length; i++) { if (sequence[i] == value) return i; } return -1; } int lastIndexOf(E value, [int start]) { if (start == null) start = sequence.length - 1; for (int i = start; i >= 0; i--) { if (sequence[i] == value) return i; } return -1; } E last() => sequence[sequence.length - 1]; List<E> getRange(int start, int length) { List<E> result = <E>[]; for (int i = 0; i < length; i++) { result.add(sequence[start + i]); } return result; } void operator []=(int index, E value) { throw new UnsupportedOperationException( "Cannot modify an unmodifiable list"); } void set length(int newLength) { throw new UnsupportedOperationException( "Cannot change the length of an unmodifiable list"); } void add(E value) { throw new UnsupportedOperationException( "Cannot add to an unmodifiable list"); } void addLast(E value) { throw new UnsupportedOperationException( "Cannot add to an unmodifiable list"); } void addAll(Collection<E> collection) { throw new UnsupportedOperationException( "Cannot add to an unmodifiable list"); } void sort([Comparator<E> compare]) { throw new UnsupportedOperationException( "Cannot modify an unmodifiable list"); } void clear() { throw new UnsupportedOperationException( "Cannot clear an unmodifiable list"); } E removeAt(int index) { throw new UnsupportedOperationException( "Cannot remove in an unmodifiable list"); } E removeLast() { throw new UnsupportedOperationException( "Cannot remove in an unmodifiable list"); } void setRange(int start, int length, List<E> from, [int startFrom]) { throw new UnsupportedOperationException( "Cannot modify an unmodifiable list"); } void removeRange(int start, int length) { throw new UnsupportedOperationException( "Cannot remove in an unmodifiable list"); } void insertRange(int start, int length, [E initialValue]) { throw new UnsupportedOperationException( "Cannot insert range in an unmodifiable list"); } }
Extends
SequenceCollection<E> > SequenceList<E>
Implements
Properties
void set length(int newLength) #
Changes the length of the list. If
newLength is greater than
the current length, entries are initialized to null
. Throws
an UnsupportedOperationException if the list is not extendable.
void set length(int newLength) { throw new UnsupportedOperationException( "Cannot change the length of an unmodifiable list"); }
Operators
operator [](int index) #
Returns the element at the given index in the list or throws an IndexOutOfRangeException if index is out of bounds.
T operator[](int index) => sequence[index];
void operator []=(int index, E value) #
Sets the entry at the given index in the list to value. Throws an IndexOutOfRangeException if index is out of bounds.
void operator []=(int index, E value) { throw new UnsupportedOperationException( "Cannot modify an unmodifiable list"); }
Methods
void add(E value) #
Adds value at the end of the list, extending the length by one. Throws an UnsupportedOperationException if the list is not extendable.
void add(E value) { throw new UnsupportedOperationException( "Cannot add to an unmodifiable list"); }
void addAll(Collection<E> collection) #
Appends all elements of the collection to the end of this list. Extends the length of the list by the number of elements in collection. Throws an UnsupportedOperationException if this list is not extendable.
void addAll(Collection<E> collection) { throw new UnsupportedOperationException( "Cannot add to an unmodifiable list"); }
void addLast(E value) #
Adds value at the end of the list, extending the length by one. Throws an UnsupportedOperationException if the list is not extendable.
void addLast(E value) { throw new UnsupportedOperationException( "Cannot add to an unmodifiable list"); }
void clear() #
Removes all elements in the list.
The length of the list becomes zero. Throws an UnsupportedOperationException, and retains all elements, if the length of the list cannot be changed.
void clear() { throw new UnsupportedOperationException( "Cannot clear an unmodifiable list"); }
bool contains(E value) #
Check whether the collection contains an element equal to element
.
bool contains(E value) { for (int i = 0; i < sequence.length; i++) { if (sequence[i] == value) return true; } return false; }
bool every(bool f(E element)) #
Returns true if every elements of this collection satisify the predicate f. Returns false otherwise.
bool every(bool f(E element)) { for (int i = 0; i < this.length; i++) { if (!f(this[i])) return false; } return true; }
Collection<E> filter(bool f(E element)) #
Returns a collection with the elements of this collection that satisfy the predicate f.
The returned collection should be of the same type as the collection creating it.
An element satisfies the predicate
f if f(element)
returns true.
Collection<E> filter(bool f(E element)) { List<E> result = <E>[]; for (int i = 0; i < this.length; i++) { E element = this[i]; if (f(element)) result.add(element); } return result; }
void forEach(f(E element)) #
Applies the function f to each element of this collection.
void forEach(f(E element)) { for (int i = 0; i < this.length; i++) f(this[i]); }
List<E> getRange(int start, int length) #
Returns a new list containing
length elements from the list,
starting at
start.
Returns an empty list if
length is 0.
Throws an ArgumentError if
length is negative.
Throws an IndexOutOfRangeException if
start or
start + length - 1
are out of range.
List<E> getRange(int start, int length) { List<E> result = <E>[]; for (int i = 0; i < length; i++) { result.add(sequence[start + i]); } return result; }
int indexOf(E value, [int start = 0]) #
Returns the first index of element
in the list.
Searches the list from index
start to the length of the list.
The first time an element e
is encountered so that e == element
,
the index of e
is returned.
Returns -1 if element
is not found.
int indexOf(E value, [int start = 0]) { for (int i = start; i < sequence.length; i++) { if (sequence[i] == value) return i; } return -1; }
void insertRange(int start, int length, [E initialValue]) #
Inserts a new range into the list, starting from
start to
start + length - 1
. The entries are filled with
initialValue.
Throws an UnsupportedOperationException if the list is
not extendable.
If
length is 0, this method does not do anything.
If
start is the length of the list, this method inserts the
range at the end of the list.
Throws an ArgumentError if
length is negative.
Throws an IndexOutOfRangeException if
start is negative or if
start is greater than the length of the list.
void insertRange(int start, int length, [E initialValue]) { throw new UnsupportedOperationException( "Cannot insert range in an unmodifiable list"); }
bool isEmpty() #
Returns true if there is no element in this collection.
bool isEmpty() { return this.length == 0; }
Iterator<E> iterator() #
int lastIndexOf(E value, [int start]) #
Returns the last index of element
in the list.
Searches the list backwards from index start to 0.
The first time an element e
is encountered so that e == element
,
the index of e
is returned.
If start is not provided, it defaults to this.length - 1
.
Returns -1 if element
is not found.
int lastIndexOf(E value, [int start]) { if (start == null) start = sequence.length - 1; for (int i = start; i >= 0; i--) { if (sequence[i] == value) return i; } return -1; }
Collection map(f(E element)) #
Returns a new collection with the elements f(e)
for each element e
of this collection.
Subclasses of Collection should implement the map
method
to return a collection of the same general type as themselves.
E.g., List.map
should return a List.
Collection map(f(E element)) { List result = new List(); for (int i = 0; i < this.length; i++) { result.add(f(this[i])); } return result; }
reduce(initialValue, combine(previousValue, E element)) #
Reduce a collection to a single value by iteratively combining each element of the collection with an existing value using the provided function. Use initialValue as the initial value, and the function combine to create a new value from the previous one and an element.
Example of calculating the sum of a collection:
collection.reduce(0, (prev, element) => prev + element);
reduce(initialValue, combine(previousValue, E element)) { var value = initialValue; for (int i = 0; i < this.length; i++) { value = combine(value, this[i]); } return value; }
E removeAt(int index) #
Removes the element at position index from the list.
This reduces the length of the list by one and moves all later elements down by one position. Returns the removed element. Throws an ArgumentError if index is not an int. Throws an IndexOutOfRangeException if the index does not point inside the list. Throws an UnsupportedOperationException, and doesn't remove the element, if the length of the list cannot be changed.
E removeAt(int index) { throw new UnsupportedOperationException( "Cannot remove in an unmodifiable list"); }
E removeLast() #
Pops and returns the last element of the list. Throws a UnsupportedOperationException if the length of the list cannot be changed.
E removeLast() { throw new UnsupportedOperationException( "Cannot remove in an unmodifiable list"); }
void removeRange(int start, int length) #
Removes
length elements from the list, beginning at
start.
Throws an UnsupportedOperationException if the list is
not extendable.
If
length is 0, this method does not do anything.
Throws an ArgumentError if
length is negative.
Throws an IndexOutOfRangeException if
start or
:start + length: - 1
are out of range.
void removeRange(int start, int length) { throw new UnsupportedOperationException( "Cannot remove in an unmodifiable list"); }
void setRange(int start, int length, List<E> from, [int startFrom]) #
Copies
length elements of
from, starting
at
startFrom, into the list, starting at
start.
If
length is 0, this method does not do anything.
Throws an ArgumentError if
length is negative.
Throws an IndexOutOfRangeException if
start or
start + length - 1
are out of range for this
, or if
startFrom or startFrom + length - 1
are out of range for
from.
void setRange(int start, int length, List<E> from, [int startFrom]) { throw new UnsupportedOperationException( "Cannot modify an unmodifiable list"); }
bool some(bool f(E element)) #
Returns true if one element of this collection satisfies the predicate f. Returns false otherwise.
bool some(bool f(E element)) { for (int i = 0; i < this.length; i++) { if (f(this[i])) return true; } return false; }
void sort([Comparator compare]) #
Sorts the list according to the order specified by the Comparator.
void sort([Comparator<E> compare]) { throw new UnsupportedOperationException( "Cannot modify an unmodifiable list"); }