Formatting pass

1 files changed, 197 insertions, 249 deletions

diff --git a/projects/net.wotonomy.persistence/src/main/java/net/wotonomy/control/EODelayedObserverQueue.java b/projects/net.wotonomy.persistence/src/main/java/net/wotonomy/control/EODelayedObserverQueue.java
index 6b9b9c3..cea0d9e 100644
--- a/projects/net.wotonomy.persistence/src/main/java/net/wotonomy/control/EODelayedObserverQueue.java
+++ b/projects/net.wotonomy.persistence/src/main/java/net/wotonomy/control/EODelayedObserverQueue.java
@@ -26,298 +26,246 @@ import net.wotonomy.foundation.NSRunLoop;
 import net.wotonomy.foundation.NSSelector;
 
 /**
-* EODelayedObserverQueue allows EODelayedObservers 
-* to receive only one subjectChanged() message
-* after numerous willChange() messages have 
-* been sent.  Observers are then notified in order 
-* of their priority property,
-* so that certain observers can be notified before
-* others for whatever application-specific purpose. 
-* This class is not thread-safe and should be used
-* only for single-threaded GUI clients (AWT and Swing).
-* <br><br>
-* 
-* Important note: because AWT's event queue does
-* not allow for priority-based scheduling, this
-* class installs a custom event queue, replacing
-* the existing queue on the AWT dispatch thread.
-* We know of no way around this problem.
-* <br><br>
-*
-* Implementation note: this queue relies on the
-* result of equals() for maintaining a set of 
-* objects on the queue.  If two EODelayedObservers
-* evaluate to the same value using equals(), only
-* one of them will exist on the queue.  If this,
-* starts to suck, we can change it.
-*
-* @author michael@mpowers.net
-* @author $Author: cgruber $
-* @version $Revision: 894 $
-*/
+ * EODelayedObserverQueue allows EODelayedObservers to receive only one
+ * subjectChanged() message after numerous willChange() messages have been sent.
+ * Observers are then notified in order of their priority property, so that
+ * certain observers can be notified before others for whatever
+ * application-specific purpose. This class is not thread-safe and should be
+ * used only for single-threaded GUI clients (AWT and Swing). <br>
+ * <br>
+ * 
+ * Important note: because AWT's event queue does not allow for priority-based
+ * scheduling, this class installs a custom event queue, replacing the existing
+ * queue on the AWT dispatch thread. We know of no way around this problem. <br>
+ * <br>
+ *
+ * Implementation note: this queue relies on the result of equals() for
+ * maintaining a set of objects on the queue. If two EODelayedObservers evaluate
+ * to the same value using equals(), only one of them will exist on the queue.
+ * If this, starts to suck, we can change it.
+ *
+ * @author michael@mpowers.net
+ * @author $Author: cgruber $
+ * @version $Revision: 894 $
+ */
 
-public class EODelayedObserverQueue
-{
-    /**
-    * The default run loop ordering flushes the delayed observers
-    * up to ObserverPrioritySixth before dispatching the AWT event
-    * queue.  ObserverPriorityLater is run last.
-    */
-    public static int FlushDelayedObserversRunLoopOrdering = 400000;
-    
-	private static EODelayedObserverQueue 
-		defaultObserverQueue = null;
-	
-    private static NSSelector runLaterSelector = 
-        new NSSelector( "flushObserverQueue",
-            new Class[] { Object.class } );
+public class EODelayedObserverQueue {
+	/**
+	 * The default run loop ordering flushes the delayed observers up to
+	 * ObserverPrioritySixth before dispatching the AWT event queue.
+	 * ObserverPriorityLater is run last.
+	 */
+	public static int FlushDelayedObserversRunLoopOrdering = 400000;
+
+	private static EODelayedObserverQueue defaultObserverQueue = null;
+
+	private static NSSelector runLaterSelector = new NSSelector("flushObserverQueue", new Class[] { Object.class });
 
 	private boolean willRunLater;
- 	private LinkedList priorityQueue;
- 
-    /**
-    * Default constructor.
-    */
-    public EODelayedObserverQueue ()
-    {
+	private LinkedList priorityQueue;
+
+	/**
+	 * Default constructor.
+	 */
+	public EODelayedObserverQueue() {
 		willRunLater = false;
-        priorityQueue = new LinkedList();
-    }
+		priorityQueue = new LinkedList();
+	}
 
-    /**
-    * Returns the system default observer queue.
-    */
-    public static EODelayedObserverQueue defaultObserverQueue ()
-    {
-        if ( defaultObserverQueue == null )
-		{
-			defaultObserverQueue = new EODelayedObserverQueue();	
+	/**
+	 * Returns the system default observer queue.
+	 */
+	public static EODelayedObserverQueue defaultObserverQueue() {
+		if (defaultObserverQueue == null) {
+			defaultObserverQueue = new EODelayedObserverQueue();
 		}
 		return defaultObserverQueue;
-    }
+	}
 
-    /**
-    * Removes the specified observer from the queue.
-    */
-    public void dequeueObserver ( 
-        EODelayedObserver anObserver )
-    {
+	/**
+	 * Removes the specified observer from the queue.
+	 */
+	public void dequeueObserver(EODelayedObserver anObserver) {
 //System.out.println( "dequeueObserver: " + anObserver );
-		//synchronized ( priorityQueue )
-		//{
-			priorityQueue.remove( anObserver );
-		//}
-    }
+		// synchronized ( priorityQueue )
+		// {
+		priorityQueue.remove(anObserver);
+		// }
+	}
 
-    /**
-    * Adds the specified observer to the queue.
-    * An already enqueued observer will not be
-	* added again.
-	* If the observer's priority is 
-	* ObserverPriorityImmediate, it will be 
-	* notified immediately and not added to the
-	* queue.  
-	* Otherwise, the queue sets itself up to
-	* call notifyObserversUpToPriority during the
-    * run loop as specified by 
-    * FlushDelayedObserversRunLoopOrdering.
-    */
-    public void enqueueObserver ( 
-        EODelayedObserver anObserver )
-    {
-        // syntactic glue for Runnables
-        final EODelayedObserver observer = anObserver;
-        
-		if ( observer.priority() == 
-			EODelayedObserver.ObserverPriorityImmediate )
-		{
-            // invoke immediately
+	/**
+	 * Adds the specified observer to the queue. An already enqueued observer will
+	 * not be added again. If the observer's priority is ObserverPriorityImmediate,
+	 * it will be notified immediately and not added to the queue. Otherwise, the
+	 * queue sets itself up to call notifyObserversUpToPriority during the run loop
+	 * as specified by FlushDelayedObserversRunLoopOrdering.
+	 */
+	public void enqueueObserver(EODelayedObserver anObserver) {
+		// syntactic glue for Runnables
+		final EODelayedObserver observer = anObserver;
+
+		if (observer.priority() == EODelayedObserver.ObserverPriorityImmediate) {
+			// invoke immediately
 			observer.subjectChanged();
-		}
-        else
-		{
-            // place in the delayed observer queue
-            
-			//synchronized ( priorityQueue )
-			//{
-                int i = 0;
-                int priority = observer.priority();
-                Object o;
+		} else {
+			// place in the delayed observer queue
+
+			// synchronized ( priorityQueue )
+			// {
+			int i = 0;
+			int priority = observer.priority();
+			Object o;
 
-                Iterator iterator = priorityQueue.iterator();
+			Iterator iterator = priorityQueue.iterator();
 
-                // scan entire list to ensure we're not already queued
-                while ( iterator.hasNext() )
-                {
-                    o = iterator.next();
-                    if ( o == observer ) 
-                    {
-                        // already queued
-                        return;
-                    }
-                    if ( ((EODelayedObserver)o).priority() > priority )
-                    {
-                        // insert at this index: break now
-                        break;
-                    }
-                    i++;
-                }
-                
-                // if we broke early, we found a threshhold:
-                // continue scanning to ensure we're not already queued
-                while ( iterator.hasNext() )
-                {
-                    if ( iterator.next() == observer ) 
-                    {
-                        // already queued
-                        return;
-                    }
-                }
-                
-                // insert before items of lower priority,
-                // otherwise insert at end of list.
-                priorityQueue.add( i, observer );
-                
-			//}
+			// scan entire list to ensure we're not already queued
+			while (iterator.hasNext()) {
+				o = iterator.next();
+				if (o == observer) {
+					// already queued
+					return;
+				}
+				if (((EODelayedObserver) o).priority() > priority) {
+					// insert at this index: break now
+					break;
+				}
+				i++;
+			}
+
+			// if we broke early, we found a threshhold:
+			// continue scanning to ensure we're not already queued
+			while (iterator.hasNext()) {
+				if (iterator.next() == observer) {
+					// already queued
+					return;
+				}
+			}
+
+			// insert before items of lower priority,
+			// otherwise insert at end of list.
+			priorityQueue.add(i, observer);
+
+			// }
 			runLater();
 		}
 //System.out.println( "enqueueObserver: " + anObserver + " : " + priorityQueue );
-    }
+	}
 
-    /**
-    * Notifies all observers with priority equal to
-    * or greater than the specified priority.
-    */
-    public void notifyObserversUpToPriority ( int priority )
-    {
+	/**
+	 * Notifies all observers with priority equal to or greater than the specified
+	 * priority.
+	 */
+	public void notifyObserversUpToPriority(int priority) {
 //System.out.println( "notifyObserversUpToPriority: priorityQueue size = " + priorityQueue.size() );
 		EODelayedObserver o;
-		while ( ! priorityQueue.isEmpty() )
-		{
+		while (!priorityQueue.isEmpty()) {
 			o = (EODelayedObserver) priorityQueue.getFirst();
-			if ( o.priority() > priority ) break;
-            priorityQueue.removeFirst();
-            
-            try
-            {
-			    o.subjectChanged();
-            }
-            catch ( Exception exc )
-            {
-                System.out.println( "Error notifying observer: " + o );
-                exc.printStackTrace();
-            }
+			if (o.priority() > priority)
+				break;
+			priorityQueue.removeFirst();
+
+			try {
+				o.subjectChanged();
+			} catch (Exception exc) {
+				System.out.println("Error notifying observer: " + o);
+				exc.printStackTrace();
+			}
 		}
 	}
-	
+
 	/**
-	* Called to ensure that notifyObserversUpToPriority
-	* will be called on the next event loop.
-	*/
-	private void runLater()
-	{
-		if ( ! willRunLater )
-		{
+	 * Called to ensure that notifyObserversUpToPriority will be called on the next
+	 * event loop.
+	 */
+	private void runLater() {
+		if (!willRunLater) {
 			willRunLater = true;
-            NSRunLoop.currentRunLoop().performSelectorWithOrder(
-                runLaterSelector, this, null, FlushDelayedObserversRunLoopOrdering, null );
+			NSRunLoop.currentRunLoop().performSelectorWithOrder(runLaterSelector, this, null,
+					FlushDelayedObserversRunLoopOrdering, null);
 		}
 	}
-	
+
 	/**
-	* This method is called by the event queue run loop
-	* and calls notifyObserversUpToPriority with 
-    * ObserverPriorityLater.
-	* NOTE: This method is not part of the specification.
-	*/
-	public void flushObserverQueue( Object anObject )
-	{
+	 * This method is called by the event queue run loop and calls
+	 * notifyObserversUpToPriority with ObserverPriorityLater. NOTE: This method is
+	 * not part of the specification.
+	 */
+	public void flushObserverQueue(Object anObject) {
 //System.out.println( "EODelayedObserverQueue: running" );		
-    	notifyObserversUpToPriority( EODelayedObserver.ObserverPrioritySixth );
-        if ( ! priorityQueue.isEmpty() )
-        {
-            // assumes all remaining on queue are ObserverPriorityLater
-            NSRunLoop.invokeLater(
-                new PriorityLaterRunnable( new LinkedList( priorityQueue ) ) );
-            priorityQueue.clear();
-        }
+		notifyObserversUpToPriority(EODelayedObserver.ObserverPrioritySixth);
+		if (!priorityQueue.isEmpty()) {
+			// assumes all remaining on queue are ObserverPriorityLater
+			NSRunLoop.invokeLater(new PriorityLaterRunnable(new LinkedList(priorityQueue)));
+			priorityQueue.clear();
+		}
 		willRunLater = false;
 	}
-    
-    /**
-    * A runnable for dispatching remaining observers running at ObserverPriorityLater.
-    */
-    class PriorityLaterRunnable implements Runnable
-    {
-        List observers;
-        
-        public PriorityLaterRunnable( List anObserverList )
-        {
-            observers = anObserverList;
-        }
-        
-        public void run()
-        {
-            EODelayedObserver o = null;
-            Iterator i = observers.iterator();
-            while ( i.hasNext() )
-            {
-                try
-                {
-                    o = (EODelayedObserver) i.next();
-                    o.subjectChanged();
-                }
-                catch ( Exception exc )
-                {
-                    System.out.println( "Error notifying observer: " + o );
-                    exc.printStackTrace();
-                }
-            }
-        }
-    }
-	
-}    
+
+	/**
+	 * A runnable for dispatching remaining observers running at
+	 * ObserverPriorityLater.
+	 */
+	class PriorityLaterRunnable implements Runnable {
+		List observers;
+
+		public PriorityLaterRunnable(List anObserverList) {
+			observers = anObserverList;
+		}
+
+		public void run() {
+			EODelayedObserver o = null;
+			Iterator i = observers.iterator();
+			while (i.hasNext()) {
+				try {
+					o = (EODelayedObserver) i.next();
+					o.subjectChanged();
+				} catch (Exception exc) {
+					System.out.println("Error notifying observer: " + o);
+					exc.printStackTrace();
+				}
+			}
+		}
+	}
+
+}
 
 /*
- * $Log$
- * Revision 1.2  2006/02/16 16:47:14  cgruber
- * Move some classes in to "internal" packages and re-work imports, etc.
+ * $Log$ Revision 1.2 2006/02/16 16:47:14 cgruber Move some classes in to
+ * "internal" packages and re-work imports, etc.
  *
- * Also use UnsupportedOperationExceptions where appropriate, instead of WotonomyExceptions.
+ * Also use UnsupportedOperationExceptions where appropriate, instead of
+ * WotonomyExceptions.
  *
- * Revision 1.1  2006/02/16 13:19:57  cgruber
- * Check in all sources in eclipse-friendly maven-enabled packages.
+ * Revision 1.1 2006/02/16 13:19:57 cgruber Check in all sources in
+ * eclipse-friendly maven-enabled packages.
  *
- * Revision 1.8  2003/08/19 01:53:12  chochos
- * EOObjectStore had some incompatible return types (Object instead of EOEnterpriseObject, in fault methods mostly). It's internally consistent but I hope it doesn't break anything based on this, even though fault methods mostly throw exceptions for now.
+ * Revision 1.8 2003/08/19 01:53:12 chochos EOObjectStore had some incompatible
+ * return types (Object instead of EOEnterpriseObject, in fault methods mostly).
+ * It's internally consistent but I hope it doesn't break anything based on
+ * this, even though fault methods mostly throw exceptions for now.
  *
- * Revision 1.7  2002/05/20 15:08:35  mpowers
- * Optimization for enqueueObserver: we were scanning the entire list anyway;
- * now we compare priorities and ensure we're not double-queued on same pass.
+ * Revision 1.7 2002/05/20 15:08:35 mpowers Optimization for enqueueObserver: we
+ * were scanning the entire list anyway; now we compare priorities and ensure
+ * we're not double-queued on same pass.
  *
- * Revision 1.6  2002/05/15 13:45:57  mpowers
- * RunLater now appropriately runs later: at the end of the current awt queue.
+ * Revision 1.6 2002/05/15 13:45:57 mpowers RunLater now appropriately runs
+ * later: at the end of the current awt queue.
  *
- * Revision 1.5  2002/03/11 03:18:39  mpowers
- * Now properly handling ObserverChangesLater.
+ * Revision 1.5 2002/03/11 03:18:39 mpowers Now properly handling
+ * ObserverChangesLater.
  *
- * Revision 1.4  2001/10/26 18:37:15  mpowers
- * Now using NSRunLoop instead of AWT EventQueue.
+ * Revision 1.4 2001/10/26 18:37:15 mpowers Now using NSRunLoop instead of AWT
+ * EventQueue.
  *
- * Revision 1.3  2001/10/22 21:54:16  mpowers
- * Removed swing dependency in favor of jdk1.3 event queue.
- * Optimized priority queue population.
+ * Revision 1.3 2001/10/22 21:54:16 mpowers Removed swing dependency in favor of
+ * jdk1.3 event queue. Optimized priority queue population.
  *
- * Revision 1.2  2001/10/12 18:01:59  mpowers
- * Now catching exceptions before they disrupt the awt event queue.
+ * Revision 1.2 2001/10/12 18:01:59 mpowers Now catching exceptions before they
+ * disrupt the awt event queue.
  *
- * Revision 1.1.1.1  2000/12/21 15:46:42  mpowers
- * Contributing wotonomy.
+ * Revision 1.1.1.1 2000/12/21 15:46:42 mpowers Contributing wotonomy.
  *
- * Revision 1.5  2000/12/20 16:25:35  michael
- * Added log to all files.
+ * Revision 1.5 2000/12/20 16:25:35 michael Added log to all files.
  *
  *
  */
-    
-