tmp/ariane-old-core/src/main/java/com/assembla/ariane/jellyfish/util/collections/queue/RequestQueue.java

   1 /*******************************************************************************
   2  * Copyright 2012 Fat Cat
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *   http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  ******************************************************************************/
  16 package com.assembla.ariane.jellyfish.util.collections.queue;
  17
  18 import java.util.Iterator;
  19 import java.util.NoSuchElementException;
  20 import java.util.concurrent.BlockingQueue;
  21 import java.util.concurrent.LinkedBlockingQueue;
  22 import java.util.concurrent.TimeUnit;
  23 import org.slf4j.Logger;
  24 import org.slf4j.LoggerFactory;
  25
  26 /**
  27  * Class that represents an queue of requests.
  28  * @author Fat Cat
  29  * @param <Request> The request type.
  30  * @version 2
  31  * @since 0.0.3
  32  */
  33 public class RequestQueue< Request >
  34 {
  35   /** An list of messages to process. */
  36   private final BlockingQueue< Request > sender;
  37
  38   /** The size of the request queue.*/
  39   private int size;
  40
  41   /** The logger to use. */
  42   private Logger logger;
  43
  44   /**
  45    * Creates a new request queue given it's size.
  46    * @param size The size of the queue.
  47    */
  48   public RequestQueue( final int size )
  49   {
  50     this.sender = new LinkedBlockingQueue< Request >( size );
  51     this.size = size;
  52     this.logger = LoggerFactory.getLogger( RequestQueue.class );
  53   }
  54
  55   /**
  56    * Adds a new request to the queue.
  57    * @param request The request to add
  58    * @throws IllegalStateException Exception raised if the request could not be
  59    *   added due to problems with the queue size.
  60    */
  61   public void add( final Request request ) throws IllegalStateException
  62   {
  63     this.logger.debug( "Adding a new request." );
  64     if ( !this.sender.contains( request ) )
  65     {
  66       this.sender.add( request );
  67     }
  68   }
  69
  70   /**
  71    * Clears the request queue.
  72    */
  73   public void clear( )
  74   {
  75     this.logger.debug( "Clearing all the requests." );
  76     this.sender.clear( );
  77   }
  78
  79   /**
  80    * Checks if the queue contains the given request.
  81    * @param request the request to check for.
  82    * @return true, if successful.
  83    */
  84   public boolean contains( final Request request )
  85   {
  86     return this.sender.contains( request );
  87   }
  88
  89   /**
  90    * Retrieves the element at the head of this queue, without removing it.
  91    * @return The head element of this queue.
  92    */
  93   public Request element( )
  94   {
  95     return this.sender.element( );
  96   }
  97
  98   /**
  99    * Checks if the requests queue is empty.
 100    * @return true, if is empty.
 101    */
 102   public boolean isEmpty( )
 103   {
 104     return this.sender.isEmpty( );
 105   }
 106
 107   /**
 108    * Returns the iterator to iterate the request queue.
 109    * @return The requests queue iterator.
 110    */
 111   public Iterator< Request > iterator( )
 112   {
 113     return this.sender.iterator( );
 114   }
 115
 116   /**
 117    * Adds an element to this queue and returns whether or not is was added.
 118    * @param e The request to add.
 119    * @return true, if successful.
 120    */
 121   public boolean offer( final Request e )
 122   {
 123     this.logger.debug( "Adding a new request." );
 124     return this.sender.offer( e );
 125   }
 126
 127   /**
 128    * Adds the element to this queue and waits until the element
 129    * is successfully inserted.
 130    *
 131    * @param e The request to add.
 132    * @param timeout The maximum waiting time.
 133    * @param unit The unit of the timeout value.
 134    * @return true, if successful.
 135    * @throws InterruptedException If an interrupted exception occurred.
 136    */
 137   public boolean offer( final Request e, final long timeout, final TimeUnit unit ) throws InterruptedException
 138   {
 139     return this.sender.offer( e, timeout, unit );
 140   }
 141
 142   /**
 143    * Retrieves the head of the queue or returns null if it does not exist.
 144    * @return The request in the head of this queue.
 145    */
 146   public Request peek( )
 147   {
 148     return this.sender.peek( );
 149   }
 150
 151   /**
 152    * Retrieves and removes the head of this queue if the queue is not empty.
 153    * @return The request in the head of this queue or null is the queue is empty.
 154    */
 155   public Request poll( )
 156   {
 157     this.logger.debug( "Removing a request." );
 158     return this.sender.poll( );
 159   }
 160
 161   /**
 162    * Retrieves and removes the head of this queue, waiting the
 163    * specified time until the request is available.
 164    *
 165    * @param timeout The maximum waiting time.
 166    * @param unit The unit of the timeout value.
 167    * @return The request in the head or null if the queue is empty.
 168    * @throws InterruptedException If an interrupted exception occurred.
 169    */
 170   public Request poll( final long timeout, final TimeUnit unit ) throws InterruptedException
 171   {
 172     return this.sender.poll( timeout, unit );
 173   }
 174
 175   /**
 176    * Inserts the given request while waiting for space to be available.
 177    * @param e The request to add.
 178    * @throws InterruptedException If an interrupted exception occurred.
 179    */
 180   public void put( final Request e ) throws InterruptedException
 181   {
 182     this.logger.debug( "Adding a request." );
 183     this.sender.put( e );
 184   }
 185
 186   /**
 187    * Returns the number of requests that can be added without
 188    * violating the size dimension of this queue.
 189    * @return The number of remaining requests.
 190    */
 191   public int remainingCapacity( )
 192   {
 193     return this.sender.remainingCapacity( );
 194   }
 195
 196   /**
 197    * Retrieves and removes the request at the head of the queue.
 198    * @return The request at the head.
 199    * @throws NoSuchElementException If there is no available request.
 200    */
 201   public Request remove( ) throws NoSuchElementException
 202   {
 203     this.logger.debug( "Removing a request." );
 204     return this.sender.remove( );
 205   }
 206
 207   /**
 208    * Returns the number of available requests.
 209    * @return The number of available requests.
 210    */
 211   public int count( )
 212   {
 213     return this.sender.size( );
 214   }
 215
 216   /**
 217    * Retrieves and removes the request at the head of the queue,
 218    * waiting the amount of time until the operation is successful.
 219    *
 220    * @return The request at the head of the queue.
 221    * @throws InterruptedException If an interrupted exception occurred.
 222    */
 223   public Request take( ) throws InterruptedException
 224   {
 225     this.logger.debug( "Removing a request." );
 226     return this.sender.take( );
 227   }
 228
 229   /**
 230    * Returns the maximum number of requests in this queue.
 231    * @return The maximum number of queue requests.
 232    */
 233   public int getMaxSize( )
 234   {
 235     return this.size;
 236   }
 237
 238 }