MQueue<A> class

A mutable FIFO queue backed by ArrayDeque.

Use enqueue / enqueueAll to add elements at the back and dequeue to remove from the front. front peeks at the head without removing it.

final q = MQueue<int>();
q.enqueue(1).enqueue(2);
q.dequeue(); // 1
q.front;     // 2
Inheritance
Available extensions

Constructors

MQueue([int size = ArrayDeque.DefaultInitialSize])

Properties

array ↔ Array<A>
getter/setter pairinherited
end ↔ int
getter/setter pairinherited
front → A
Returns the front element without removing it.
no setter
hashCode → int
The hash code for this object.
no setterinherited
Returns the first element of this collection, or throws if it is empty.
no setterinherited
headOption → Option<A>
Returns the first element of this collection as a Some if non-empty. If this collction is empty, None is returned.
no setterinherited
init → ArrayDeque<A>
Returns all elements from this collection except the last. If this collection is empty, an empty collection is returned.
no setterinherited
inits → RIterator<ArrayDeque<A>>
Returns an iterator of all potential tails of this collection, starting with the entire collection and ending with an empty one.
no setterinherited
isEmpty → bool
Whether this collection contains no elements.
no setterinherited
isNotEmpty → bool
Whether this collection contains at least one element.
no setterinherited
isTraversableAgain → bool
Whether this collection can be traversed more than once.
no setterinherited
iterator → RIterator<A>
Returns an RIterator over the elements of this collection.
no setterinherited
knownSize → int
Returns the number of elements in this collection, if that number is already known. If not, -1 is returned.
no setterinherited
last → A
Returns the last element of this collection, or throws if it is empty.
no setterinherited
lastOption → Option<A>
Returns the last element of this collection as a Some, or None if this collection is empty.
no setterinherited
length → int
The number of elements in this sequence.
no setterinherited
nonEmpty → bool
Whether this collection contains at least one element.
no setterinherited
runtimeType → Type
A representation of the runtime type of the object.
no setterinherited
size → int
Returns the number of elements in this collection.
no setterinherited
start ↔ int
getter/setter pairinherited
tail → ArrayDeque<A>
Returns a new collection with the first element removed. If this collection is empty, an empty collection is returned.
no setterinherited
tails → RIterator<ArrayDeque<A>>
Returns an iterator of all potential tails of this collection, starting with the entire collection and ending with an empty one.
no setterinherited

Methods

addAll(RIterableOnce<A> elems) → ArrayDeque<A>
Appends all elems and returns this.
inherited
addOne(A elem) → ArrayDeque<A>
Appends elem and returns this.
inherited
append(A elem) → ArrayDeque<A>
Alias for addOne.
inherited
appendAll(RIterableOnce<A> elems) → ArrayDeque<A>
Alias for addAll.
inherited
appended(A elem) → ArrayDeque<A>
Returns a new Seq, with the given elem added to the end.
inherited
appendedAll(RIterableOnce<A> suffix) → ArrayDeque<A>
Returns a new Seq, with elems added to the end.
inherited
canEqual(Object other) → bool
inherited
clear() → void
Removes all elements from this buffer.
inherited
collect<B>(Function1<A, Option<B>> f) → ArrayDeque<B>
Returns a new collection by applying f to each element an only keeping results of type Some.
inherited
collectFirst<B>(Function1<A, Option<B>> f) → Option<B>
Applies f to each element of this collection, returning the first element that results in a Some, if any.
inherited
combinations(int n) → RIterator<ArrayDeque<A>>
Returns an Iterator that will produce all combinations of elements from this sequence of size n in order.
inherited
concat(covariant RIterableOnce<A> suffix) → ArrayDeque<A>
Returns a copy of this collection, with elems added to the end.
inherited
contains(A elem) → bool
Returns true, if any element of this collection equals elem.
inherited
containsSlice(RSeq<A> that) → bool
Returns true if that is contained in this collection, in order.
inherited
copyToArray(Array<A> xs, [int start = 0, int? n]) → int
Copies elements into xs starting at start, writing at most n elements (or all remaining capacity when n is omitted).
inherited
corresponds<B>(covariant RIterable<B> that, Function2<A, B, bool> p) → bool
Returns true if this collection has the same size as that and each corresponding element from this and that satisfies the given predicate p.
inherited
count(Function1<A, bool> p) → int
Return the number of elements in this collection that satisfy the given predicate.
inherited
dequeue() → A
Removes and returns the front element. Throws if empty.
dequeueAll(Function1<A, bool> p) → RSeq<A>
Removes and returns all elements satisfying p.
dequeueFirst(Function1<A, bool> p) → Option<A>
Removes and returns the first element satisfying p, or None if none.
dequeueWhile(Function1<A, bool> p) → RSeq<A>
Removes and returns all leading elements satisfying p.
diff(RSeq<A> that) → ArrayDeque<A>
Returns a new collection with the difference of this and that, i.e. all elements that appear in only this collection.
inherited
distinct() → ArrayDeque<A>
Returns a new collection where every element is distinct according to equality.
inherited
distinctBy<B>(Function1<A, B> f) → ArrayDeque<A>
Returns a new collection where every element is distinct according to the application of f to each element.
inherited
drop(int n) → ArrayDeque<A>
Returns a new collection with the first n elements removed.
inherited
dropInPlace(int n) → ArrayDeque<A>
Removes the first n elements in place and returns this.
inherited
dropRight(int n) → ArrayDeque<A>
Return a new collection with the last n elements removed.
inherited
dropRightInPlace(int n) → ArrayDeque<A>
Removes the last n elements in place and returns this.
inherited
dropWhile(Function1<A, bool> p) → ArrayDeque<A>
Returns a new collection with leading elements satisfying p removed.
inherited
dropWhileInPlace(Function1<A, bool> p) → ArrayDeque<A>
Removes leading elements satisfying p in place and returns this.
inherited
endsWith(RIterable<A> that) → bool
Returns true if the end of this collection has the same elements in order as that. Otherwise, false is returned.
inherited
enqueue(A elem) → MQueue<A>
Adds elem at the back of the queue and returns this.
enqueueAll(RIterableOnce<A> elems) → MQueue<A>
Adds all elems at the back of the queue and returns this.
exists(Function1<A, bool> p) → bool
Returns true if any element of this collection satisfies the given predicate, false if no elements satisfy it.
inherited
filter(Function1<A, bool> p) → ArrayDeque<A>
Returns a new collection containing only elements that satisfy p.
inherited
filterNot(Function1<A, bool> p) → ArrayDeque<A>
Returns a new collection containing only elements that do not satisfy p.
inherited
find(Function1<A, bool> p) → Option<A>
Returns the first element from this collection that satisfies the given predicate p. If no element satisfies p, None is returned.
inherited
findLast(Function1<A, bool> p) → Option<A>
Returns the last element satisfying p as Some, or None if none.
inherited
flatMap<B>(covariant Function1<A, RIterableOnce<B>> f) → ArrayDeque<B>
Returns a new collection by applying f to each element and concatenating the results.
inherited
flatten() → RIterable<A>

Available on RIterable<RIterable<A>>, provided by the RIterableNested2Ops extension

Concatenates all inner iterables into a single IList.
fold(A init, Function2<A, A, A> op) → A
Alias for foldLeft with a same-type accumulator.
inherited
foldLeft<B>(B z, Function2<B, A, B> op) → B
Returns a summary value by applying op to all elements of this collection, moving from left to right. The fold uses a seed value of z.
inherited
foldRight<B>(B z, Function2<A, B, B> op) → B
Returns a summary value by applying op to all elements of this collection, moving from right to left. The fold uses a seed value of z.
inherited
forall(Function1<A, bool> p) → bool
Returns true if all elements of this collection satisfy the given predicate, false if any elements do not.
inherited
foreach<U>(Function1<A, U> f) → void
Applies f to each element of this collection, discarding any resulting values.
inherited
groupBy<K>(Function1<A, K> f) → IMap<K, ArrayDeque<A>>
Partitions all elements of this collection by applying f to each element and accumulating duplicate keys in the returned IMap.
inherited
grouped(int size) → RIterator<ArrayDeque<A>>
Returns a new iterator where each element is a collection of size elements from the original collection. The last element may contain less than size elements.
inherited
groupMap<K, B>(Function1<A, K> key, Function1<A, B> f) → IMap<K, ArrayDeque<B>>
Creates a new map by generating a key-value pair for each elements of this collection using key and f. Any elements that generate the same key will have the resulting values accumulated in the returned map.
inherited
groupMapReduce<K, B>(Function1<A, K> key, Function1<A, B> f, Function2<B, B, B> reduce) → IMap<K, B>
Partitions all elements of this collection by applying key to each element. Additionally f is applied to each element to generate a value. If multiple values are generating for the same key, those values will be combined using reduce.
inherited
indexOf(A elem, [int from = 0]) → Option<int>
Returns the first index, if any, where the element at that index equals elem. If no index contains elem, None is returned.
inherited
indexOfSlice(RSeq<A> that, [int from = 0]) → Option<int>
Finds the first index in this collection where the next sequence of elements is equal to that. If that cannot be found in this collection, None is returned.
inherited
indexWhere(Function1<A, bool> p, [int from = 0]) → Option<int>
Returns the index of the first element that satisfies the predicate p. If no element satisfies, None is returned.
inherited
indices() → Range
Returns a range of all indices of this sequence
inherited
insert(int idx, A elem) → void
Inserts elem at position idx, shifting later elements right.
inherited
insertAll(int idx, RIterableOnce<A> elems) → void
Inserts all elems starting at position idx.
inherited
intersect(RSeq<A> that) → ArrayDeque<A>
Returns a new collection with the intersection of this and that, i.e. all elements that appear in both collections.
inherited
intersperse(A x) → ArrayDeque<A>
Returns a new collection with sep inserted between each element.
inherited
isDefinedAt(int idx) → bool
Returns true if this collection has an element at the given idx.
inherited
lastIndexOf(A elem, [int end = 2147483647]) → Option<int>
Returns the last index, if any, where the element at that index equals elem. If no index contains elem, None is returned.
inherited
lastIndexOfSlice(RSeq<A> that, [int end = 2147483647]) → Option<int>
Finds the last index in this collection where the next sequence of elements is equal to that. If that cannot be found in this collection, None is returned.
inherited
lastIndexWhere(Function1<A, bool> p, [int end = 2147483647]) → Option<int>
Returns the index of the last element that satisfies the predicate p. If no element satisfies, None is returned.
inherited
lift(int ix) → Option<A>
Returns the element at index ix as a Some. If ix is outside the range of this collection, None is returned.
inherited
map<B>(Function1<A, B> f) → RSeq<B>
Returns a new collection by applying f to each element.
inherited
maxByOption<B>(Function1<A, B> f, Order<B> order) → Option<A>
Finds the largest element in this collection by applying f to each element and using the given Order to find the greatest.
inherited
maxOption(Order<A> order) → Option<A>
Finds the largest element in this collection according to the given Order.
inherited
minByOption<B>(Function1<A, B> f, Order<B> order) → Option<A>
Finds the smallest element in this collection by applying f to each element and using the given Order to find the greatest.
inherited
minOption(Order<A> order) → Option<A>
Finds the largest element in this collection according to the given Order.
inherited
mkString({String? start, String? sep, String? end}) → String
Returns a String by using each elements toString(), adding sep between each element. If start is defined, it will be prepended to the resulting string. If end is defined, it will be appended to the resulting string.
inherited
noSuchMethod(Invocation invocation) → dynamic
Invoked when a nonexistent method or property is accessed.
inherited
padTo(int len, A elem) → ArrayDeque<A>
Returns a new collection with a length of at least len.
inherited
padToInPlace(int len, A elem) → ArrayDeque<A>
Appends elem until length equals len, then returns this.
inherited
partition(Function1<A, bool> p) → (ArrayDeque<A>, ArrayDeque<A>)
Returns 2 collections as a tuple where the first tuple element will be a collection of elements that satisfy the given predicate p. The second item of the returned tuple will be elements that do not satisfy p.
inherited
partitionMap<A1, A2>(Function1<A, Either<A1, A2>> f) → (ArrayDeque<A1>, ArrayDeque<A2>)
Applies f to each element of this collection and returns a separate collection for all applications resulting in a Left and Right respectively.
inherited
patch(int from, RIterableOnce<A> other, int replaced) → ArrayDeque<A>
Returns a new collection with replaced elements starting at from replaced by the elements of other.
inherited
patchInPlace(int from, RIterableOnce<A> patch, int replaced) → ArrayDeque<A>
Replaces replaced elements starting at from with patch in place.
inherited
permutations() → RIterator<IndexedSeq<A>>
Returns an Iterator that will emit all possible permutations of the elements in this collection.
inherited
prepend(A elem) → ArrayDeque<A>
Prepends elem and returns this.
inherited
prependAll(RIterableOnce<A> elems) → ArrayDeque<A>
Prepends all elems and returns this.
inherited
prepended(A elem) → IndexedSeq<A>
Returns a new collection with elem added to the beginning.
inherited
prependedAll(RIterableOnce<A> prefix) → IndexedSeq<A>
Returns a new collection with all elems added to the beginning.
inherited
product() → double

Available on RIterableOnce<double>, provided by the RIterableDoubleOps extension

Returns the product of all elements in this list
product() → int

Available on RIterableOnce<int>, provided by the RIterableIntOps extension

Returns the product of all elements in this list
reduce(Function2<A, A, A> op) → A
Reduces this collection to a single value by applying op left to right.
inherited
reduceLeft(Function2<A, A, A> op) → A
Reduces from left to right. Throws if empty.
inherited
reduceLeftOption(Function2<A, A, A> op) → Option<A>
Returns a summary values of all elements of this collection by applying f to each element, moving left to right.
inherited
reduceOption(Function2<A, A, A> op) → Option<A>
Returns a summary values of all elements of this collection by applying f to each element, moving left to right.
inherited
reduceRight(Function2<A, A, A> op) → A
Reduces from right to left. Throws if empty.
inherited
reduceRightOption(Function2<A, A, A> op) → Option<A>
Returns a summary values of all elements of this collection by applying f to each element, moving right to left.
inherited
remove(int idx) → A
Removes and returns the element at idx.
inherited
removeAll(Function1<A, bool> p) → RSeq<A>
Removes and returns all elements satisfying p in FIFO order.
inherited
removeAt(int idx) → ArrayDeque<A>
Returns a new collection with the element at idx removed.
inherited
removeFirst(Function1<A, bool> p, [int from = 0]) → Option<A>
Removes the first element satisfying p at or after from and returns Some(element), or None if no such element exists.
inherited
removeHead({bool resizeInternalRepr = false}) → A
Removes and returns the first element.
inherited
removeHeadOption({bool resizeInternalRepr = false}) → Option<A>
Removes and returns the first element wrapped in Some, or returns None when empty.
inherited
removeHeadWhile(Function1<A, bool> p) → RSeq<A>
Removes and returns all leading elements satisfying p.
inherited
removeLast({bool resizeInternalRepr = false}) → A
Removes and returns the last element.
inherited
removeLastOption({bool resizeInternalRepr = false}) → Option<A>
Removes and returns the last element wrapped in Some, or returns None when empty.
inherited
removeN(int idx, int count) → void
Removes count elements starting at idx.
inherited
reverse() → ArrayDeque<A>
Returns a new collection with the order of the elements reversed.
inherited
reverseIterator() → RIterator<A>
Returns an iterator that will emit all elements in this collection, in reverse order.
inherited
sameElements(RIterable<A> that) → bool
Returns true if this collection has the same elements, in the same order, as that.
inherited
scan<B>(B z, Function2<B, A, B> op) → ArrayDeque<B>
Alias for scanLeft.
inherited
scanLeft<B>(B z, Function2<B, A, B> op) → ArrayDeque<B>
Returns a new collection of running totals starting with z.
inherited
scanRight<B>(B z, Function2<A, B, B> op) → ArrayDeque<B>
Returns a new collection of running totals starting with z, traversing from right to left.
inherited
segmentLength(Function1<A, bool> p, [int from = 0]) → int
Returns the length of the longest prefix starting at from where every element satisfies p.
inherited
slice(int from, int until) → ArrayDeque<A>
Returns a new collection containing elements in the range [from, until).
inherited
sliceInPlace(int start, int end) → ArrayDeque<A>
Keeps only the elements in [start, end) in place and returns this.
inherited
sliding(int size, [int step = 1]) → RIterator<ArrayDeque<A>>
Returns an iterator where elements are fixed size chunks of size n of the original collection. Each chunk is calculated by sliding a 'window' of size n over the original collection, moving the window step elements at a time.
inherited
sortBy<B>(Order<B> order, Function1<A, B> f) → ArrayDeque<A>
Returns a new collection that is sorted according to order after applying f to each element in this collection.
inherited
sorted(Order<A> order) → ArrayDeque<A>
Returns a new collection that is sorted according to order.
inherited
sortWith(Function2<A, A, bool> lt) → ArrayDeque<A>
Returns a new collection sorted using the provided function lt which is used to determine if one element is less than the other.
inherited
span(Function1<A, bool> p) → (ArrayDeque<A>, ArrayDeque<A>)
Returns two collections: elements before and starting from the first element that does not satisfy p.
inherited
splitAt(int n) → (RSeq<A>, RSeq<A>)
Returns two collections: the first n elements and the remainder.
inherited
startsWith(RIterableOnce<A> that, [int offset = 0]) → bool
Returns true if the beginning of this collection corresponds with that.
inherited
subtractOne(A x) → ArrayDeque<A>
Removes the first occurrence of x and returns this.
inherited
sum() → double

Available on RIterableOnce<double>, provided by the RIterableDoubleOps extension

Returns the sum of all elements in this list
sum() → int

Available on RIterableOnce<int>, provided by the RIterableIntOps extension

Returns the sum of all elements in this list
take(int n) → ArrayDeque<A>
Returns a new collection containing only the first n elements.
inherited
takeInPlace(int n) → ArrayDeque<A>
Keeps only the first n elements in place and returns this.
inherited
takeRight(int n) → ArrayDeque<A>
Returns a new collection with the last n elements of this collection. If n is greater than the size of this collection, the original collection is returned.
inherited
takeRightInPlace(int n) → ArrayDeque<A>
Keeps only the last n elements in place and returns this.
inherited
takeWhile(Function1<A, bool> p) → ArrayDeque<A>
Returns a new collection of leading elements that satisfy p.
inherited
takeWhileInPlace(Function1<A, bool> p) → ArrayDeque<A>
Keeps only the leading elements satisfying p in place and returns this.
inherited
tapEach<U>(Function1<A, U> f) → ArrayDeque<A>
Applies f to each element in this collection, discarding any results and returns this collection.
inherited
toIList() → IList<A>
Returns an IList with the same elements as this collection.
inherited
toIMap() → IMap<A, B>

Available on RIterable<(A, B)>, provided by the RIterableTuple2Ops extension

Creates a new IMap where each tuple element of this list is used to create a key and value respectively.
toIndexedSeq() → IndexedSeq<A>
Returns an IndexedSeq with the same elements as this collection.
inherited
toISet() → ISet<A>
Returns an ISet with the same elements as this collection, duplicates removed.
inherited
toIVector() → IVector<A>
Returns an IVector with the same elements as this collection.
inherited
toList({bool growable = true}) → List<A>
Returns a new List with the same elements as this collection.
inherited
toSeq() → RSeq<A>
Returns a RSeq with the same elements as this collection.
inherited
toString() → String
A string representation of this object.
inherited
traverseEither<B, C>(Function1<A, Either<B, C>> f) → Either<B, ArrayDeque<C>>
Applies f to each element of this RSeq and collects the results into a new collection. If Left is encountered for any element, that result is returned and any additional elements will not be evaluated.
inherited
traverseOption<B>(Function1<A, Option<B>> f) → Option<ArrayDeque<B>>
Applies f to each element of this RSeq and collects the results into a new collection. If None is encountered for any element, that result is returned and any additional elements will not be evaluated.
inherited
trimToSize() → void
Shrinks the internal array to exactly fit the current number of elements.
inherited
unzip() → (IndexedSeq<A>, IndexedSeq<B>)

Available on IndexedSeq<(A, B)>, provided by the IndexedSeqTuple2Ops extension

unzip() → (RIterable<A>, RIterable<B>)

Available on RIterable<(A, B)>, provided by the RibsIterableTuple2Ops extension

Splits a collection of pairs into two separate collections.
update(int idx, A elem) → void
Replaces the element at idx with elem.
inherited
updated(int index, A elem) → ArrayDeque<A>
Returns a new collection with the element at index replaced by elem.
inherited
zip<B>(RIterableOnce<B> that) → ArrayDeque<(A, B)>
Returns a new collection that combines corresponding elements from this collection and that as a tuple. The length of the returned collection will be the minimum of this collections size and the size of that.
inherited
zipAll<B>(RIterableOnce<B> that, A thisElem, B thatElem) → ArrayDeque<(A, B)>
Returns a new collection that combines corresponding elements from this collection and that as a tuple. The length of the returned collection will be the maximum of this collections size and thes size of that. If this collection is shorter than that, thisElem will be used to fill in the resulting collection. If that is shorter, thatElem will be used to will in the resulting collection.
inherited
zipWithIndex() → ArrayDeque<(A, int)>
Return a new collection with each element of this collection paired with it's respective index.
inherited

Operators

operator ==(Object other) → bool
The equality operator.
inherited
operator [](int idx) → A
Returns the element at index idx.
inherited

Static Methods

empty<A>() → MQueue<A>
Returns an empty MQueue.
override
from<A>(RIterableOnce<A> source) → MQueue<A>
Creates an MQueue from a RIterableOnce, preserving order.
override