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.change;

import org.openconcerto.utils.cc.IClosure;
import org.openconcerto.utils.cc.ITransformer;
import org.openconcerto.utils.cc.Transformer;

import java.util.ArrayList;
import java.util.Collection;
import java.util.IdentityHashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.CopyOnWriteArrayList;

import net.jcip.annotations.GuardedBy;

/**
 * Allow to propagate ListChange to listeners and bound lists. Can also store all changes that it
 * was notified and replay them with {@link #apply(List, ITransformer)}.
 *
 * @author Sylvain
 *
 * @param <T> type of items.
 * @see #bind(List, ITransformer)
 * @see #addListener(IClosure)
 */
public class ListChangeRecipe<T> implements ListChange<T> {

    private final List<ListChangeIndex<T>> changes;
    // don't use PropertyChangeSupport since it isn't type safe and we're only interested in the
    // last change (and not the whole property, i.e. the whole list)
    private final List<IClosure<? super ListChangeIndex<T>>> listeners;
    @GuardedBy("this")
    private final Map<List<?>, Pair<?>> boundLists;

    /**
     * Create a new instance. Recording is only necessary for {@link #apply(List, ITransformer)}.
     * Thread-safe only if not recording.
     *
     * @param record <code>true</code> if all changes should be kept (this will leak memory until
     *        {@link #clear()} is called).
     */
    public ListChangeRecipe(final boolean record) {
        super();
        this.changes = record ? new ArrayList<ListChangeIndex<T>>() : null;
        this.listeners = new CopyOnWriteArrayList<>();
        // need IdentityHashMap since List.equals() depend on its items
        // which will change
        this.boundLists = new IdentityHashMap<List<?>, Pair<?>>();
    }

    public final boolean recordChanges() {
        return this.changes != null;
    }

    /**
     * The list of changes since the last {@link #clear()}. Not thread-safe.
     * 
     * @return the list of changes
     */
    public final List<ListChangeIndex<T>> getChanges() {
        if (!this.recordChanges())
            throw new IllegalStateException("This instance wasn't created to record changes");
        return this.changes;
    }

    public void addListener(final IClosure<? super ListChangeIndex<T>> l) {
        this.listeners.add(l);
    }

    public void rmListener(final IClosure<? super ListChangeIndex<T>> l) {
        this.listeners.remove(l);
    }

    public void bind(final List<T> l) {
        this.bind(l, Transformer.<T> nopTransformer());
    }

    /**
     * From now on, every change added to this will be applied immediately to <code>l</code>.
     *
     * @param <U> type of items of <code>l</code>.
     * @param l the list to keep in sync.
     * @param transf the transformer.
     */
    public synchronized <U> void bind(final List<U> l, final ITransformer<T, U> transf) {
        this.boundLists.put(l, new Pair<U>(l, transf));
    }

    public synchronized <U> void unbind(final List<U> l) {
        this.boundLists.remove(l);
    }

    private final void add(final ListChangeIndex<T> change) {
        if (this.recordChanges())
            this.changes.add(change);
        // must change bounded lists first, otherwise listeners couldn't access them
        synchronized (this) {
            for (final Pair<?> p : this.boundLists.values()) {
                p.apply(change);
            }
            for (final IClosure<? super ListChangeIndex<T>> l : this.listeners)
                l.executeChecked(change);
        }
    }

    public void add(final int index0, final Collection<? extends T> c) {
        this.add(new ListChangeIndex.Add<T>(index0, c));
    }

    public void remove(final int index0, final int index1, final List<T> removed) {
        this.add(new ListChangeIndex.Rm<T>(index0, index1, removed));
    }

    public void set(final int index0, final T old, final T newItem) {
        this.add(new ListChangeIndex.Set<T>(index0, old, newItem));
    }

    /**
     * Clear all recorded changes. In general should be called after
     * {@link #apply(List, ITransformer)}.
     */
    public final void clear() {
        this.getChanges().clear();
    }

    /**
     * Apply all changes since the last {@link #clear()}.
     *
     * @param <U> type of list
     * @param l the list to change.
     * @param transf transform items between this and <code>l</code>.
     * @throws IllegalStateException if this instance doesn't {@link #recordChanges() record
     *         changes}.
     */
    @Override
    public <U> void apply(final List<U> l, final ITransformer<T, U> transf) throws IllegalStateException {
        for (final ListChange<T> change : this.getChanges()) {
            change.apply(l, transf);
        }
    }

    private final class Pair<U> {

        private final List<U> l;
        private final ITransformer<T, U> transf;

        public Pair(final List<U> l, final ITransformer<T, U> transf) {
            super();
            this.l = l;
            this.transf = transf;
        }

        void apply(final ListChange<T> change) {
            change.apply(this.l, this.transf);
        }
    }
}