core/org.gnit.lucenekmp.jdkport/LinkedBlockingQueue

LinkedBlockingQueue

open class LinkedBlockingQueue<E>(capacity: Int = Int.MAX_VALUE) : AbstractQueue<E> , BlockingQueue<E>

Constructors

constructor(capacity: Int = Int.MAX_VALUE)

Creates a LinkedBlockingQueue with a capacity of Integer.MAX_VALUE, initially containing the elements of the given collection, added in traversal order of the collection's iterator.

Types

Node

class Node<E>(var item: E?)

Linked list node class.

Properties

head

@Transient

var head: LinkedBlockingQueue.Node<E>?

Head of linked list. Invariant: head.item == null

isBounded

val isBounded: Boolean

size

open override val size: Int

Returns the number of elements in this queue.

Functions

add

open override fun add(e: E): Boolean

Inserts the specified element into this queue if it is possible to do so immediately without violating capacity restrictions, returning true upon success and throwing an IllegalStateException if no space is currently available.

addAll

open override fun addAll(c: Collection<E>): Boolean

Adds all of the elements in the specified collection to this queue. Attempts to addAll of a queue to itself result in IllegalArgumentException. Further, the behavior of this operation is undefined if the specified collection is modified while the operation is in progress.

clear

open override fun clear()

Atomically removes all of the elements from this queue. The queue will be empty after this call returns.

contains

open operator override fun contains(o: 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).

containsAll

open override fun containsAll(elements: Collection<E>): Boolean

drainTo

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

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

element

open override fun element(): E

Retrieves, but does not remove, the head of this queue. This method differs from .peek only in that it throws an exception if this queue is empty.

findPred

fun findPred(p: LinkedBlockingQueue.Node<E>, ancestor: LinkedBlockingQueue.Node<E>): LinkedBlockingQueue.Node<E>?

Returns the predecessor of live node p, given a node that was once a live ancestor of p (or head); allows unlinking of p.

forEach

fun forEach(action: (E) -> Unit)

forEachFrom

fun forEachFrom(action: (E) -> Unit, p: LinkedBlockingQueue.Node<E>?)

Runs action on each element found during a traversal starting at p. If p is null, traversal starts at head.

isEmpty

open override fun isEmpty(): Boolean

iterator

open operator override 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).

offer

open override fun offer(e: E): Boolean

Inserts the specified element at the tail of this queue if it is possible to do so immediately without exceeding the queue's capacity, returning true upon success and false if this queue is full. When using a capacity-restricted queue, this method is generally preferable to method add, which can fail to insert an element only by throwing an exception.

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

Inserts the specified element at the tail of this queue, waiting if necessary up to the specified wait time for space to become available.

peek

open override fun peek(): E?

Retrieves, but does not remove, the head of this queue, or returns null if this queue is empty.

poll

open override fun poll(): E?

Retrieves and removes the head of this queue, or returns null if this queue is empty.

open suspend override fun poll(timeout: Long, unit: TimeUnit): E?

Retrieves and removes the head of this queue, waiting up to the specified wait time if necessary for an element to become available.

put

open suspend override fun put(e: E)

Inserts the specified element at the tail of this queue, waiting if necessary for space to become available.

remainingCapacity

open override fun remainingCapacity(): Int

Returns the number of additional elements that this queue can ideally (in the absence of memory or resource constraints) accept without blocking. This is always equal to the initial capacity of this queue less the current size of this queue.

remove

open override fun remove(): E

Retrieves and removes the head of this queue. This method differs from .poll only in that it throws an exception if this queue is empty.

open override fun remove(o: 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