WebSVN - OpenConcerto - Diff - Rev 177 and 182 - /trunk/OpenConcerto/src/org/openconcerto/sql/view/list/UpdateQueue.java

 /*
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
+ *
- * Copyright 2011 OpenConcerto, by ILM Informatique. All rights reserved.
+ * 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.
  */
  package org.openconcerto.sql.view.list;
 import org.openconcerto.sql.Log;
+import org.openconcerto.sql.model.RowRef;
 import org.openconcerto.sql.model.SQLRow;
+import org.openconcerto.sql.model.SQLRowAccessor;
 import org.openconcerto.sql.model.SQLRowValues;
-import org.openconcerto.sql.model.SQLRowValues.CreateMode;
 import org.openconcerto.sql.model.SQLRowValuesCluster.State;
 import org.openconcerto.sql.model.SQLTable;
 import org.openconcerto.sql.model.SQLTableEvent;
 import org.openconcerto.sql.model.SQLTableModifiedListener;
 import org.openconcerto.sql.model.graph.Link.Direction;
 import org.openconcerto.sql.model.graph.Path;
+import org.openconcerto.sql.request.ComboSQLRequest.KeepMode;
 import org.openconcerto.sql.view.list.UpdateRunnable.RmAllRunnable;
 import org.openconcerto.sql.view.list.search.SearchOne;
 import org.openconcerto.sql.view.list.search.SearchOne.Mode;
 import org.openconcerto.sql.view.list.search.SearchQueue;
 import org.openconcerto.sql.view.list.search.SearchQueue.SetStateRunnable;
 import java.util.HashSet;
 import java.util.Iterator;
 import java.util.List;
 import java.util.Set;
 import java.util.concurrent.RunnableFuture;
+import java.util.function.BiConsumer;
 import java.util.logging.Level;
 import net.jcip.annotations.GuardedBy;
 public final class UpdateQueue extends SleepingQueue {
+        }
         return res;
+    }
     /**
-     * The lines and their path affected by a change of the passed row.
+     * The lines affected by a change of the passed row.
+     *
      * @param r the row that has changed.
-     * @return the refreshed lines and their changed paths.
+     * @return the refreshed lines.
      */
-    protected final ListMap<ListSQLLine, Path> getAffectedLines(final SQLRow r) {
+    protected final Set<Integer> getAffectedLines(final SQLRow r) {
+        final Set<Integer> res = new HashSet<>();
-        return this.getAffected(r, new ListMap<ListSQLLine, Path>(), true);
+        this.getAffected(r, (p, l) -> res.add(l.getID()));
+        return res;
+    }
     protected final ListMap<Path, ListSQLLine> getAffectedPaths(final SQLRow r) {
-        return this.getAffected(r, new ListMap<Path, ListSQLLine>(), false);
+        final ListMap<Path, ListSQLLine> res = new ListMap<>();
+        this.getAffected(r, res::add);
+        return res;
+    }
     // must be called from within this queue, as this method use fullList
-    private <K, V> ListMap<K, V> getAffected(final SQLRow r, final ListMap<K, V> res, final boolean byLine) {
+    private void getAffected(final SQLRow r, final BiConsumer<Path, ListSQLLine> cons) {
         final List<ListSQLLine> fullList = this.getFullList();
         synchronized (fullList) {
             final SQLTable t = r.getTable();
             final int id = r.getID();
             if (id < SQLRow.MIN_VALID_ID)
                 throw new IllegalArgumentException("invalid ID: " + id);
             if (!fullList.isEmpty()) {
+                final boolean keepGraph = this.getModel().getReq().getKeepMode() == KeepMode.GRAPH;
                 final SQLRowValues proto = this.getState().getReq().getGraphToFetch();
                 final List<Path> pathsToT = new ArrayList<Path>();
                 proto.getGraph().walk(proto, pathsToT, new ITransformer<State<List<Path>>, List<Path>>() {
                     @Override
                     public List<Path> transformChecked(State<List<Path>> input) {
                             input.getAcc().add(input.getPath());
+                        }
                         return input.getAcc();
+                    }
                 }, RecursionType.BREADTH_FIRST, Direction.ANY);
+                // paths aren't stored when !keepGraph
+                if (!keepGraph) {
+                    final RowRef idRef = r.getRowRef();
+                    for (final ListSQLLine line : fullList) {
+                        if (line.getPKs().contains(idRef))
+                            cons.accept(null, line);
+                    }
+                }
                 for (final Path p : pathsToT) {
                     final String lastReferentField = SearchQueue.getLastReferentField(p);
+                    final RowRef foreignRef;
+                    if (lastReferentField != null && r.exists()) {
+                        final SQLRowAccessor foreign = r.getNonEmptyForeign(lastReferentField);
+                        foreignRef = foreign != null ? foreign.getRowRef() : null;
+                    } else {
+                        foreignRef = null;
+                    }
+                    // fullList already checked above, so if there's no foreignRef, there's nothing
+                    // to do
+                    if (!keepGraph && foreignRef == null)
+                        continue;
                     for (final ListSQLLine line : fullList) {
                         boolean put = false;
+                        if (keepGraph) {
-                        for (final SQLRowValues current : line.getRow().followPath(p, CreateMode.CREATE_NONE, false)) {
+                            for (final SQLRowValues current : line.getRow().getDistantRows(p)) {
-                            // works for rowValues w/o any ID
+                                // works for rowValues w/o any ID
-                            if (current != null && current.getID() == id) {
+                                if (current != null && current.getID() == id) {
-                                put = true;
+                                    put = true;
+                                }
+                            }
+                        }
+                        /*
-                        // if the modified row isn't in the existing line, it might still affect it
+                         * If the modified row isn't in the existing line, it might still affect it
-                        // if it's a referent row insertion
+                         * if it's a referent row insertion (a referent row update or deletion would
-                        if (!put && lastReferentField != null && r.exists() && !r.isForeignEmpty(lastReferentField)) {
+                         * mean than the current line contains the modified row and so "put" would
-                            // no NPE, even without an undefined ID since we tested isForeignEmpty()
+                         * already be true).
+                         */
-                            final int foreignID = r.getInt(lastReferentField);
+                        if (!put && foreignRef != null) {
+                            if (keepGraph) {
-                            for (final SQLRowValues current : line.getRow().followPath(p.minusLast(), CreateMode.CREATE_NONE, false)) {
+                                for (final SQLRowValues current : line.getRow().getDistantRows(p.minusLast())) {
-                                if (current.getID() == foreignID) {
+                                    if (current.getID() == foreignRef.getID().intValue()) {
-                                    put = true;
+                                        put = true;
+                                    }
+                                }
+                            } else {
+                                put = line.getPKs().contains(foreignRef);
+                            }
+                        }
                         if (put) {
                             // add to the list of paths that have been refreshed
-                            add(byLine, res, p, line);
+                            cons.accept(p, line);
+                        }
+                    }
+                }
+            }
+        }
-        return res;
-    }
-    @SuppressWarnings("unchecked")
-    <V, K> void add(boolean byLine, ListMap<K, V> res, final Path p, final ListSQLLine line) {
-        if (byLine)
-            res.add((K) line, (V) p);
-        else
-            res.add((K) p, (V) line);
+    }
     final void setFullList(final List<ListSQLLine> tmp, final SQLTableModelColumns cols) {
         final List<ListSQLLine> fullList = this.getFullList();
         synchronized (fullList) {

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

svn://code.openconcerto.org/openconcerto

(root)/trunk/OpenConcerto/src/org/openconcerto/sql/view/list/UpdateQueue.java - Rev 177 → 182