WebSVN - OpenConcerto - Diff - Rev 180 and 182 - /trunk/OpenConcerto/src/org/openconcerto/utils/ReentrantEventDispatcher.java

 /*
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
+ *
- * Copyright 2011 OpenConcerto, by ILM Informatique. All rights reserved.
+ * Copyright 2011-2019 OpenConcerto, by ILM Informatique. All rights reserved.
+ *
  * The contents of this file are subject to the terms of the GNU General Public License Version 3
  * only ("GPL"). You may not use this file except in compliance with the License. You can obtain a
  * copy of the License at http://www.gnu.org/licenses/gpl-3.0.html See the License for the specific
  * language governing permissions and limitations under the License.
 import java.util.LinkedList;
 import java.util.Objects;
 /**
  * Allow to maintain the dispatching of events in order when a listener itself fires an event.
+ * <p>
+ * If each notification simply goes through a list of listeners, the events are delivered out of
+ * order : <img src="doc-files/reentrantEventsNaive.png" />
+ * <p>
+ * This class adds new notifications at the end of a list, but resume notifying from the start of
+ * the list. <img src="doc-files/reentrantEventsIn-order.png" />
+ *
  * @author sylvain
+ *
  * @param <L> listener type.
  * @param <E> event type.
  * @param <X> exception type.
  */
 public final class ReentrantEventDispatcher<L, E, X extends Exception> {
+    public final class DispatchingState {
+        private final Iterator<L> iter;
-    private final class DispatchingState extends Tuple3<Iterator<L>, BiConsumerExn<L, E, X>, E> {
+        private final BiConsumerExn<L, E, X> callback;
+        private final E evt;
-        public DispatchingState(final Iterator<L> iter, BiConsumerExn<L, E, X> callback, final E evt) {
+        private DispatchingState(final Iterator<L> iter, BiConsumerExn<L, E, X> callback, final E evt) {
+            this.iter = Objects.requireNonNull(iter, "Missing iterator");
-            super(Objects.requireNonNull(iter, "Missing iterator"), Objects.requireNonNull(callback, "Missing callback"), evt);
+            this.callback = Objects.requireNonNull(callback, "Missing callback");
+            this.evt = evt;
+        }
+        private final Iterator<L> getIterator() {
+            return this.iter;
+        }
+        private final BiConsumerExn<L, E, X> getCallback() {
+            return this.callback;
+        }
+        public final E getEvt() {
+            return this.evt;
+        }
+    }
     private final ThreadLocal<LinkedList<DispatchingState>> events = new ThreadLocal<LinkedList<DispatchingState>>() {
         @Override
         super();
         this.callback = callback;
+    }
     public final void fire(final Iterator<L> iter, final E evt) throws X {
-        this.fire(iter, this.callback, evt);
+        this.fire(this.createDispatchingState(iter, evt));
+    }
     public final void fire(final Iterator<L> iter, final BiConsumerExn<L, E, X> callback, final E evt) throws X {
-        this.fire(new DispatchingState(iter, callback, evt));
+        this.fire(this.createDispatchingState(iter, callback, evt));
+    }
+    public final DispatchingState createDispatchingState(final Iterator<L> iter, final E evt) {
+        return this.createDispatchingState(iter, this.callback, evt);
+    }
+    public final DispatchingState createDispatchingState(final Iterator<L> iter, final BiConsumerExn<L, E, X> callback, final E evt) {
+        return new DispatchingState(iter, callback, evt);
+    }
-    private final void fire(final DispatchingState newTuple) throws X {
+    public final void fire(final DispatchingState newTuple) throws X {
         final LinkedList<DispatchingState> linkedList = this.events.get();
         // add new event
         linkedList.addLast(newTuple);
         // process all pending events
         DispatchingState currentTuple;
         while ((currentTuple = linkedList.peekFirst()) != null) {
-            final Iterator<L> currentIter = currentTuple.get0();
+            final Iterator<L> currentIter = currentTuple.getIterator();
-            final BiConsumerExn<L, E, X> currentCallback = currentTuple.get1();
+            final BiConsumerExn<L, E, X> currentCallback = currentTuple.getCallback();
-            final E currentEvt = currentTuple.get2();
+            final E currentEvt = currentTuple.getEvt();
             while (currentIter.hasNext()) {
                 final L l = currentIter.next();
                 currentCallback.accept(l, currentEvt);
+            }
+            /*
+             * It isn't because one callback failed that the event itself didn't happen or should be
+             * reverted : we should still notify the other callbacks. So don't use a finally block
+             * to remove currentTuple. But if the event should indeed be reverted (e.g. the callback
+             * was a check), #remove(DispatchingState) should be called.
+             */
             // not removeFirst() since the item might have been already removed
             linkedList.pollFirst();
+        }
+    }
+    /**
+     * Remove a dispatching state. Useful because if there's an exception while notifying the
+     * listeners, then the next {@link #fire(DispatchingState)} in the same thread will by default
+     * resume notifying the listeners. That behaviour is not valid for a reverted DB transaction.
+     *
+     * @param dispatchingState what to remove.
+     * @return {@code true} if the item was actually removed.
+     * @see #createDispatchingState(Iterator, Object)
+     */
+    public final boolean remove(DispatchingState dispatchingState) {
+        return this.events.get().remove(dispatchingState);
+    }
+}

Dépôt officiel du code source de l'ERP OpenConcerto

svn://code.openconcerto.org/openconcerto

(root)/trunk/OpenConcerto/src/org/openconcerto/utils/ReentrantEventDispatcher.java - Rev 180 → 182