Overview  Package   Class  Use  Tree  Deprecated  Index  Help 
 PREV CLASS   NEXT CLASS FRAMES    NO FRAMES    
SUMMARY: NESTED | FIELD | CONSTR | METHOD DETAIL: FIELD | CONSTR | METHOD

com.google.common.util.concurrent
Class ForwardingBlockingQueue<E>

java.lang.Object
  extended by com.google.common.collect.ForwardingObject
      extended by com.google.common.collect.ForwardingCollection<E>
          extended by com.google.common.collect.ForwardingQueue<E>
              extended by com.google.common.util.concurrent.ForwardingBlockingQueue<E>
Type Parameters:
E - the type of elements held in this collection
All Implemented Interfaces:
Iterable<E>, Collection<E>, BlockingQueue<E>, Queue<E>
public abstract class ForwardingBlockingQueue<E>
extends ForwardingQueue<E>
implements BlockingQueue<E>

A BlockingQueue which forwards all its method calls to another BlockingQueue. Subclasses should override one or more methods to modify the behavior of the backing collection as desired per the decorator pattern.

Since:
4
Author:
Raimundo Mirisola

Constructor Summary
protected ForwardingBlockingQueue()
          Constructor for use by subclasses.
 
Method Summary
protected abstract  BlockingQueue<E> delegate()
          Returns the backing delegate instance that methods are forwarded to.
 int drainTo(Collection<? super E> c)
          Removes all available elements from this queue and adds them to the given collection.
 int drainTo(Collection<? super E> c, int maxElements)
          Removes at most the given number of available elements from this queue and adds them to the given collection.
 boolean offer(E e, long timeout, TimeUnit unit)
          Inserts the specified element into this queue, waiting up to the specified wait time if necessary for space to become available.
 E poll(long timeout, TimeUnit unit)
          Retrieves and removes the head of this queue, waiting up to the specified wait time if necessary for an element to become available.
 void put(E e)
          Inserts the specified element into this queue, waiting if necessary for space to become available.
 int remainingCapacity()
          Returns the number of additional elements that this queue can ideally (in the absence of memory or resource constraints) accept without blocking, or Integer.MAX_VALUE if there is no intrinsic limit.
 E take()
          Retrieves and removes the head of this queue, waiting if necessary until an element becomes available.
 
Methods inherited from class com.google.common.collect.ForwardingQueue
element, offer, peek, poll, remove, standardOffer, standardPeek, standardPoll
 
Methods inherited from class com.google.common.collect.ForwardingCollection
add, 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
add, contains, offer, 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, removeAll, retainAll, size, toArray, toArray
 

Constructor Detail

ForwardingBlockingQueue

protected ForwardingBlockingQueue()
Constructor for use by subclasses.

Method Detail

delegate

protected abstract BlockingQueue<E> delegate()
Description copied from class: ForwardingObject
Returns the backing delegate instance that methods are forwarded to. Abstract subclasses generally override this method with an abstract method that has a more specific return type, such as ForwardingSet.delegate(). Concrete subclasses override this method to supply the instance being decorated.

Specified by:
delegate in class ForwardingQueue<E>

drainTo

public int drainTo(Collection<? super E> c,
                   int maxElements)
Description copied from interface: java.util.concurrent.BlockingQueue
Removes at most the given number of available elements from this queue and adds them to the given collection. A failure encountered while attempting to add elements to collection c may result in elements being in neither, either or both collections when the associated exception is thrown. Attempts to drain 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.

Specified by:
drainTo in interface BlockingQueue<E>
Parameters:
c - the collection to transfer elements into
maxElements - the maximum number of elements to transfer
Returns:
the number of elements transferred

drainTo

public int drainTo(Collection<? super E> c)
Description copied from interface: java.util.concurrent.BlockingQueue
Removes all available elements from this queue and adds them to the given collection. This operation may be more efficient than repeatedly polling this queue. A failure encountered while attempting to add elements to collection c may result in elements being in neither, either or both collections when the associated exception is thrown. Attempts to drain 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.

Specified by:
drainTo in interface BlockingQueue<E>
Parameters:
c - the collection to transfer elements into
Returns:
the number of elements transferred

offer

public boolean offer(E e,
                     long timeout,
                     TimeUnit unit)
              throws InterruptedException
Description copied from interface: java.util.concurrent.BlockingQueue
Inserts the specified element into this queue, waiting up to the specified wait time if necessary for space to become available.

Specified by:
offer in interface BlockingQueue<E>
Parameters:
e - the element to add
timeout - how long to wait before giving up, in units of unit
unit - a TimeUnit determining how to interpret the timeout parameter
Returns:
true if successful, or false if the specified waiting time elapses before space is available
Throws:
InterruptedException - if interrupted while waiting

poll

public E poll(long timeout,
              TimeUnit unit)
       throws InterruptedException
Description copied from interface: java.util.concurrent.BlockingQueue
Retrieves and removes the head of this queue, waiting up to the specified wait time if necessary for an element to become available.

Specified by:
poll in interface BlockingQueue<E>
Parameters:
timeout - how long to wait before giving up, in units of unit
unit - a TimeUnit determining how to interpret the timeout parameter
Returns:
the head of this queue, or null if the specified waiting time elapses before an element is available
Throws:
InterruptedException - if interrupted while waiting

put

public void put(E e)
         throws InterruptedException
Description copied from interface: java.util.concurrent.BlockingQueue
Inserts the specified element into this queue, waiting if necessary for space to become available.

Specified by:
put in interface BlockingQueue<E>
Parameters:
e - the element to add
Throws:
InterruptedException - if interrupted while waiting

remainingCapacity

public int remainingCapacity()
Description copied from interface: java.util.concurrent.BlockingQueue
Returns the number of additional elements that this queue can ideally (in the absence of memory or resource constraints) accept without blocking, or Integer.MAX_VALUE if there is no intrinsic limit.

Note that you cannot always tell if an attempt to insert an element will succeed by inspecting remainingCapacity because it may be the case that another thread is about to insert or remove an element.

Specified by:
remainingCapacity in interface BlockingQueue<E>
Returns:
the remaining capacity

take

public E take()
       throws InterruptedException
Description copied from interface: java.util.concurrent.BlockingQueue
Retrieves and removes the head of this queue, waiting if necessary until an element becomes available.

Specified by:
take in interface BlockingQueue<E>
Returns:
the head of this queue
Throws:
InterruptedException - if interrupted while waiting
Overview  Package   Class  Use  Tree  Deprecated  Index  Help 
 PREV CLASS   NEXT CLASS FRAMES    NO FRAMES    
SUMMARY: NESTED | FIELD | CONSTR | METHOD DETAIL: FIELD | CONSTR | METHOD