/**@class java.util.concurrent.LinkedBlockingDeque
 implements java.util.concurrent.BlockingDeque

 implements java.io.Serializable

@extends java.util.AbstractQueue

 An optionally-bounded {@linkplain java.util.concurrent.BlockingDeque blocking deque} based on
 linked nodes.

 <p>The optional capacity bound constructor argument serves as a
 way to prevent excessive expansion. The capacity, if unspecified,
 is equal to {@link Integer#MAX_VALUE}.  Linked nodes are
 dynamically created upon each insertion unless this would bring the
 deque above capacity.

 <p>Most operations run in constant time (ignoring time spent
 blocking).  Exceptions include {@link #remove(Object) remove},
 {@link #removeFirstOccurrence removeFirstOccurrence}, {@link #removeLastOccurrence removeLastOccurrence}, {@link #contains
 contains}, {@link #iterator iterator.remove()}, and the bulk
 operations, all of which run in linear time.

 <p>This class and its iterator implement all of the
 <em>optional</em> methods of the {@link Collection} and {@link Iterator} interfaces.

 @since 1.6
 @author  Doug Lea
 @param <E> the type of elements held in this deque
*/
var LinkedBlockingDeque = {

/**
@throws IllegalStateException if this deque is full
@throws NullPointerException {@inheritDoc}
*/
addFirst : function(  ) {},

/**
@throws IllegalStateException if this deque is full
@throws NullPointerException  {@inheritDoc}
*/
addLast : function(  ) {},

/**
@throws NullPointerException {@inheritDoc}
*/
offerFirst : function(  ) {},

/**
@throws NullPointerException {@inheritDoc}
*/
offerLast : function(  ) {},

/**
@throws NullPointerException {@inheritDoc}
@throws InterruptedException {@inheritDoc}
*/
putFirst : function(  ) {},

/**
@throws NullPointerException {@inheritDoc}
@throws InterruptedException {@inheritDoc}
*/
putLast : function(  ) {},

/**
@throws NullPointerException {@inheritDoc}
@throws InterruptedException {@inheritDoc}
*/
offerFirst : function(  ) {},

/**
@throws NullPointerException {@inheritDoc}
@throws InterruptedException {@inheritDoc}
*/
offerLast : function(  ) {},

/**
@throws NoSuchElementException {@inheritDoc}
*/
removeFirst : function(  ) {},

/**
@throws NoSuchElementException {@inheritDoc}
*/
removeLast : function(  ) {},

/**
*/
pollFirst : function(  ) {},

/**
*/
pollLast : function(  ) {},

/**
*/
takeFirst : function(  ) {},

/**
*/
takeLast : function(  ) {},

/**
*/
pollFirst : function(  ) {},

/**
*/
pollLast : function(  ) {},

/**
@throws NoSuchElementException {@inheritDoc}
*/
getFirst : function(  ) {},

/**
@throws NoSuchElementException {@inheritDoc}
*/
getLast : function(  ) {},

/**
*/
peekFirst : function(  ) {},

/**
*/
peekLast : function(  ) {},

/**
*/
removeFirstOccurrence : function(  ) {},

/**
*/
removeLastOccurrence : function(  ) {},

/**Inserts the specified element at the end of this deque unless it would
 violate capacity restrictions.  When using a capacity-restricted deque,
 it is generally preferable to use method {@link #offer(Object) offer}.

 <p>This method is equivalent to {@link #addLast}.
@throws IllegalStateException if this deque is full
@throws NullPointerException if the specified element is null
*/
add : function(  ) {},

/**
@throws NullPointerException if the specified element is null
*/
offer : function(  ) {},

/**
@throws NullPointerException {@inheritDoc}
@throws InterruptedException {@inheritDoc}
*/
put : function(  ) {},

/**
@throws NullPointerException {@inheritDoc}
@throws InterruptedException {@inheritDoc}
*/
offer : function(  ) {},

/**Retrieves and removes the head of the queue represented by this deque.
 This method differs from {@link #poll poll} only in that it throws an
 exception if this deque is empty.

 <p>This method is equivalent to {@link #removeFirst() removeFirst}.
@return {Object {java.lang.Object}} the head of the queue represented by this deque
@throws NoSuchElementException if this deque is empty
*/
remove : function(  ) {},

/**
*/
poll : function(  ) {},

/**
*/
take : function(  ) {},

/**
*/
poll : function(  ) {},

/**Retrieves, but does not remove, the head of the queue represented by
 this deque.  This method differs from {@link #peek peek} only in that
 it throws an exception if this deque is empty.

 <p>This method is equivalent to {@link #getFirst() getFirst}.
@return {Object {java.lang.Object}} the head of the queue represented by this deque
@throws NoSuchElementException if this deque is empty
*/
element : function(  ) {},

/**
*/
peek : function(  ) {},

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

 <p>Note that you <em>cannot</em> always tell if an attempt to insert
 an element will succeed by inspecting {@code remainingCapacity}
 because it may be the case that another thread is about to
 insert or remove an element.
*/
remainingCapacity : function(  ) {},

/**
@throws UnsupportedOperationException {@inheritDoc}
@throws ClassCastException            {@inheritDoc}
@throws NullPointerException          {@inheritDoc}
@throws IllegalArgumentException      {@inheritDoc}
*/
drainTo : function(  ) {},

/**
@throws UnsupportedOperationException {@inheritDoc}
@throws ClassCastException            {@inheritDoc}
@throws NullPointerException          {@inheritDoc}
@throws IllegalArgumentException      {@inheritDoc}
*/
drainTo : function(  ) {},

/**
@throws IllegalStateException if this deque is full
@throws NullPointerException {@inheritDoc}
*/
push : function(  ) {},

/**
@throws NoSuchElementException {@inheritDoc}
*/
pop : function(  ) {},

/**Removes the first occurrence of the specified element from this deque.
 If the deque does not contain the element, it is unchanged.
 More formally, removes the first element {@code e} such that
 {@code o.equals(e)} (if such an element exists).
 Returns {@code true} if this deque contained the specified element
 (or equivalently, if this deque changed as a result of the call).

 <p>This method is equivalent to
 {@link #removeFirstOccurrence(Object) removeFirstOccurrence}.
@param {Object {Object}} o element to be removed from this deque, if present
@return {Boolean} {@code true} if this deque changed as a result of the call
*/
remove : function(  ) {},

/**Returns the number of elements in this deque.
@return {Number} the number of elements in this deque
*/
size : function(  ) {},

/**Returns {@code true} if this deque contains the specified element.
 More formally, returns {@code true} if and only if this deque contains
 at least one element {@code e} such that {@code o.equals(e)}.
@param {Object {Object}} o object to be checked for containment in this deque
@return {Boolean} {@code true} if this deque contains the specified element
*/
contains : function(  ) {},

/**Returns an array containing all of the elements in this deque, in
 proper sequence (from first to last element).

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

 <p>This method acts as bridge between array-based and collection-based
 APIs.
@return {Object {java.lang.Object}} an array containing all of the elements in this deque
*/
toArray : function(  ) {},

/**Returns an array containing all of the elements in this deque, in
 proper sequence; the runtime type of the returned array is that of
 the specified array.  If the deque 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 deque.

 <p>If this deque fits in the specified array with room to spare
 (i.e., the array has more elements than this deque), the element in
 the array immediately following the end of the deque is set to
 {@code null}.

 <p>Like the {@link #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.

 <p>Suppose {@code x} is a deque known to contain only strings.
 The following code can be used to dump the deque into a newly
 allocated array of {@code String}:

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

 Note that {@code toArray(new Object[0])} is identical in function to
 {@code toArray()}.
@param {Object {java.lang.Object[]}} a the array into which the elements of the deque are to
          be stored, if it is big enough; otherwise, a new array of the
          same runtime type is allocated for this purpose
@return {Object {java.lang.Object}} an array containing all of the elements in this deque
@throws ArrayStoreException if the runtime type of the specified array
         is not a supertype of the runtime type of every element in
         this deque
@throws NullPointerException if the specified array is null
*/
toArray : function(  ) {},

/**
*/
toString : function(  ) {},

/**Atomically removes all of the elements from this deque.
 The deque will be empty after this call returns.
*/
clear : function(  ) {},

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

 <p>The returned iterator is
 <a href="package-summary.html#Weakly"><i>weakly consistent</i></a>.
@return {Object {java.util.Iterator}} an iterator over the elements in this deque in proper sequence
*/
iterator : function(  ) {},

/**Returns an iterator over the elements in this deque in reverse
 sequential order.  The elements will be returned in order from
 last (tail) to first (head).

 <p>The returned iterator is
 <a href="package-summary.html#Weakly"><i>weakly consistent</i></a>.
@return {Object {java.util.Iterator}} an iterator over the elements in this deque in reverse order
*/
descendingIterator : function(  ) {},

/**Returns a {@link Spliterator} over the elements in this deque.

 <p>The returned spliterator is
 <a href="package-summary.html#Weakly"><i>weakly consistent</i></a>.

 <p>The {@code Spliterator} reports {@link Spliterator#CONCURRENT},
 {@link Spliterator#ORDERED}, and {@link Spliterator#NONNULL}.
@implNote The {@code Spliterator} implements {@code trySplit} to permit limited
 parallelism.
@return {Object {java.util.Spliterator}} a {@code Spliterator} over the elements in this deque
@since 1.8
*/
spliterator : function(  ) {},


};