simpleeventsystem.java

一个基于PlaceLab的室内和室外的智能导航系统

package org.placelab.eventsystem;

import java.util.Comparator;
import java.util.Enumeration;
import java.util.Hashtable;
import java.util.Vector;

import org.placelab.util.DHeap;

/*
 * Created on Aug 10, 2004
 *
 */

/**
 * 
 *
 */
public class SimpleEventSystem implements EventSystem {
	private DHeap timers;
	private Hashtable eventListeners;
	private int runCount=0;
	
	private class QueueEventComparator implements Comparator {
	    public int compare(Object o1, Object o2) {
	        QueueEvent qe1 = (QueueEvent)o1;
	        QueueEvent qe2 = (QueueEvent)o2;
	        if(qe1.timeout > qe2.timeout) return 1;
	        else if(qe1.timeout == qe2.timeout) return 0;
	        else return -1;
	    }
	}
	
	private class QueueEvent {
		public QueueEvent(long t, EventListener l, Object d) {
			timeout = t;
			listener = l;
			data = d;
		}
		public long timeout;
		public EventListener listener;
		public Object data;
	}
	
	public SimpleEventSystem() {
		timers = new DHeap(new QueueEventComparator(), 
		        4, 256);
		eventListeners = new Hashtable();
		runCount = 0;
	}
	public void run() {
		QueueEvent event=null;
		int keepGoing;
		synchronized(timers) { keepGoing = ++runCount; }
		while (true) {
			synchronized(timers) {
				if (runCount < keepGoing) break;
				while (timers.isEmpty()) {
					try { timers.wait(); } catch (InterruptedException e) {}
				}
				if (runCount < keepGoing) break;
				
				long now = System.currentTimeMillis();
				event = (QueueEvent) timers.findMin();
				if (event.timeout <= now) {
					timers.deleteMin();
				} else {
					long interval = event.timeout - now;
					event = null;
					try { timers.wait(interval); } catch (InterruptedException e) {}
					if (runCount < keepGoing) break;
				}
			}
			
			if (event != null) {
				// process event
				event.listener.callback(null, event.data);
			}
		}
	}

	public void stop() {
		synchronized(timers) {
			timers.makeEmpty();
			runCount--;
		}
	}

	public Object addTimer(long timeoutMillis, EventListener listener,
			Object data) {
		QueueEvent event = new QueueEvent(System.currentTimeMillis()+timeoutMillis, listener, data);
		synchronized(timers) {
			timers.insert(event);
			timers.notify();
		}
		return event;
	}

	public void removeTimer(Object token) {
		QueueEvent event = (QueueEvent) token;
		synchronized(timers) {
			timers.remove(event);
		}
	}

	public Object addEventListener(Object eventType, EventListener listener) {
		Vector listeners = (Vector)eventListeners.get(eventType);
		if (listeners == null) {
			listeners = new Vector();
			eventListeners.put(eventType, listeners);
		}
		listeners.addElement(listener);
		Object []rv = new Object[2];
		rv[0] = eventType;
		rv[1] = listener;
		return rv;
	}
	public void removeEventListener(Object token) {
		Object[] arr = (Object[]) token;
		Object eventType = arr[0];
		Object listener = arr[1];
		
		Vector listeners = (Vector) eventListeners.get(eventType);
		if (listeners != null) listeners.removeElement(listener);
	}

	public void notifyEvent(final Object eventType, final Object data) {
		addTimer(0, new EventListener() {
			public void callback(Object dummy, Object d) {
				doNotifyEvent(eventType, data);
			}
		}, null);
	}
	private void doNotifyEvent(Object eventType, Object data) {
		Vector listeners = (Vector) eventListeners.get(eventType);
		if (listeners == null) return;
		for (Enumeration it=listeners.elements(); it.hasMoreElements(); ) {
			EventListener listener = (EventListener) it.nextElement();
			listener.callback(eventType, data);
		}
	}

	public void notifyTransientEvent(EventListener listener, Object data) {
		addTimer(0, listener, data);
	}
}