coreRuntime/src/sc/bind/BindingContext.java
private void doDispatch(BindingEvent list) {
      BindingEvent outer;
      IListener.SyncType oldSyncType = defaultSyncType;

      // Need this to be in immediate mode to send these events
      defaultSyncType = IListener.SyncType.IMMEDIATE;
      try {

         /* Make a pass through all pairs and compute the dependencies */
         /*
         for (outer = list; outer != null; outer = outer.next) {
            for (inner = outer.next; inner != null; inner = inner.next) {
               IListener innerListener = inner.listener;
               IListener outerListener = outer.listener;
               // Not sure we should be queueing the same listener more than once but if so, it should not
               // be a dependency.
               if (innerListener != outerListener) {
                  ISet readsOI = outerListener.getReads();
                  ISet readsIO = innerListener.getReads();
                  if (readsOI != null && readsIO != null) {
                     boolean depOI = readsOI.containsAny(innerListener.getWrites());
                     boolean depIO = readsIO.containsAny(outerListener.getWrites());
                     if (depOI) {
                        if (!depIO) {
                           outer.addDependency(inner);
                        }
                     }
                     else if (depIO)
                        inner.addDependency(outer);
                  }
               }
            }
         }
         */

         for (outer = list; outer != null; outer = outer.next) {
            dispatchDependencies(outer);
         }
      }
      finally {
         defaultSyncType = oldSyncType;
      }
   }
/**
    * At this point we have the list of events with the same priority.  We need to figure out which to run first
    * by looking for any dependencies between the listeners.
    */
At this point we have the list of events with the same priority.  We need to figure out which to run first
by looking for any dependencies between the listeners.
At this point we have the list of events with the same priority . We need to figure out which to run first by looking for any dependencies between the listeners .
private void doDispatch(BindingEvent list) {
      BindingEvent outer;
      IListener.SyncType oldSyncType = defaultSyncType;
      defaultSyncType = IListener.SyncType.IMMEDIATE;
      try {
         /* Make a pass through all pairs and compute the dependencies */
         /*
         for (outer = list; outer != null; outer = outer.next) {
            for (inner = outer.next; inner != null; inner = inner.next) {
               IListener innerListener = inner.listener;
               IListener outerListener = outer.listener;
               // Not sure we should be queueing the same listener more than once but if so, it should not
               // be a dependency.
               if (innerListener != outerListener) {
                  ISet readsOI = outerListener.getReads();
                  ISet readsIO = innerListener.getReads();
                  if (readsOI != null && readsIO != null) {
                     boolean depOI = readsOI.containsAny(innerListener.getWrites());
                     boolean depIO = readsIO.containsAny(outerListener.getWrites());
                     if (depOI) {
                        if (!depIO) {
                           outer.addDependency(inner);
                        }
                     }
                     else if (depIO)
                        inner.addDependency(outer);
                  }
               }
            }
         }
         */
         for (outer = list; outer != null; outer = outer.next) {
            dispatchDependencies(outer);
         }
      }
      finally {
         defaultSyncType = oldSyncType;
      }
   }
private void doDispatch ( BindingEvent list ) { BindingEvent outer ; IListener . SyncType oldSyncType = defaultSyncType ; defaultSyncType = IListener . SyncType . IMMEDIATE ; try { /* Make a pass through all pairs and compute the dependencies */ /*
         for (outer = list; outer != null; outer = outer.next) {
            for (inner = outer.next; inner != null; inner = inner.next) {
               IListener innerListener = inner.listener;
               IListener outerListener = outer.listener;
               // Not sure we should be queueing the same listener more than once but if so, it should not
               // be a dependency.
               if (innerListener != outerListener) {
                  ISet readsOI = outerListener.getReads();
                  ISet readsIO = innerListener.getReads();
                  if (readsOI != null && readsIO != null) {
                     boolean depOI = readsOI.containsAny(innerListener.getWrites());
                     boolean depIO = readsIO.containsAny(outerListener.getWrites());
                     if (depOI) {
                        if (!depIO) {
                           outer.addDependency(inner);
                        }
                     }
                     else if (depIO)
                        inner.addDependency(outer);
                  }
               }
            }
         }
         */ for ( outer = list ; outer != null ; outer = outer . next ) { dispatchDependencies ( outer ) ; } } finally { defaultSyncType = oldSyncType ; } }
At this point we have the list of events with the same priority.
At this point we have the list of events with the same priority .
// Need this to be in immediate mode to send these events