org.daisy.common.priority

Class UpdatablePriorityBlockingQueue<T>

java.lang.Object

com.google.common.collect.ForwardingObject

com.google.common.collect.ForwardingCollection<E>

com.google.common.collect.ForwardingQueue<E>

com.google.common.util.concurrent.ForwardingBlockingQueue<Runnable>

org.daisy.common.priority.UpdatablePriorityBlockingQueue<T>

All Implemented Interfaces:

Iterable<Runnable>, Collection<Runnable>, BlockingQueue<Runnable>, Queue<Runnable>

public class UpdatablePriorityBlockingQueue<T>
extends ForwardingBlockingQueue<Runnable>

This class adds a layer to a forwarded PriorityBlockingQueue that allows to update the order based on a priority or via the provided methods.

Updating the priorities

• #update(Function function): Updates the priorities by applying the given function sequentially to the different priorities. The function has update the PrioritizableRunnable by reference. This function is threadsafe
• #swap(PrioritizableRunnable runnable) allows to swap two elements in the queue

The internal design might seem a bit over-engineered but there are some reasons for that. ThreadPoolExecutorSevice needs a queue which has to be of type Runnable. Our needs are a bit more complex than that, so we have to "hide" the actual internal type of our objects a give a Runnable view to the superclass. This forces some unchecked type conversions that are safe ONLY when interacting with PrioritizableRunnables. Also we have to cope with the possibility of swapping elements in the queue. This is done more or less elegantly by the tuple SwappingPriority and WrappingPriorityQueue, which allow to hide the element wrapping process and return priorities of other elements as if they were its own. This class is threadsafe

Version:

1.0

Constructor Summary

Constructors

Constructor and Description
UpdatablePriorityBlockingQueue() Creates a new UpdatablePriorityBlockingQueue, it has infiniteinfiniteinfiniteinfiniteinfinite capacity.

Method Summary

Modifier and Type	Method and Description
boolean	add(Runnable element) See java.util.concurrent.BlockingQueue#add(), This method may block if the queue is being updated.
Collection<PrioritizableRunnable<T>>	asCollection() Returns the runnables as an immutable Collection without maintaining the order given by the priority
Collection<PrioritizableRunnable<T>>	asOrderedCollection() Returns the runnables as an immutable Collection maintaining the order given by the priority
protected BlockingQueue<Runnable>	delegate() Returns this forwarding class delegate
boolean	offer(Runnable o) See java.util.concurrent.BlockingQueue#offer(), This method may block if the queue is being updated.
void	swap(PrioritizableRunnable<T> runnable1, PrioritizableRunnable<T> runnable2) Swap the priorities of both PrioritizableRunnable objects to change the order in the queue
Runnable	take() See BlockingQueue.take(), it also waits for any updating operations to finish.
protected Optional<org.daisy.common.priority.SwappingPriority<T>>	tryFind(PrioritizableRunnable<T> runnable) Tries to find the runnable among the elements in the queue.
void	update(Function<PrioritizableRunnable<T>,Void> function) Applies the function to all the elements in the queue.

Methods inherited from class com.google.common.util.concurrent.ForwardingBlockingQueue

drainTo, drainTo, offer, poll, put, remainingCapacity

Methods inherited from class com.google.common.collect.ForwardingQueue

element, peek, poll, remove, standardOffer, standardPeek, standardPoll

Methods inherited from class com.google.common.collect.ForwardingCollection

addAll, clear, contains, containsAll, isEmpty, iterator, remove, removeAll, retainAll, size, standardAddAll, standardClear, standardContains, standardContainsAll, standardIsEmpty, standardRemove, standardRemoveAll, standardRetainAll, standardToArray, standardToArray, standardToString, toArray, toArray

Methods inherited from class com.google.common.collect.ForwardingObject

toString

Methods inherited from class java.lang.Object

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

Methods inherited from interface java.util.concurrent.BlockingQueue

contains, remove

Methods inherited from interface java.util.Queue

element, peek, poll, remove

Methods inherited from interface java.util.Collection

addAll, clear, containsAll, equals, hashCode, isEmpty, iterator, parallelStream, removeAll, removeIf, retainAll, size, spliterator, stream, toArray, toArray

Methods inherited from interface java.lang.Iterable

forEach

Constructor Detail

UpdatablePriorityBlockingQueue

public UpdatablePriorityBlockingQueue()

Creates a new UpdatablePriorityBlockingQueue, it has infinite^{infiniteinfiniteinfiniteinfinite} capacity.

Method Detail

tryFind

protected Optional<org.daisy.common.priority.SwappingPriority<T>> tryFind(PrioritizableRunnable<T> runnable)

Tries to find the runnable among the elements in the queue.

swap

public void swap(PrioritizableRunnable<T> runnable1,
                 PrioritizableRunnable<T> runnable2)

Swap the priorities of both PrioritizableRunnable objects to change the order in the queue

update

public void update(Function<PrioritizableRunnable<T>,Void> function)

Applies the function to all the elements in the queue. The function must change the objects by reference. Once the function has been applied the queue is reordered. This function is threadsafe

Parameters:

function -

asOrderedCollection

public Collection<PrioritizableRunnable<T>> asOrderedCollection()

Returns the runnables as an immutable Collection maintaining the order given by the priority

asCollection

public Collection<PrioritizableRunnable<T>> asCollection()

Returns the runnables as an immutable Collection without maintaining the order given by the priority

delegate

protected BlockingQueue<Runnable> delegate()

Returns this forwarding class delegate

Overrides:

delegate in class ForwardingBlockingQueue<Runnable>

Returns:

offer

public boolean offer(Runnable o)

See java.util.concurrent.BlockingQueue#offer(), This method may block if the queue is being updated.

Specified by:

offer in interface BlockingQueue<Runnable>

Specified by:

offer in interface Queue<Runnable>

Overrides:

offer in class ForwardingQueue<Runnable>

add

public boolean add(Runnable element)

See java.util.concurrent.BlockingQueue#add(), This method may block if the queue is being updated.

Specified by:

add in interface Collection<Runnable>

Specified by:

add in interface BlockingQueue<Runnable>

Specified by:

add in interface Queue<Runnable>

Overrides:

add in class ForwardingCollection<Runnable>

take

public Runnable take()
              throws InterruptedException

See BlockingQueue.take(), it also waits for any updating operations to finish.

Specified by:

take in interface BlockingQueue<Runnable>

Overrides:

take in class ForwardingBlockingQueue<Runnable>

Throws:

InterruptedException