net.yacy.cora.sorting

Class WeakPriorityBlockingQueue<E>

java.lang.Object

net.yacy.cora.sorting.WeakPriorityBlockingQueue<E>

All Implemented Interfaces:

java.io.Serializable

public class WeakPriorityBlockingQueue<E>
extends java.lang.Object
implements java.io.Serializable

implements a stack where elements 'float' on-top of the stack according to a weight value. objects pushed on the stack must implement the hashCode() method to provide a handle for a double-check. If the queue gets larger that the given maxsize, then elements from the tail of the queue are drained (deleted).

See Also:

Serialized Form

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
private static class	WeakPriorityBlockingQueue.AbstractElement<E>
static interface	WeakPriorityBlockingQueue.Element<E>
static class	WeakPriorityBlockingQueue.NaturalElement<E> natural ordering elements, can be used as container of objects in the priority queue the elements with smallest ordering weights are first in the queue when elements are taken
static class	WeakPriorityBlockingQueue.ReverseElement<E> reverse ordering elements, can be used as container of objects in the priority queue the elements with highest ordering weights are first in the queue when elements are taken

Field Summary

Fields

Modifier and Type	Field and Description
private java.util.ArrayList<WeakPriorityBlockingQueue.Element<E>>	drained
private java.util.concurrent.Semaphore	enqueued
private int	maxsize
private java.util.TreeSet<WeakPriorityBlockingQueue.Element<E>>	queue
private static long	serialVersionUID

Constructor Summary

Constructors

Constructor and Description
WeakPriorityBlockingQueue(int maxsize, boolean drain) create a new WeakPriorityBlockingQueue all elements in the stack are not ordered by their insert order but by a given element weight weights that are preferred are returned first when a pop from the stack is made

Method Summary

Methods

Modifier and Type	Method and Description
void	clear() clear the queue
WeakPriorityBlockingQueue.Element<E>	element(int position) all objects that have been returned by poll or take are stored in a back-up list where they can be retrieved afterward.
WeakPriorityBlockingQueue.Element<E>	element(int position, long time) retrieve an element from the drained queue but wait until a timeout until returning null when no element will be available within the time from the input queue
boolean	isEmpty() test if the queue is empty
java.util.Iterator<WeakPriorityBlockingQueue.Element<E>>	iterator() iterate over all elements available.
private java.util.ArrayList<WeakPriorityBlockingQueue.Element<E>>	list() return all entries as they would be retrievable with element()
java.util.ArrayList<WeakPriorityBlockingQueue.Element<E>>	list(int count) return the specific amount of entries as they would be retrievable with element() if count is < 0 then all elements are taken the returned list is not cloned from the internal list and shall not be modified in any way (read-only)
static void	main(java.lang.String[] args)
WeakPriorityBlockingQueue.Element<E>	peek() return the element with the smallest weight, but do not remove it
WeakPriorityBlockingQueue.Element<E>	poll() return the element with the smallest weight and remove it from the stack
WeakPriorityBlockingQueue.Element<E>	poll(long timeout) Retrieves and removes the head of this queue, waiting if necessary up to the specified wait time if no elements are present on this queue.
void	put(WeakPriorityBlockingQueue.Element<E> element) put a element on the stack using a order of the weight elements that had been on the stack cannot be put in again, they are checked against the drained list
int	sizeAvailable() get the number of elements that are available for retrieval this is a combined number of sizeQueue() and sizeDrained();
int	sizeDrained() get the number of elements that had been drained so far and are waiting in a list to get enumerated with element()
int	sizeQueue() get the number of elements in the queue, waiting to be removed with take() or poll()
private WeakPriorityBlockingQueue.Element<E>	takeUnsafe()

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

serialVersionUID

private static final long serialVersionUID

See Also:

Constant Field Values

queue

private final java.util.TreeSet<WeakPriorityBlockingQueue.Element<E>> queue

enqueued

private final java.util.concurrent.Semaphore enqueued

drained

private final java.util.ArrayList<WeakPriorityBlockingQueue.Element<E>> drained

maxsize

private int maxsize

Constructor Detail

WeakPriorityBlockingQueue

public WeakPriorityBlockingQueue(int maxsize,
                         boolean drain)

create a new WeakPriorityBlockingQueue all elements in the stack are not ordered by their insert order but by a given element weight weights that are preferred are returned first when a pop from the stack is made

Parameters:

maxsize - the maximum size of the stack. When the stack exceeds this number, then entries are removed

Method Detail

clear

public void clear()

clear the queue

isEmpty

public boolean isEmpty()

test if the queue is empty

Returns:

true if the queue is empty, false if not

sizeQueue

public int sizeQueue()

get the number of elements in the queue, waiting to be removed with take() or poll()

Returns:

sizeDrained

public int sizeDrained()

get the number of elements that had been drained so far and are waiting in a list to get enumerated with element()

Returns:

sizeAvailable

public int sizeAvailable()

get the number of elements that are available for retrieval this is a combined number of sizeQueue() and sizeDrained();

Returns:

put

public void put(WeakPriorityBlockingQueue.Element<E> element)

put a element on the stack using a order of the weight elements that had been on the stack cannot be put in again, they are checked against the drained list

Parameters:

element - the element (must have a equals() method)

weight - the weight of the element

remove - - the rating of the element that shall be removed in case that the stack has an size overflow

poll

public WeakPriorityBlockingQueue.Element<E> poll()

return the element with the smallest weight and remove it from the stack

Returns:

null if no element is on the queue or the head of the queue

poll

public WeakPriorityBlockingQueue.Element<E> poll(long timeout)
                                          throws java.lang.InterruptedException

Retrieves and removes the head of this queue, waiting if necessary up to the specified wait time if no elements are present on this queue.

Parameters:

timeout - milliseconds until timeout

Returns:

the head element from the queue

Throws:

java.lang.InterruptedException

takeUnsafe

private WeakPriorityBlockingQueue.Element<E> takeUnsafe()

peek

public WeakPriorityBlockingQueue.Element<E> peek()

return the element with the smallest weight, but do not remove it

Returns:

null if no element is on the queue or the head of the queue

element

public WeakPriorityBlockingQueue.Element<E> element(int position)

all objects that have been returned by poll or take are stored in a back-up list where they can be retrieved afterward. The elements from that list are stored in the specific order as they had been retrieved. This method returns the elements in that specific order and if the list is not large enough, elements available with poll() are taken and written to the list until the required position is written. If the stach size together with the recorded list is not large enough, null is returned

Parameters:

position - inside the drained queue

Returns:

the element from the recorded position or null if that position is not available

element

public WeakPriorityBlockingQueue.Element<E> element(int position,
                                           long time)
                                             throws java.lang.InterruptedException

retrieve an element from the drained queue but wait until a timeout until returning null when no element will be available within the time from the input queue

Parameters:

position - inside the drained queue

time - the timeout

Returns:

the element from the recorded position or null if that position is not available within the timeout

Throws:

java.lang.InterruptedException

list

public java.util.ArrayList<WeakPriorityBlockingQueue.Element<E>> list(int count)

return the specific amount of entries as they would be retrievable with element() if count is < 0 then all elements are taken the returned list is not cloned from the internal list and shall not be modified in any way (read-only)

Parameters:

count -

Returns:

a list of elements in the stack

list

private java.util.ArrayList<WeakPriorityBlockingQueue.Element<E>> list()

return all entries as they would be retrievable with element()

Returns:

a list of all elements in the stack

iterator

public java.util.Iterator<WeakPriorityBlockingQueue.Element<E>> iterator()

iterate over all elements available. All elements that are still in the queue are drained to recorded positions

Returns:

an iterator over all drained positions.

main

public static void main(java.lang.String[] args)