}
public void addComparableResources(Resource r1, Resource r2) {
+ if (DEBUG)
+ System.out.println("Preset " + r1 + " = " + r2);
comparableResources.map(r1, r2);
}
public void addComparableResources(BijectionMap<Resource, Resource> matching) {
+ if (DEBUG) {
+ for (Entry<Resource, Resource> entry : matching.getEntries())
+ System.out.println("Preset " + entry.getKey() + " = " + entry.getValue());
+ }
comparableResources.addAll(matching);
}
this.g = g;
this.b = Layer0.getInstance(g);
comparator.setComparator(this);
+ comparator.initialize(g, r1, r2);
Stack<Resource> objectsLeft = new Stack<Resource>();
Stack<Resource> objectsRight = new Stack<Resource>();
// These cases have longer path than one to identified objects.
processUnreliableDeep(unreliableLeft, unreliableRight, objectsLeft, objectsRight);
}
+ if (objectsLeft.isEmpty() && unreliableLeft.size() > 0 && unreliableRight.size() > 0) {
+ // comparison is ending, but we have still unprocessed unidentified resources left.
+ // These cases have longer path than one to identified objects.
+ processUnreliableDeep(unreliableLeft, unreliableRight, objectsLeft, objectsRight);
+ }
}
});
}
for (Statement s : unreliableLeft) {
if (!comparableStatements.containsLeft(s))
- if (s.getObject().getResourceId() == 303248)
- System.out.println();
addDeletion(s);
}
for (Statement s : unreliableRight) {
if (r1.equals(r2))
continue;
-
if (processedResources.contains(r1))
continue;
processedResources.add(r1);
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 (match) {
+ map.map(leftPath, rightPath);
+ break;
+ }
}
}
}
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);
- comparableResources.map(left, right);
+ comparableResources.map(left, right);
}
}
return out;
}
+ public List<Statement> filterAssertedDuplicates(Resource r, List<Statement> in) throws DatabaseException {
+ List<Statement> out = new ArrayList<Statement>();
+ 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 > 1 && 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);
+ }
+
+ }
+ for (Statement s : in) {
+ if (!s.isAsserted(r))
+ out.add(s);
+
+ }
+ return out;
+ }
+
private String printStatement(ReadGraph graph, Statement s) throws DatabaseException {
}
}
- 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);
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;
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;
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++;