// 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;
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());
}
- private boolean hasMatchingPaths(Set<Path> leftPaths, Set<Path> rightPaths) {
+ private boolean hasMatchingPaths(Set<Path> leftPaths, Set<Path> rightPaths) throws DatabaseException {
if (leftPaths.size() != rightPaths.size())
return false;
BijectionMap<Path,Path> map = getMatchingPaths(leftPaths, rightPaths);
return map.size() == leftPaths.size();
}
- private BijectionMap<Path,Path> getMatchingPaths(Set<Path> leftPaths, Set<Path> rightPaths) {
+ private BijectionMap<Path,Path> getMatchingPaths(Set<Path> leftPaths, Set<Path> rightPaths) throws DatabaseException {
BijectionMap<Path,Path> map = new BijectionMap<Path, Path>();
for (Path leftPath : leftPaths) {
for (Path rightPath : rightPaths) {
match = false;
break;
}
+ if (comparator.compare(g, sl.getObject(), sr.getObject()) == ResourceComparator.NO_MATCH) {
+ match = false;
+ break;
+ }
}
if (match) {
map.map(leftPath, rightPath);
return new GraphChanges(r1,r2,changes1,changes2,modifications,comparableResources);
}
+ public List<Statement> getChanges1() {
+ return changes1;
+ }
+
+ public List<Statement> getChanges2() {
+ return changes2;
+ }
+
private void addComparable(Statement left, Statement right) throws DatabaseException {
addComparable(left.getObject(), right.getObject());
comparableStatements.map(left, right);
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;
out.add(s);
}
- }
- for (Statement s : in) {
- if (!s.isAsserted(r))
- out.add(s);
-
}
return out;
}
for (int i = 0; i < used2.length; i++) {
used2[i] = false;
}
-
+
// left, right, difference
List<List<Integer>> differences = new ArrayList<List<Integer>>();
for (int i1 = off1; i1 < off1 + len1; i1++) {
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<Integer> i1s = priorities.getValues(pri);
- for (Integer i1 : i1s) {
- if (used1[i1])
- continue;
- List<Integer> 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<Statement> s1s = new HashSet<Statement>();
Set<Statement> s2s = new HashSet<Statement>();
}
}
-
+ private boolean priorityMatching(List<Statement> ss1, int off1, int len1, List<Statement> ss2, int off2, int len2, Integer[] pris, List<List<Integer>> differences, MapList<Integer, Integer> priorities, boolean used1[],boolean used2[], Collection<Resource> objectsLeft, Collection<Resource> objectsRight, boolean force) throws DatabaseException {
+ boolean matchFail = false;
+ for (Integer pri : pris) {
+ if (pri == Integer.MAX_VALUE) {
+
+ } else if (pri == 0) {
+
+ } else {
+ List<Integer> i1s = priorities.getValues(pri);
+
+ for (Integer i1 : i1s) {
+ if (used1[i1])
+ continue;
+ List<Integer> i2diff = differences.get(i1);
+ List<Integer> matches = new ArrayList<Integer>();
+ 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
}
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;
}
Code Review / simantics / interop.git / blobdiff