/*
    * Created on May 12, 2004
    *
    */
   package org.neo.swarm.interceptor.asyncQueue;
   
   import org.aopalliance.intercept.MethodInvocation;
   import org.neo.swarm.core.aop.silc.comp.MethodInterceptor;
   
  import EDU.oswego.cs.dl.util.concurrent.BoundedLinkedQueue;
  
  /***
   * This object does..
   * 
   * @author navery
   */
  public class AsyncInterceptor implements MethodInterceptor {
  
  	BoundedLinkedQueue eventQueue;
  
  	AsyncInterceptor(int queueSize) {
  		eventQueue = new BoundedLinkedQueue(queueSize);
  		Thread eventQueue = new EventFeed();
  		eventQueue.start();
  	}
  
  	/***
  	 * @return Returns the queueSize.
  	 */
  	public int getQueueSize() {
  		return eventQueue.capacity();
  	}
  
  	/***
  	 *   The queueSize to set.
  	 * @param queueSize
  	 */
  	public void setQueueSize(int queueSize) {
  		// change the size of the queue, doesnt dump existing entries, but will force new puts to wait until capacity is sufficient
  		eventQueue.setCapacity(queueSize);
  	}
  
  	public Object invoke(MethodInvocation invocation) throws Throwable {
  		// raise warning log if event queue is full..
  		if (eventQueue.size() == eventQueue.capacity()) {
  			//LOG.info("event queue full:" + eventQueue.capacity());
  			Thread.yield(); // attempt to allow queue depletion
  		}
  		eventQueue.put(invocation);
  		return null;
  	}
  
  	/***
  	 * Feed thread that extracts events from the eventQueue and invokes the
  	 * recipient object.
  	 */
  	class EventFeed extends Thread {
  
  		public void run() {
  			try {
  				while (true) {
  					try {
  						MethodInvocation invocation = (MethodInvocation) eventQueue.take();
  						invocation.proceed();
  					} catch (Throwable e) {
  						e.printStackTrace();
  					}
  				}
  			} catch (Exception e) {
  				e.printStackTrace();
  				//				LOG.info("eventThread exiting..." + this);
  			}
  		}
  	}
  }