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

/*

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.

 *

 * 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.

 *

 * When distributing the software, include this License Header Notice in each file.

 */

 package org.openconcerto.utils;

import org.openconcerto.utils.cc.BiConsumerExn;

import java.util.Iterator;

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 BiConsumerExn<L, E, X> callback;

        private final E evt;

        private DispatchingState(final Iterator<L> iter, BiConsumerExn<L, E, X> callback, final E evt) {

            this.iter = Objects.requireNonNull(iter, "Missing iterator");

            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

        protected LinkedList<DispatchingState> initialValue() {

            return new LinkedList<>();

        }

    };

    private final BiConsumerExn<L, E, X> callback;

    public ReentrantEventDispatcher() {

        this(null);

    }

    public ReentrantEventDispatcher(final BiConsumerExn<L, E, X> callback) {

        super();

        this.callback = callback;

    }

    public final void fire(final Iterator<L> iter, final E evt) throws X {

        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(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);

    }

    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.getIterator();

            final BiConsumerExn<L, E, X> currentCallback = currentTuple.getCallback();

            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);

    }

}