X-Git-Url: https://gerrit.simantics.org/r/gitweb?a=blobdiff_plain;f=org.simantics.interop%2Fsrc%2Forg%2Fsimantics%2Finterop%2Ftest%2FGraphComparator.java;h=c59cbfccac76db6aa1e28e474f29163c833e040e;hb=8b60ded31ab0047c731335acc1a2cccb844324d8;hp=052a9a9ee19ad7bce23cba188e2bc923fbd76a2d;hpb=8b92927f87a7966d268ab7678d29992485752c21;p=simantics%2Finterop.git diff --git a/org.simantics.interop/src/org/simantics/interop/test/GraphComparator.java b/org.simantics.interop/src/org/simantics/interop/test/GraphComparator.java index 052a9a9..c59cbfc 100644 --- a/org.simantics.interop/src/org/simantics/interop/test/GraphComparator.java +++ b/org.simantics.interop/src/org/simantics/interop/test/GraphComparator.java @@ -52,7 +52,7 @@ import org.simantics.utils.datastructures.Pair; */ public class GraphComparator { - private static final boolean DEBUG = true; + private static final boolean DEBUG = false; private Resource r1; private Resource r2; @@ -308,8 +308,6 @@ public class GraphComparator { if (r1.equals(r2)) continue; - if (r1.getResourceId() == 610446L) - System.out.println(); if (processedResources.contains(r1)) continue; processedResources.add(r1); @@ -457,7 +455,7 @@ public class GraphComparator { // compare objects (unreliable result is interpreted as positive match) int comp = comparator.compare(g, left.get(i).getObject(), similarLeft.get(j).getObject(), true); - if (comp >= 0 && comp < Integer.MAX_VALUE) { + if (comp >= 0 && comp < ResourceComparator.NO_MATCH) { useL[i] = true; useSL[j] = true; break; @@ -518,6 +516,8 @@ public class GraphComparator { Statement rs = right.get(r); if (!comparableResources.contains(ls.getSubject(), rs.getSubject())) continue; + if ((comparableResources.containsLeft(ls.getObject()) || comparableResources.containsRight(rs.getObject())) && !comparableResources.contains(ls.getObject(), rs.getObject())) + continue; if (rcomp.compare(ls.getPredicate(),rs.getPredicate()) == 0) { // compare objects (unreliable result is not accepted) int comp = comparator.compare(g, ls.getObject(), rs.getObject()); @@ -697,14 +697,14 @@ public class GraphComparator { } - private boolean hasMatchingPaths(Set leftPaths, Set rightPaths) { + private boolean hasMatchingPaths(Set leftPaths, Set rightPaths) throws DatabaseException { if (leftPaths.size() != rightPaths.size()) return false; BijectionMap map = getMatchingPaths(leftPaths, rightPaths); return map.size() == leftPaths.size(); } - private BijectionMap getMatchingPaths(Set leftPaths, Set rightPaths) { + private BijectionMap getMatchingPaths(Set leftPaths, Set rightPaths) throws DatabaseException { BijectionMap map = new BijectionMap(); for (Path leftPath : leftPaths) { for (Path rightPath : rightPaths) { @@ -713,8 +713,27 @@ public class GraphComparator { if (leftPath.getLength() != rightPath.getLength()) continue; if (comparableResources.contains(leftPath.getEnd(), rightPath.getEnd())) { - map.map(leftPath, rightPath); - break; + boolean match = true; + for (int i = 0; i < leftPath.getLength(); i++) { + Statement sl = leftPath.getStatements().get(i); + Statement sr = rightPath.getStatements().get(i); + if (!sl.getPredicate().equals(sr.getPredicate()) && !comparableResources.contains(sl.getPredicate(), sr.getPredicate())) { + match = false; + break; + } + if ((getComparableResources().containsLeft(sl.getObject()) || getComparableResources().containsRight(sr.getObject())) && !getComparableResources().contains(sl.getObject(), sr.getObject())) { + match = false; + break; + } + if (comparator.compare(g, sl.getObject(), sr.getObject()) == ResourceComparator.NO_MATCH) { + match = false; + break; + } + } + if (match) { + map.map(leftPath, rightPath); + break; + } } } } @@ -777,6 +796,14 @@ public class GraphComparator { return new GraphChanges(r1,r2,changes1,changes2,modifications,comparableResources); } + public List getChanges1() { + return changes1; + } + + public List getChanges2() { + return changes2; + } + private void addComparable(Statement left, Statement right) throws DatabaseException { addComparable(left.getObject(), right.getObject()); comparableStatements.map(left, right); @@ -789,8 +816,6 @@ public class GraphComparator { throw new DatabaseException("Comparator error: Trying to map " + left + " to " + right + " while mappings " + left + " to " + comparableResources.getRight(left) + " and " + comparableResources.getLeft(right) + " to " + right + " exist."); } else { if (DEBUG) System.out.println(left + " = " + right); - if (left.getResourceId() == 610381L) - System.out.println(); comparableResources.map(left, right); } } @@ -807,6 +832,26 @@ public class GraphComparator { return out; } + public List filterAssertedDuplicates(Resource r, List in) throws DatabaseException { + List out = new ArrayList(); + for (int i = 0; i < in.size(); i++) { + Statement s = in.get(i); + if (!s.isAsserted(r)) + out.add(s); + else { + boolean has = false; + if (i > 0 && in.get(i-1).getPredicate().equals(s.getPredicate())) + has = true; + else if (i < in.size()-1 && in.get(i+1).getPredicate().equals(s.getPredicate())) + has = true; + if (!has) + out.add(s); + } + + } + return out; + } + private String printStatement(ReadGraph graph, Statement s) throws DatabaseException { @@ -850,8 +895,6 @@ public class GraphComparator { if (!changes1Set.contains(s)) { changes1Set.add(s); changes1.add(s); - if (s.getObject().getResourceId() == 532631L) - System.out.println(); } } @@ -862,8 +905,8 @@ public class GraphComparator { } } - private void addModification(Resource sub1, Statement s1, Resource sub2, Statement s2) { - Modification mod = new Modification(sub1, sub2, s1, s2); + private void addModification(Resource left, Statement leftstm, Resource right, Statement rightstm) { + Modification mod = new Modification(left, right, leftstm, rightstm); if (!modificationsSet.contains(mod)) { modificationsSet.add(mod); modifications.add(mod); @@ -1042,7 +1085,7 @@ public class GraphComparator { for (int i = 0; i < used2.length; i++) { used2[i] = false; } - + // left, right, difference List> differences = new ArrayList>(); for (int i1 = off1; i1 < off1 + len1; i1++) { @@ -1074,41 +1117,12 @@ public class GraphComparator { Integer[] pris = priorities.getKeys(new Integer[]{}); Arrays.sort(pris); + boolean matchFail = priorityMatching(ss1, off1, len1, ss2, off2, len2, pris, differences, priorities, used1, used2, objectsLeft, objectsRight, false); + if (matchFail) + matchFail = priorityMatching(ss1, off1, len1, ss2, off2, len2, pris, differences, priorities, used1, used2, objectsLeft, objectsRight, objectsLeft == null); for (Integer pri : pris) { - if (pri == Integer.MAX_VALUE) { - - } else if (pri == 0) { - - } else { - List i1s = priorities.getValues(pri); - for (Integer i1 : i1s) { - if (used1[i1]) - continue; - List i2diff = differences.get(i1); - for (int i2 = 0; i2 < i2diff.size(); i2++) { - if (i2diff.get(i2) == pri) { - if (used2[i2]) - continue; - used1[i1] = true; - used2[i2] = true; - Statement s1 = ss1.get(i1+off1); - Statement s2 = ss2.get(i2+off2); - - if (objectsLeft != null) { - objectsLeft.add(s1.getObject()); - objectsRight.add(s2.getObject()); - } - addComparable(s1, s2); - break; - } - } - } - } - } - - for (Integer pri : pris) { - if (pri != 0) + if (pri != 0 && !matchFail && unreliableLeft == null) continue; Set s1s = new HashSet(); Set s2s = new HashSet(); @@ -1156,7 +1170,51 @@ public class GraphComparator { } } - + private boolean priorityMatching(List ss1, int off1, int len1, List ss2, int off2, int len2, Integer[] pris, List> differences, MapList priorities, boolean used1[],boolean used2[], Collection objectsLeft, Collection objectsRight, boolean force) throws DatabaseException { + boolean matchFail = false; + for (Integer pri : pris) { + if (pri == Integer.MAX_VALUE) { + + } else if (pri == 0) { + + } else { + List i1s = priorities.getValues(pri); + + for (Integer i1 : i1s) { + if (used1[i1]) + continue; + List i2diff = differences.get(i1); + List matches = new ArrayList(); + for (int i2 = 0; i2 < i2diff.size(); i2++) { + if (i2diff.get(i2) == pri) { + if (used2[i2]) + continue; + matches.add(i2); + } + } + if (matches.size() == 1 || (force && matches.size() > 1)) { + int i2 = matches.get(0); + used1[i1] = true; + used2[i2] = true; + Statement s1 = ss1.get(i1+off1); + Statement s2 = ss2.get(i2+off2); + + if (objectsLeft != null) { + objectsLeft.add(s1.getObject()); + objectsRight.add(s2.getObject()); + } + addComparable(s1, s2); + } else if (matches.size() > 1) { + matchFail = true; + } + } + if (matchFail) + break; + } + } + return matchFail; + } + /** * compares properties, assumes functional relations @@ -1175,6 +1233,9 @@ public class GraphComparator { ss1 = filterNonTested(ss1); ss2 = filterNonTested(ss2); sortStatement(ss1, ss2); + // getStatements(r1, b.HasProperty) returns both instance and asserted statements for the same property relation. + ss1 = filterAssertedDuplicates(r1, ss1); + ss2 = filterAssertedDuplicates(r2, ss2); int i1 = 0; int i2 = 0; @@ -1185,16 +1246,20 @@ public class GraphComparator { break; else { while (i2 < ss2.size()) { - if (DEBUG) System.out.println("Compare Prop diff2 " + printStatement(g,ss2.get(i2))); - addAddition(ss2.get(i2)); + Statement s = ss2.get(i2); + if (DEBUG) System.out.println("Compare Prop diff2 " + printStatement(g,s)); + if (!s.isAsserted(r2)) + addAddition(s); i2++; } break; } } else if (i2 >= ss2.size()) { while (i1 < ss1.size()) { - if (DEBUG) System.out.println("Compare Prop diff1 " + printStatement(g,ss1.get(i1))); - addDeletion(ss1.get(i1)); + Statement s = ss1.get(i1); + if (DEBUG) System.out.println("Compare Prop diff1 " + printStatement(g,s)); + if (!s.isAsserted(r1)) + addDeletion(s); i1++; } break; @@ -1211,25 +1276,41 @@ public class GraphComparator { case 0:{ boolean b1 = g.hasValue(s1.getObject()); boolean b2 = g.hasValue(s2.getObject()); + boolean a1 = s1.isAsserted(r1); + boolean a2 = s2.isAsserted(r2); if (b1 == b2) { if (b1) { -// Object v1 = g.getValue(s1.getObject()); -// Object v2 = g.getValue(s2.getObject()); -// boolean eq = compareValue(v1, v2); + // Literals boolean eq = compareValue(g,b,s1.getObject(), s2.getObject()); if (!eq) { addModification(r1,s1,r2,s2); - if (!s1.isAsserted(r1) && !s2.isAsserted(r2)) + if (!a1 && !a2) addComparable(s1, s2); } } else { - if (!s1.getObject().equals(s1.getSubject()) && !s2.getObject().equals(s2.getSubject())) - compareProps(s1.getObject(), s2.getObject()); + // Non literal properties. + int comp = comparator.compare(g, s1.getObject(), s2.getObject()); + if (comp == ResourceComparator.NO_MATCH) { + addModification(r1,s1,r2,s2); + } else if (comp != ResourceComparator.EXACT_MATCH) { + if (!s1.getObject().equals(s1.getSubject()) && !s2.getObject().equals(s2.getSubject())) { + if (!a1 && !a2) { + // compare props matches objects, so we can call that only for non asserted statements + compareProps(s1.getObject(), s2.getObject()); + } else if (a1 && a2) { + // TODO : compare asserted statements? + } else { + addModification(r1,s1,r2,s2); + } + } else { + addModification(r1,s1,r2,s2); + } + } else { + // Exact match, nothing to do. + } } } else { addModification(r1,s1,r2,s2); - if (!s1.isAsserted(r1) && !s2.isAsserted(r2)) - addComparable(s1, s2); } i1++; i2++; @@ -1237,14 +1318,18 @@ public class GraphComparator { } case -1:{ if (DEBUG) System.out.println("Compare Prop diff1s " + printStatement(g,s1)); - addDeletion(s1); + // Use modification, since deletions do not support asserted statements + addModification(r1,s1,r2,null); + //addDeletion(s1); i1++; break; } case 1:{ if (DEBUG) System.out.println("Compare Prop diff2s " + printStatement(g,s2)); - addAddition(s2); + // Use modification, since additions do not support asserted statements + addModification(r1,null,r2,s2); + //addAddition(s2); i2++; break; }