import java.util.ArrayDeque;
import java.util.ArrayList;
-import java.util.Collection;
import java.util.Collections;
import java.util.Deque;
import java.util.List;
import org.simantics.db.Session;
import org.simantics.db.Statement;
import org.simantics.db.WriteGraph;
+import org.simantics.db.common.request.ReadRequest;
import org.simantics.db.exception.DatabaseException;
import org.simantics.db.layer0.util.Layer0Utils;
import org.simantics.db.request.Read;
import org.simantics.interop.test.GraphChanges;
import org.simantics.interop.test.GraphChanges.Modification;
import org.simantics.interop.test.GraphComparator;
-import org.simantics.utils.datastructures.BijectionMap;
import org.simantics.utils.datastructures.Pair;
public abstract class ModelUpdate {
private UpdateTree updateTree3;
private UpdateList updateList3;
+ private UpdateNode3 updateNode3;
+
private List<ChangeFilter> filters = new ArrayList<ChangeFilter>();
- private List<ChangeFilter> userFilters = new ArrayList<ChangeFilter>();
+ private List<ChangeFilter2> userFilters = new ArrayList<ChangeFilter2>();
boolean init = false;
* Adds an user filter. Use refreshUserFilters() to apply the changes.
* @param filter
*/
- public void addUserFilter(ChangeFilter filter) {
+ public void addUserFilter(ChangeFilter2 filter) {
userFilters.add(filter);
}
* Removes an user filter. Use refreshUserFilters() to apply the changes.
* @param filter
*/
- public void removeUserFilter(ChangeFilter filter) {
+ public void removeUserFilter(ChangeFilter2 filter) {
userFilters.remove(filter);
}
userFilters.clear();
}
- public List<ChangeFilter> getUserFilters() {
+ public List<ChangeFilter2> getUserFilters() {
return userFilters;
}
pc.setVisible(true);
}
if (userFilters.size() > 0) {
- // Create filtered changes
- List<ChangeFilter> combined = new ArrayList<>(filters);
- combined.addAll(userFilters);
- GraphChanges filteredChanges = getSession().syncRequest(createFilterRead(changes, combined));
- UpdateTree updateTreeF = getUpdateTree(filteredChanges);
- UpdateList updateListF = getUpdateList(filteredChanges);
- // hide changes that are not contained within the filtered changes.
- applyVisibleFlags(updateTree.getRootNode(), updateTreeF.getRootNode());
- applyVisibleFlags(updateList.getChanges(), updateListF.getChanges());
+ if (changes2 != null && changes3 != null) {
+ getUpdateTree3();
+ }
+ getSession().syncRequest(new ReadRequest() {
+
+ @Override
+ public void run(ReadGraph graph) throws DatabaseException {
+ for (PropertyChange change : updateList.getChanges()) {
+ boolean visible = true;
+ for (ChangeFilter2 filter : userFilters) {
+ if (!filter.accept(graph, change)) {
+ visible = false;
+ break;
+ }
+ }
+ change.setVisible(visible);
+ }
+ if (updateTree3 != null) {
+ Deque<UpdateNode3> stack = new ArrayDeque<>();
+ stack.add(getUpdateNode3());
+ while (!stack.isEmpty()) {
+ UpdateNode3 n = stack.pop();
+ boolean visible = true;
+ for (ChangeFilter2 filter : userFilters) {
+ if (!filter.accept(graph, n)) {
+ visible = false;
+ break;
+ }
+ }
+ n.setVisible(visible);
+ for (UpdateNode3 c : n.getChildren())
+ stack.push(c);
+ }
+ } else {
+
+ Deque<UpdateNode> stack = new ArrayDeque<>();
+ stack.add(updateTree.getRootNode());
+ while (!stack.isEmpty()) {
+ UpdateNode n = stack.pop();
+ boolean visible = true;
+ for (ChangeFilter2 filter : userFilters) {
+ if (!filter.accept(graph, n)) {
+ visible = false;
+ break;
+ }
+ }
+ n.setVisible(visible);
+ for (UpdateNode c : n.getChildren())
+ stack.push(c);
+ }
+ }
+ }
+ });
}
}
- private void applyVisibleFlags(UpdateNode l, UpdateNode r) {
- BijectionMap<UpdateNode, UpdateNode> comparable = new BijectionMap<>();
- for (UpdateNode lc : l.getChildren()) {
- for (UpdateNode rc : r.getChildren()) {
- if (comparable.containsRight(rc))
- continue;
- if (lc.getResource() != null) {
- if (lc.getResource().equals(rc.getResource())) {
-
- comparable.map(lc, rc);
- break;
- }
- } else if (rc.getResource() == null){
- UpdateOp lop = lc.getOp();
- UpdateOp rop = rc.getOp();
- if (lop.getStatement() != null && lop.getStatement().equals(rop.getStatement())) {
- comparable.map(lc, rc);
- break;
- }
- }
- }
- }
- for (UpdateNode lc : l.getChildren()) {
- if (!comparable.containsLeft(lc))
- lc.setVisible(false);
- }
- for (Entry<UpdateNode, UpdateNode> entry : comparable.getEntries()) {
- applyVisibleFlags(entry.getKey(), entry.getValue());
- }
- }
-
- private void applyVisibleFlags(Collection<PropertyChange> l, Collection<PropertyChange> r) {
- BijectionMap<PropertyChange, PropertyChange> comparable = new BijectionMap<>();
- for (PropertyChange lc : l) {
- for (PropertyChange rc : r) {
- if (comparable.containsRight(rc))
- continue;
- if (lc.getFirst() != null && lc.getFirst().equals(rc.getFirst())) {
- comparable.map(lc, rc);
- break;
- }
- if (lc.getSecond() != null && lc.getSecond().equals(rc.getSecond())) {
- comparable.map(lc, rc);
- break;
- }
- }
- }
- for (PropertyChange lc : l) {
- if (!comparable.containsLeft(lc))
- lc.setVisible(false);
- }
-
- }
-
protected abstract Pair<GraphComparator,String> getChanges(Resource r1, Resource r2) throws DatabaseException;
protected abstract UpdateTree getUpdateTree(GraphChanges changes) throws DatabaseException;
protected UpdateList getUpdateList(GraphChanges changes) throws DatabaseException {
updateList3 = getUpdateList(changes3);
return updateList3;
}
+
+ public UpdateNode3 getUpdateNode3() throws DatabaseException {
+ if (updateNode3 == null && changes2 != null && changes3 != null) {
+ updateNode3 = UpdateNode3.getCombinedTree(this);
+ }
+ return updateNode3;
+ }
public void applyAll(WriteGraph graph) throws DatabaseException {
if (accept)
modifications.add(mod);
}
- GraphChanges newChanges = new GraphChanges(changes.getResource1(),changes.getResource2(),changes.getDeletions(), changes.getAdditions(), modifications, changes.getComparable());
+ List<Statement> deletions = new ArrayList<Statement>();
+ for (Statement del : changes.getDeletions()) {
+
+ boolean accept = true;
+ for (ChangeFilter filter : filters) {
+ if (!filter.acceptDeletion(g, del)) {
+ accept = false;
+ break;
+ }
+ }
+ if (accept)
+ deletions.add(del);
+ }
+ List<Statement> additions = new ArrayList<Statement>();
+ for (Statement del : changes.getAdditions()) {
+
+ boolean accept = true;
+ for (ChangeFilter filter : filters) {
+ if (!filter.acceptAddition(g, del)) {
+ accept = false;
+ break;
+ }
+ }
+ if (accept)
+ additions.add(del);
+ }
+
+ GraphChanges newChanges = new GraphChanges(changes.getResource1(),changes.getResource2(),deletions, additions, modifications, changes.getComparable());
return newChanges;
}
}
-
+ /**
+ * Interface for built-in filters that are used for processing raw change data before forming UpdateTree + UpdateList
+ * @author luukkainen
+ *
+ */
public interface ChangeFilter {
public boolean accept(ReadGraph g, Modification change) throws DatabaseException;
+ public boolean acceptAddition(ReadGraph g, Statement addition) throws DatabaseException;
+ public boolean acceptDeletion(ReadGraph g, Statement deletion) throws DatabaseException;
+ }
+
+ /**
+ * Interface for user defined filters.
+ *
+ * This filter only affects visible flags.
+ *
+ * @author luukkainen
+ *
+ */
+ public interface ChangeFilter2 {
+ public boolean accept(ReadGraph g, PropertyChange change) throws DatabaseException;
+ public boolean accept(ReadGraph g, UpdateNode change) throws DatabaseException;
+ public boolean accept(ReadGraph g, UpdateNode3 change) throws DatabaseException;
}
return true;
}
+
+ @Override
+ public boolean acceptAddition(ReadGraph g, Statement addition) throws DatabaseException {
+ return true;
+ }
+
+ @Override
+ public boolean acceptDeletion(ReadGraph g, Statement deletion) throws DatabaseException {
+ return true;
+ }
}
public void defaultSelections() {
Code Review / simantics / interop.git / blobdiff