src/org/lwes/listener/ThreadedEventDispatcher.java

   1 package org.lwes.listener;
   2
   3 import org.lwes.Event;
   4 import org.lwes.util.Log;
   5
   6 /**
   7  * Dispatches events to downstream handlers using threads.
   8  * @author Preston Pfarner
   9  * @author Michael P. Lum
  10  */
  11 public class ThreadedEventDispatcher extends Thread {
  12         /* dequeuer controlling this object */
  13         private ThreadedDequeuer dequeuer;
  14         private EventHandler eventHandler;
  15         private Event event;
  16
  17         protected ThreadedEventDispatcher(ThreadedDequeuer aDequeuer) {
  18                 this.dequeuer = aDequeuer;
  19                 super.start();
  20                 setName("EventDispatcher");
  21         }
  22
  23         public void setTask(EventHandler aHandler, Event anEvent) throws IllegalStateException {
  24                 if(isIdle()) {
  25                         synchronized(this) {
  26                                 eventHandler = aHandler;
  27                                 event = anEvent;
  28                         }
  29                         synchronized(this) { notifyAll(); }
  30                 } else {
  31                         throw new IllegalStateException("Processor already has a listener");
  32                 }
  33         }
  34
  35         public final boolean isActive() {
  36                 return (! isIdle());
  37         }
  38
  39         public final boolean isIdle() {
  40                 final boolean p1 = (eventHandler == null);
  41                 final boolean p2 = (event == null);
  42                 if(p1 == p2) return p1;
  43                 else throw new IllegalStateException("Contradictory state indication");
  44         }
  45
  46         public void run() {
  47                 while(true) {
  48                         synchronized(this) {
  49                                 if(isActive()) {
  50                                         try {
  51                                                 eventHandler.handleEvent(event);
  52                                         } catch(Exception e) {
  53                                                 Log.warning("Caught exception handling event", e);
  54                                         }
  55                                         clearTask();
  56                                 } else {
  57                                         try {
  58                                                 wait();
  59                                         } catch(InterruptedException e) {}
  60                                 }
  61                         }
  62                 }
  63         }
  64
  65         private void clearTask() {
  66                 synchronized(this) {
  67                         eventHandler = null;
  68                         event = null;
  69                 }
  70
  71                 dequeuer.makeAvailable(this);
  72         }
  73
  74 }