Uint64List abstract class
A fixed-length list of 64-bit unsigned integers that is viewable as a
ByteArray. For long lists, this implementation will be considerably
more space- and time-efficient than the default List
implementation.
abstract class Uint64List implements List<int>, ByteArrayViewable { /** * Creates a [Uint64List] of the specified length (in elements), all * of whose elements are initially zero. */ external factory Uint64List(int length); /** * Creates an [Uint64List] _view_ of the specified region in * the specified byte [array]. Changes in the [Uint64List] will be * visible in the byte array and vice versa. If the [start] index of the * region is not specified, it defaults to zero (the first byte in the byte * array). If the length is not specified, it defaults to null, which * indicates that the view extends to the end of the byte array. * * Throws [ArgumentError] if the length of the specified region * is not divisible by 8 (the size of a "uint64" in bytes), or if the * [start] of the region is not divisible by 8. If, however, [array] * is a view of another byte array, this constructor will throw * [ArgumentError] if the implicit starting position in the * "ultimately backing" byte array is not divisible by 8. In plain terms, * this constructor throws [ArgumentError] if the specified * region does not contain an integral number of "uint64s," or if it * is not "uint64-aligned." */ external factory Uint64List.view(ByteArray array, [int start, int length]); }
Implements
Constructors
factory Uint64List(int length) #
Creates a Uint64List of the specified length (in elements), all of whose elements are initially zero.
external factory Uint64List(int length);
factory Uint64List.view(ByteArray array, [int start, int length]) #
Creates an Uint64List view of the specified region in the specified byte array. Changes in the Uint64List will be visible in the byte array and vice versa. If the start index of the region is not specified, it defaults to zero (the first byte in the byte array). If the length is not specified, it defaults to null, which indicates that the view extends to the end of the byte array.
Throws ArgumentError
if the length of the specified region
is not divisible by 8 (the size of a "uint64" in bytes), or if the
start of the region is not divisible by 8. If, however,
array
is a view of another byte array, this constructor will throw
ArgumentError
if the implicit starting position in the
"ultimately backing" byte array is not divisible by 8. In plain terms,
this constructor throws ArgumentError
if the specified
region does not contain an integral number of "uint64s," or if it
is not "uint64-aligned."
external factory Uint64List.view(ByteArray array, [int start, int length]);
Properties
Operators
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);
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);
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);
ByteArray asByteArray([int start, int length]) #
Returns the byte array view of this object. This view allows the byte representation of the object to be read and written directly.
ByteArray asByteArray([int start, int length]);
int bytesPerElement() #
Returns the number of bytes in the representation of each element in this list, or the number bytes in the representation of the entire object if it is not a list.
int bytesPerElement();
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();
bool contains(E element) #
Check whether the collection contains an element equal to element.
bool contains(E element) { for (E e in this) { if (e == element) 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 (E element in this) { if (!f(element)) 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));
void forEach(void f(E element)) #
Applies the function f to each element of this collection.
void forEach(void f(E element)) { for (E element in this) f(element); }
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);
int indexOf(E element, [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 element, [int start = 0]);
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]);
bool isEmpty() #
Returns true if there is no element in this collection.
bool isEmpty() => !iterator().hasNext();
Iterator<E> iterator() #
Returns an Iterator
that iterates over this Iterable
object.
Iterator<E> iterator();
E last() #
Returns the last element of the list, or throws an out of bounds exception if the list is empty.
E last();
int lastIndexOf(E element, [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 element, [int start]);
int lengthInBytes() #
Returns the length of this view, in bytes.
int lengthInBytes();
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));
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);
Dynamic reduce(var initialValue, Dynamic combine(var previousValue, E element)) { var value = initialValue; for (E element in this) value = combine(value, element); 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);
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();
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);
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]);
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 (E element in this) { if (f(element)) return true; } return false; }
void sort([Comparator compare = Comparable.compare]) #
Sorts the list according to the order specified by the Comparator
.
void sort([Comparator<E> compare = Comparable.compare]);