DoublePriorityQueue (Primitive-Collections 0.7.0 API)

All Superinterfaces:

DoubleIterable, java.lang.Iterable<java.lang.Double>

All Known Subinterfaces:

DoublePriorityDequeue

All Known Implementing Classes:

AbstractDoublePriorityQueue, DoubleArrayFIFOQueue, DoubleArrayPriorityQueue, DoubleHeapPriorityQueue, DoubleLinkedList, DoublePriorityQueues.SynchronizedPriorityDequeue, DoublePriorityQueues.SynchronizedPriorityQueue
```
public interface DoublePriorityQueue
extends DoubleIterable
```
A Simple PriorityQueue (or Queue) interface that provides with the nessesary functions to interact with it, without cluttering with the Collection interface.

Method Summary

All Methods Instance Methods Abstract Methods Default Methods
Modifier and Type	Method and Description
`void`	`clear()` clears all elements within the PriorityQueue, this does not resize the backing arrays
`DoubleComparator`	`comparator()`
`DoublePriorityQueue`	`copy()` A Function that does a shallow clone of the PriorityQueue itself.
`double`	`dequeue()` Method to extract a element from the PriorityQueue
`void`	`enqueue(double e)` Method to insert a element into the PriorityQueue
`default void`	`enqueueAll(double... e)` Method to mass insert elements into the PriorityQueue
`default void`	`enqueueAll(double[] e, int length)` Method to mass insert elements into the PriorityQueue
`default void`	`enqueueAll(double[] e, int offset, int length)` Method to mass insert elements into the PriorityQueue
`default void`	`enqueueAll(DoubleCollection c)` Method to mass insert elements into the PriorityQueue
`default double`	`first()` Shows the element that is to be returned next
`default boolean`	`isEmpty()`
`void`	`onChanged()` Allows to notify the Queue to be revalidate its data
`double`	`peek(int index)` Peeking function to see whats inside the queue.
`boolean`	`removeFirst(double e)` Removes the first found element in the queue
`boolean`	`removeLast(double e)` Removes the last found element in the queue
`int`	`size()`
`default DoublePriorityQueue`	`synchronizeQueue()` Creates a Wrapped PriorityQueue that is Synchronized
`default DoublePriorityQueue`	`synchronizeQueue(java.lang.Object mutex)` Creates a Wrapped PriorityQueue that is Synchronized
`default double[]`	`toDoubleArray()` A method to drop the contents of the Queue without clearing the queue
`double[]`	`toDoubleArray(double[] input)` A method to drop the contents of the Queue without clearing the queue

Methods inherited from interface speiger.src.collections.doubles.collections.DoubleIterable
arrayflatMap, asAsync, count, distinct, filter, findFirst, flatMap, forEach, forEach, forEach, iterator, limit, map, matchesAll, matchesAny, matchesNone, peek, pour, pourAsList, pourAsSet, reduce, reduce, sorted, spliterator

- Method Detail
  - isEmpty
```
default boolean isEmpty()
```
    Returns:
    
    true if the PriorityQueue is empty
  - size
```
int size()
```
    Returns:
    
    the amount of elements that are stored in the PriorityQueue
  - clear
```
void clear()
```
    clears all elements within the PriorityQueue, this does not resize the backing arrays
  - enqueue
```
void enqueue(double e)
```
    Method to insert a element into the PriorityQueue
    
    Parameters:
    
    e - the element that should be inserted
  - enqueueAll
```
default void enqueueAll(double... e)
```
    Method to mass insert elements into the PriorityQueue
    
    Parameters:
    
    e - the elements that should be inserted
  - enqueueAll
```
default void enqueueAll(double[] e,
                        int length)
```
    Method to mass insert elements into the PriorityQueue
    
    Parameters:
    
    e - the elements that should be inserted
    
    length - the amount of elements that should be inserted
  - enqueueAll
```
default void enqueueAll(double[] e,
                        int offset,
                        int length)
```
    Method to mass insert elements into the PriorityQueue
    
    Parameters:
    
    e - the elements that should be inserted
    
    offset - the offset where in the array should be started
    
    length - the amount of elements that should be inserted
  - enqueueAll
```
default void enqueueAll(DoubleCollection c)
```
    Method to mass insert elements into the PriorityQueue
    
    Parameters:
    
    c - the elements that should be inserted from the Collection
  - dequeue
```
double dequeue()
```
    Method to extract a element from the PriorityQueue
    
    Returns:
    
    a element from the Queue
    
    Throws:
    
    java.util.NoSuchElementException - if no element is present
  - peek
```
double peek(int index)
```
    Peeking function to see whats inside the queue.
    
    Parameters:
    
    index - of the element that is requested to be viewed.
    
    Returns:
    
    the element that is requested
  - first
```
default double first()
```
    Shows the element that is to be returned next
    
    Returns:
    
    the first element in the Queue
  - removeFirst
```
boolean removeFirst(double e)
```
    Removes the first found element in the queue
    
    Parameters:
    
    e - the element that should be removed
    
    Returns:
    
    if a searched element was removed
  - removeLast
```
boolean removeLast(double e)
```
    Removes the last found element in the queue
    
    Parameters:
    
    e - the element that should be removed
    
    Returns:
    
    if a searched element was removed
  - onChanged
```
void onChanged()
```
    Allows to notify the Queue to be revalidate its data
  - copy
```
DoublePriorityQueue copy()
```
    A Function that does a shallow clone of the PriorityQueue itself. This function is more optimized then a copy constructor since the PriorityQueue does not have to be unsorted/resorted. It can be compared to Cloneable but with less exception risk
    
    Returns:
    
    a Shallow Copy of the PriorityQueue
    
    Note:
    
    Wrappers and view PriorityQueues will not support this feature
  - comparator
```
DoubleComparator comparator()
```
    Returns:
    
    the sorter of the Queue, can be null
  - synchronizeQueue
```
default DoublePriorityQueue synchronizeQueue()
```
    Creates a Wrapped PriorityQueue that is Synchronized
    
    Returns:
    
    a new PriorityQueue that is synchronized
    
    See Also:
    
    DoublePriorityQueues.synchronize(speiger.src.collections.doubles.queues.DoublePriorityQueue)
  - synchronizeQueue
```
default DoublePriorityQueue synchronizeQueue(java.lang.Object mutex)
```
    Creates a Wrapped PriorityQueue that is Synchronized
    
    Parameters:
    
    mutex - is the controller of the synchronization block
    
    Returns:
    
    a new PriorityQueue Wrapper that is synchronized
    
    See Also:
    
    DoublePriorityQueues.synchronize(speiger.src.collections.doubles.queues.DoublePriorityQueue)
  - toDoubleArray
```
default double[] toDoubleArray()
```
    A method to drop the contents of the Queue without clearing the queue
    
    Returns:
    
    the contents of the queue into a seperate array.
  - toDoubleArray
```
double[] toDoubleArray(double[] input)
```
    A method to drop the contents of the Queue without clearing the queue
    
    Parameters:
    
    input - where the elements should be inserted to. If it does not fit then it creates a new appropiatly created array
    
    Returns:
    
    the contents of the queue into a seperate array.
    
    Note:
    
    if the Type is generic then a Object Array is created instead of a Type Array

Interface DoublePriorityQueue

Method Summary

Methods inherited from interface speiger.src.collections.doubles.collections.DoubleIterable

Method Detail

isEmpty

size

clear

enqueue

enqueueAll

enqueueAll

enqueueAll

enqueueAll

dequeue

peek

first

removeFirst

removeLast

onChanged

copy

comparator

synchronizeQueue

synchronizeQueue

toDoubleArray

toDoubleArray