X-Git-Url: https://gerrit.simantics.org/r/gitweb?a=blobdiff_plain;f=org.simantics.interop%2Fsrc%2Forg%2Fsimantics%2Finterop%2Ftest%2FGraphComparator.java;h=0c5aecc993bed308043f23d19ec997daa979bded;hb=a4bc3eec6c4554096bd819d7cb612011028d254f;hp=6f8c4d1b15e13d10a652dac5551abbb7d0a329e1;hpb=7bd962c96d0a43bbc0fca67e87a1bc877a451fe0;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 6f8c4d1..0c5aecc 100644 --- a/org.simantics.interop/src/org/simantics/interop/test/GraphComparator.java +++ b/org.simantics.interop/src/org/simantics/interop/test/GraphComparator.java @@ -455,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; @@ -695,14 +695,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) { @@ -711,16 +711,24 @@ public class GraphComparator { if (leftPath.getLength() != rightPath.getLength()) continue; if (comparableResources.contains(leftPath.getEnd(), rightPath.getEnd())) { - boolean preds = true; + 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())) { - preds = false; + 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 (preds) { + if (match) { map.map(leftPath, rightPath); break; } @@ -786,6 +794,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); @@ -822,7 +838,7 @@ public class GraphComparator { out.add(s); else { boolean has = false; - if (i > 1 && in.get(i-1).getPredicate().equals(s.getPredicate())) + 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; @@ -830,11 +846,6 @@ public class GraphComparator { out.add(s); } - } - for (Statement s : in) { - if (!s.isAsserted(r)) - out.add(s); - } return out; } @@ -892,8 +903,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); @@ -1072,7 +1083,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++) { @@ -1104,41 +1115,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(); @@ -1186,7 +1168,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 @@ -1248,25 +1274,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++; @@ -1274,14 +1316,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; }