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.sql.view.list;

import org.openconcerto.sql.model.SQLRowAccessor;

import org.openconcerto.sql.model.SQLRowValues;

import org.openconcerto.sql.model.graph.Path;

import org.openconcerto.sql.request.ListSQLRequest;

import org.openconcerto.utils.Value;

import org.openconcerto.utils.cc.IPredicate;

import java.beans.PropertyChangeEvent;

import java.beans.PropertyChangeListener;

import java.sql.SQLException;

import java.util.ArrayList;

import java.util.Collection;

import java.util.Comparator;

import java.util.List;

import java.util.concurrent.Future;

// use SQLRowValues to allow graph

public abstract class SQLTableModelLinesSource {

    private final ITableModel model;

    private final PropertyChangeListener reqListener;

    private final List<PropertyChangeListener> listeners;

    private IPredicate<SQLRowValues> filter;

    {

        this.listeners = new ArrayList<PropertyChangeListener>();

        this.filter = null;

    }

    protected SQLTableModelLinesSource(final ITableModel model) {

        this.model = model;

        this.reqListener = new PropertyChangeListener() {

            @Override

            public void propertyChange(PropertyChangeEvent evt) {

                fireChanged(evt);

            }

        };

    }

    void live() {

        this.getParent().getReq().addWhereListener(this.reqListener);

    }

    void die() {

        this.getParent().getReq().rmWhereListener(this.reqListener);

    }

    public final ITableModel getModel() {

        return this.model;

    }

    public abstract SQLTableModelSource getParent();

    public final ListSQLRequest getUpdateQueueReq() {

        return this.getModel().getUpdateQ().getState().getReq();

    }

    public final List<ListSQLLine> getAll() {

        return this.get(null);

    }

    /**

     * Fetch up to date values from the DB.

     *

     * @param ids which rows to fetch, <code>null</code> meaning all.

     * @return the new values from the DB, some changes in the DB might be ignored if there's

     *         pending changes in this.

     */

    public abstract List<ListSQLLine> get(final Collection<? extends Number> ids);

    /**

     * A row in the DB has been changed, fetch its current value.

     *

     * @param id a valid ID of a database row.

     * @return if not {@link Value#hasValue()} the event should be ignored, otherwise the new value

     *         for the passed ID, <code>null</code> if it is not part of this.

     */

    public abstract Value<ListSQLLine> get(final int id);

    /**

     * Implementations should only use state of the parameters, so that this method can be

     * thread-safe (it is called both by the {@link UpdateQueue} and by the EDT in

     * {@link ITableModel}). This implementation order lines like the source {@link ListSQLRequest

     * request}.

     *

     * @param l1 the first line.

     * @param l2 the second line.

     * @return a negative integer, zero, or a positive integer as this object is less than, equal

     *         to, or greater than the specified object.

     * @see Comparator#compare(Object, Object)

     */

    public int compare(ListSQLLine l1, ListSQLLine l2) {

        return ListSQLLine.compareLikeRequest(l1, l2);

    }

    public boolean isCellEditable(ListSQLLine line, int colIndex, SQLTableModelColumn col) {

        return true;

    }

    public abstract Future<?> moveBy(final List<? extends SQLRowAccessor> rows, final int inc);

    // take IDs :

    // 1. no need to protect rows from modifications, just copy IDs

    // 2. for non committed rows, i.e. without DB ID and thus without SQLRow, it's easier to handle

    // (virtual) IDs than to use IdentitySet of SQLRowValues

    public abstract Future<?> moveTo(final List<? extends Number> rows, final int rowIndex);

    public final void setFilter(final IPredicate<SQLRowValues> filter) {

        // always fire since for now there's no other way for the caller

        // (ie if the meaning of filter change, it has to do setFilter(getFilter()) )

        this.filter = filter;

        this.fireChanged(new PropertyChangeEvent(this, "filter", null, this.filter));

    }

    public final IPredicate<SQLRowValues> getFilter() {

        return this.filter;

    }

    /**

     * Adds a listener to be notified when {@link #getAll()} change value.

     *

     * @param l the listener.

     */

    public final void addListener(PropertyChangeListener l) {

        this.listeners.add(l);

    }

    public final void rmListener(PropertyChangeListener l) {

        this.listeners.remove(l);

    }

    protected final void fireChanged(PropertyChangeEvent evt) {

        for (final PropertyChangeListener l : this.listeners)

            l.propertyChange(evt);

    }

    protected final ListSQLLine createLine(final SQLRowValues v) {

        return this.createLine(v, null);

    }

    /**

     * Create a line with the passed row.

     *

     * @param v the values.

     * @param passedID the {@link ListSQLLine#getID() ID} of the result, <code>null</code> meaning

     *        {@link SQLRowValues#getID()}.

     * @return a new line.

     * @throws IllegalArgumentException if <code>passedID</code> is <code>null</code> and

     *         <code>v</code> {@link SQLRowValues#hasID() has no ID}.

     */

    protected final ListSQLLine createLine(final SQLRowValues v, final Number passedID) {

        if (v == null || (this.filter != null && !this.filter.evaluateChecked(v)))

            return null;

        final int id;

        if (passedID != null) {

            id = passedID.intValue();

        } else if (v.hasID()) {

            id = v.getID();

        } else {

            throw new IllegalArgumentException("No ID for " + v);

        }

        final ListSQLLine res = new ListSQLLine(this, v, id, this.getModel().getUpdateQ().getState());

        this.lineCreated(res);

        return res;

    }

    /**

     * A new line has been created. This implementation does nothing.

     *

     * @param res the newly created line.

     */

    protected void lineCreated(ListSQLLine res) {

    }

    final void colsChanged(final SQLTableModelSourceState beforeState, final SQLTableModelSourceState afterState) {

        this.model.getUpdateQ().stateChanged(beforeState, afterState);

    }

    /**

     * Change the line <code>l</code> at the passed path with the passed values.

     *

     * @param l the line to change, eg RECEPTEUR[12].

     * @param path the changing path, eg RECEPTEUR.ID_LIMITEUR.

     * @param vals the new values, eg LIMITEUR{ID=4, DESIGNATION="dess"}.

     * @throws SQLException if the values cannot be commited.

     */

    public abstract void commit(ListSQLLine l, Path path, SQLRowValues vals) throws SQLException;

}