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

/*

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

 *

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

 *

 * @author sylvain

 *

 * @param <L> listener type.

 * @param <E> event type.

 * @param <X> exception type.

 */

public final class ReentrantEventDispatcher<L, E, X extends Exception> {

    private final class DispatchingState extends Tuple3<Iterator<L>, BiConsumerExn<L, E, X>, E> {

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

            super(Objects.requireNonNull(iter, "Missing iterator"), Objects.requireNonNull(callback, "Missing callback"), 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(iter, this.callback, 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));

    }

    private 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 BiConsumerExn<L, E, X> currentCallback = currentTuple.get1();

            final E currentEvt = currentTuple.get2();

            while (currentIter.hasNext()) {

                final L l = currentIter.next();

                currentCallback.accept(l, currentEvt);

            }

            // not removeFirst() since the item might have been already removed

            linkedList.pollFirst();

        }

    }

}