WebSVN - OpenConcerto - Diff - Rev 156 and 182 - /trunk/OpenConcerto/src/org/openconcerto/sql/view/list/ListSQLLine.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.model.FieldPath;
+import org.openconcerto.sql.model.RowRef;
 import org.openconcerto.sql.model.SQLField;
+import org.openconcerto.sql.model.SQLRowAccessor;
 import org.openconcerto.sql.model.SQLRowValues;
 import org.openconcerto.sql.model.SQLRowValues.CreateMode;
 import org.openconcerto.sql.model.SQLTable;
 import org.openconcerto.sql.model.SQLTable.VirtualFields;
 import org.openconcerto.sql.model.graph.Path;
+import org.openconcerto.sql.request.BaseFillSQLRequest.OrderValue;
+import org.openconcerto.sql.request.ComboSQLRequest.KeepMode;
 import org.openconcerto.sql.view.list.search.SearchQueue;
 import org.openconcerto.utils.CollectionUtils;
 import org.openconcerto.utils.NumberUtils;
 import java.util.ArrayList;
+    }
     private final SQLTableModelLinesSource src;
     // unmodifiable
     @GuardedBy("this")
-    private SQLRowValues row;
+    private SQLRowAccessor row;
+    // If the whole graph of this.row isn't kept then we need to store the primary keys so that when
+    // a SQLTableEvent is fired, we can know which lines is affected.
+    private final Set<RowRef> pks;
     // Immutable
     private final SQLTableModelSourceState state;
     private final int id;
     // allow to order by something not in the row
     @GuardedBy("this")
     private Number order;
+    // If the whole graph of this.row isn't kept then we need to store rows needed to order the
+    // lines. Otherwise don't allocate more memory just use this.rows.
+    private final OrderValue reqOrderVal;
     // lists are accessed by Swing (model.getValueAt()) and
     // by the search queue (SearchRunnable#matchFilter(ListSQLLine line))
     // immutable
     @GuardedBy("this")
     private List<Object> list;
         super();
         this.src = src;
         this.setRow(row);
         this.id = id;
         this.state = state;
+        final boolean isGraph = src.getParent().getKeepMode() == KeepMode.GRAPH;
+        this.reqOrderVal = isGraph ? null : state.getReq().createOrderValue(row);
+        if (isGraph) {
-        this.clearCache();
+            this.clearCache();
+            this.pks = null;
+        } else {
+            // compute all cells,
+            this.list = Collections.emptyList();
+            this.loadCache(state.getAllColumns().getAllColumns().size());
+            // then free memory by keeping a single SQLRow and only RowIDRef
+            this.setRow(row.asRow());
+            final Set<RowRef> tmpRefs = new HashSet<>(row.getGraphSize(), 1.0f);
+            for (final SQLRowValues v : row.getGraph().getItems()) {
+                tmpRefs.add(v.getRowRef());
+            }
+            this.pks = Collections.unmodifiableSet(tmpRefs);
+        }
+    }
     // load at least columnCount values
     // (to avoid loading debug columns, which took more time than the regular columns, ie more than
     // half the time was passed on almost never displayed values)
     public final SQLTableModelLinesSource getSrc() {
         return this.src;
+    }
-    private final void setRow(SQLRowValues v) {
+    private final void setRow(SQLRowAccessor v) {
         if (!v.isFrozen())
             throw new IllegalArgumentException("Not frozen : " + v);
         synchronized (this) {
             this.row = v;
+        }
+    }
+    public final SQLRowValues getRow() {
+        return (SQLRowValues) this.getRowAccessor();
+    }
-    public synchronized final SQLRowValues getRow() {
+    public synchronized final SQLRowAccessor getRowAccessor() {
         return this.row;
+    }
+    public final Set<RowRef> getPKs() {
+        return this.pks;
+    }
     @Override
     public int compareTo(ListSQLLine o) {
         if (this.src != o.src)
             throw new IllegalArgumentException(this.src + " != " + o.src);
         return this.src.compare(this, o);
                 throw new IllegalStateException("Order mismatch :\n" + order1 + " for " + l1 + " not coherent with\n" + order2 + " for " + l2);
             return NumberUtils.compare(order1, order2);
         } else {
             if (order2 != null)
                 throw new IllegalStateException("Order mismatch :\n" + order1 + " for " + l1 + " not coherent with\n" + order2 + " for " + l2);
+            final OrderValue orderVal1 = l1.getRequestOrderValue();
+            if (orderVal1 != null) {
+                final OrderValue orderVal2 = l2.getRequestOrderValue();
+                return orderVal1.compareTo(orderVal2);
+            } else {
+                // assert because we already checked same state above
+                assert l2.getRequestOrderValue() == null;
-            return l1.getState().getReq().order(l1.getRow(), l2.getRow());
+                return l1.getState().getReq().order(l1.getRow(), l2.getRow());
+            }
+        }
+    }
     public int getID() {
         return this.id;
+    }
     public synchronized final Number getOrder() {
         return this.order;
+    }
+    public final OrderValue getRequestOrderValue() {
+        return this.reqOrderVal;
+    }
     public synchronized List<Object> getList(int columnCount) {
         this.loadCache(columnCount);
         return this.list;
+    }
+        }
         return true;
+    }
     public void clearCache() {
+        if (this.getSrc().getParent().getKeepMode() != KeepMode.GRAPH)
+            throw new IllegalStateException("Wouldn't be able to compute cell values");
         synchronized (this) {
             this.list = Collections.emptyList();
+        }
+    }
         return false;
+    }
     @Override
     public String toString() {
-        return this.getClass().getSimpleName() + " on " + this.getRow();
+        return this.getClass().getSimpleName() + " on " + this.getRowAccessor();
+    }
+}

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/ListSQLLine.java - Rev 156 → 182