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 java.util.AbstractList;

import java.util.Collection;

import java.util.Collections;

import java.util.Iterator;

import java.util.List;

/**

 * A class that wraps a list, to detect every change made to it. The changes are available with

 * {@link #getRecipe()}. Thread-safe if the delegate is itself thread-safe and not keeping history.

 *

 * @author Sylvain

 *

 * @param <E> type of items.

 */

public class ListChangeRecorder<E> extends AbstractList<E> {

    private final List<E> delegate;

    private final ListChangeRecipe<E> recipe;

    public ListChangeRecorder(final List<E> delegate) {

        this(delegate, false);

    }

    public ListChangeRecorder(final List<E> delegate, final boolean keepHistory) {

        super();

        this.delegate = delegate;

        this.recipe = new ListChangeRecipe<E>(keepHistory);

    }

    public ListChangeRecipe<E> getRecipe() {

        return this.recipe;

    }

    // inherit from AbstractList to gain iterators & sublist

    // they only call regular methods of this class, so every change made through them is recorded

    // overload a maximum of methods to keep the original behaviour/optimization of our delegate

    // ** read only

    @Override

    public E get(final int index) {

        return this.delegate.get(index);

    }

    @Override

    public int size() {

        return this.delegate.size();

    }

    @Override

    public Object[] toArray() {

        return this.delegate.toArray();

    }

    @Override

    public <T> T[] toArray(final T[] a) {

        return this.delegate.toArray(a);

    }

    @Override

    public boolean contains(final Object o) {

        return this.delegate.contains(o);

    }

    @Override

    public boolean containsAll(final Collection<?> c) {

        return this.delegate.containsAll(c);

    }

    @Override

    public boolean equals(final Object o) {

        return this.delegate.equals(o);

    }

    @Override

    public int hashCode() {

        return this.delegate.hashCode();

    }

    @Override

    public int indexOf(final Object o) {

        return this.delegate.indexOf(o);

    }

    @Override

    public boolean isEmpty() {

        return this.delegate.isEmpty();

    }

    @Override

    public int lastIndexOf(final Object o) {

        return this.delegate.lastIndexOf(o);

    }

    // ** write, always change the delegate before notifying the recipe

    // otherwise the listeners will be told of the changes before they even happened

    @Override

    public synchronized boolean add(final E e) {

        final boolean res = this.delegate.add(e);

        // -1 since this just grew by one

        this.recipe.add(this.size() - 1, Collections.singleton(e));

        return res;

    }

    @Override

    public synchronized void add(final int index, final E e) {

        this.delegate.add(index, e);

        this.recipe.add(index, Collections.singleton(e));

    }

    @Override

    public synchronized boolean addAll(final Collection<? extends E> c) {

        final int size = this.size();

        final boolean res = this.delegate.addAll(c);

        this.recipe.add(size, c);

        return res;

    }

    @Override

    public synchronized boolean addAll(final int index, final Collection<? extends E> c) {

        final boolean res = this.delegate.addAll(index, c);

        this.recipe.add(index, c);

        return res;

    }

    @Override

    public synchronized void clear() {

        final List<E> copy = (List<E>) ListChangeIndex.copy(this);

        this.delegate.clear();

        this.recipe.remove(0, copy.size() - 1, copy);

    }

    @Override

    public synchronized E set(final int index, final E element) {

        final E res = this.delegate.set(index, element);

        this.recipe.set(index, res, element);

        return res;

    }

    @Override

    public synchronized E remove(final int index) {

        final E res = this.delegate.remove(index);

        this.recipe.remove(index, index, Collections.singletonList(res));

        return res;

    }

    // objects

    @Override

    public synchronized boolean remove(final Object o) {

        final int index = this.indexOf(o);

        if (index < 0)

            return false;

        else {

            this.remove(index);

            return true;

        }

    }

    @Override

    public boolean removeAll(final Collection<?> c) {

        return this.changeAll(c, true);

    }

    @Override

    public boolean retainAll(final Collection<?> c) {

        return this.changeAll(c, false);

    }

    private synchronized boolean changeAll(final Collection<?> c, final boolean remove) {

        boolean modified = false;

        final Iterator<?> e = iterator();

        while (e.hasNext()) {

            if (c.contains(e.next()) == remove) {

                e.remove();

                modified = true;

            }

        }

        return modified;

    }

}