LinkedTransferQueue

LinkedTransferQueue

LinkedTransferQueue()

Creates an initially empty LinkedTransferQueue.

LinkedTransferQueue

LinkedTransferQueue(c: MutableCollection<out E>!)

Creates a LinkedTransferQueue initially containing the elements of the given collection, added in traversal order of the collection's iterator.

add

open fun add(element: E): Boolean

Inserts the specified element at the tail of this queue. As the queue is unbounded, this method will never throw IllegalStateException or return false.

clear

open fun clear(): Unit

contains

open fun contains(element: E?): Boolean

Returns true if this queue contains the specified element. More formally, returns true if and only if this queue contains at least one element e such that o.equals(e).

drainTo

open fun drainTo(c: MutableCollection<in E>!): Int

drainTo

open fun drainTo(
    c: MutableCollection<in E>!, 
    maxElements: Int
): Int

forEach

open fun forEach(action: Consumer<in E>): Unit

getWaitingConsumerCount

open fun getWaitingConsumerCount(): Int

hasWaitingConsumer

open fun hasWaitingConsumer(): Boolean

isEmpty

open fun isEmpty(): Boolean

Returns true if this queue contains no elements.

iterator

open fun iterator(): MutableIterator<E>

Returns an iterator over the elements in this queue in proper sequence. The elements will be returned in order from first (head) to last (tail).

The returned iterator is weakly consistent.

offer

open fun offer(
    e: E, 
    timeout: Long, 
    unit: TimeUnit!
): Boolean

Inserts the specified element at the tail of this queue. As the queue is unbounded, this method will never block or return false.

offer

open fun offer(e: E): Boolean

Inserts the specified element at the tail of this queue. As the queue is unbounded, this method will never return false.

peek

open fun peek(): E?

poll

open fun poll(
    timeout: Long, 
    unit: TimeUnit!
): E

poll

open fun poll(): E?

put

open fun put(e: E): Unit

Inserts the specified element at the tail of this queue. As the queue is unbounded, this method will never block.

remainingCapacity

open fun remainingCapacity(): Int

Always returns Integer.MAX_VALUE because a LinkedTransferQueue is not capacity constrained.

remove

open fun remove(element: E?): Boolean

Removes a single instance of the specified element from this queue, if it is present. More formally, removes an element e such that o.equals(e), if this queue contains one or more such elements. Returns true if this queue contained the specified element (or equivalently, if this queue changed as a result of the call).

removeAll

open fun removeAll(elements: Collection<E>): Boolean

removeIf

open fun removeIf(filter: Predicate<in E>): Boolean

retainAll

open fun retainAll(elements: Collection<E>): Boolean

spliterator

open fun spliterator(): Spliterator<E>

Returns a Spliterator over the elements in this queue.

The returned spliterator is weakly consistent.

The Spliterator reports Spliterator#CONCURRENT, Spliterator#ORDERED, and Spliterator#NONNULL.

take

open fun take(): E

toArray

open fun toArray(): Array<Any!>

Returns an array containing all of the elements in this queue, in proper sequence.

The returned array will be "safe" in that no references to it are maintained by this queue. (In other words, this method must allocate a new array). The caller is thus free to modify the returned array.

This method acts as bridge between array-based and collection-based APIs.

toArray

open fun <T : Any!> toArray(a: Array<T>): Array<T>

Returns an array containing all of the elements in this queue, in proper sequence; the runtime type of the returned array is that of the specified array. If the queue fits in the specified array, it is returned therein. Otherwise, a new array is allocated with the runtime type of the specified array and the size of this queue.

If this queue fits in the specified array with room to spare (i.e., the array has more elements than this queue), the element in the array immediately following the end of the queue is set to null.

Like the toArray() method, this method acts as bridge between array-based and collection-based APIs. Further, this method allows precise control over the runtime type of the output array, and may, under certain circumstances, be used to save allocation costs.

Suppose x is a queue known to contain only strings. The following code can be used to dump the queue into a newly allocated array of String:

<code>String[] y = x.toArray(new String[0]);</code>

toString

open fun toString(): String

transfer

open fun transfer(e: E): Unit

Transfers the element to a consumer, waiting if necessary to do so.

More precisely, transfers the specified element immediately if there exists a consumer already waiting to receive it (in take or timed poll), else inserts the specified element at the tail of this queue and waits until the element is received by a consumer.

tryTransfer

open fun tryTransfer(e: E): Boolean

Transfers the element to a waiting consumer immediately, if possible.

More precisely, transfers the specified element immediately if there exists a consumer already waiting to receive it (in take or timed poll), otherwise returning false without enqueuing the element.

tryTransfer

open fun tryTransfer(
    e: E, 
    timeout: Long, 
    unit: TimeUnit!
): Boolean

Transfers the element to a consumer if it is possible to do so before the timeout elapses.

More precisely, transfers the specified element immediately if there exists a consumer already waiting to receive it (in take or timed poll), else inserts the specified element at the tail of this queue and waits until the element is received by a consumer, returning false if the specified wait time elapses before the element can be transferred.

size

open val size: Int

Returns the number of elements in this queue. If this queue contains more than Integer.MAX_VALUE elements, returns Integer.MAX_VALUE.

Beware that, unlike in most collections, this method is NOT a constant-time operation. Because of the asynchronous nature of these queues, determining the current number of elements requires an O(n) traversal.