X-Git-Url: https://gerrit.simantics.org/r/gitweb?a=blobdiff_plain;f=org.simantics.interop%2Fsrc%2Forg%2Fsimantics%2Finterop%2Ftest%2FGraphComparator.java;h=e52a3bf296f485d11b88f362bf07ada14b566a41;hb=8f1ee72ae165c01b208423cd2d18a6afc1819a3f;hp=dff6672b86820924f52f0906e6c658498916abb2;hpb=6f66967403916102ef5cb0d564cb357206fb3c69;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 dff6672..e52a3bf 100644 --- a/org.simantics.interop/src/org/simantics/interop/test/GraphComparator.java +++ b/org.simantics.interop/src/org/simantics/interop/test/GraphComparator.java @@ -16,8 +16,10 @@ import java.util.Arrays; import java.util.Collection; import java.util.Collections; import java.util.Comparator; +import java.util.HashMap; import java.util.HashSet; import java.util.List; +import java.util.Map; import java.util.Set; import java.util.Stack; @@ -25,8 +27,8 @@ import org.simantics.db.ReadGraph; import org.simantics.db.Resource; import org.simantics.db.Statement; import org.simantics.db.common.utils.NameUtils; +import org.simantics.db.exception.DatabaseException; import org.simantics.db.exception.DoesNotContainValueException; -import org.simantics.db.exception.ManyObjectsForFunctionalRelationException; import org.simantics.db.exception.ServiceException; import org.simantics.db.exception.ValidationException; import org.simantics.layer0.Layer0; @@ -48,10 +50,12 @@ import org.simantics.utils.datastructures.Pair; */ public class GraphComparator { - + private Resource r1; + private Resource r2; private List traversed = new ArrayList(); // list of relations that are traversed (and tested) private List tested = new ArrayList(); // list of relations that are tested, but not traversed private List nonTraversed = new ArrayList(); // list of relations that are not traversed + private List nonTested = new ArrayList(); // list of relations that are not tested private List changes1 = new ArrayList(); private List changes2 = new ArrayList(); @@ -60,21 +64,51 @@ public class GraphComparator { private Set changes2Set = new HashSet(); private Set> modificationsSet = new HashSet>(); - private BijectionMap comparable = new BijectionMap(); + private BijectionMap comparableStatements = new BijectionMap(); + private BijectionMap comparableResources = new BijectionMap(); + + private ResourceComparator comparator; + + private Comparator scomp = new PredicateComparator(); + private Comparator rcomp = new ResComparator(); // runtime attributes private ReadGraph g; private Layer0 b; - ArrayList rs1 = new ArrayList(); - ArrayList rs2 = new ArrayList(); + public GraphComparator(Resource r1, Resource r2) { + this.r1 = r1; + this.r2 = r2; + comparator = new TypeComparator(); + } + + public GraphComparator(Resource r1, Resource r2, ResourceComparator comparator) { + this.r1 = r1; + this.r2 = r2; + this.comparator = comparator; + } + ArrayList ss1 = new ArrayList(); ArrayList ss2 = new ArrayList(); - Comparator scomp = new PredicateComparator(); - Comparator rcomp = new ResourceComparator(); - + + + public Comparator getResourceComparator() { + return rcomp; + } + + public Comparator getStatementComparator() { + return scomp; + } + + public Resource getR1() { + return r1; + } + + public Resource getR2() { + return r2; + } public void addTraversed(Resource rel) { traversed.add(rel); @@ -100,35 +134,57 @@ public class GraphComparator { tested.addAll(rels); } + public void addNonTested(Resource rel) { + nonTested.add(rel); + } + + public void addNonTested(Collection rels) { + nonTested.addAll(rels); + } + + public void addComparableResources(Resource r1, Resource r2) { + comparableResources.map(r1, r2); + } + + public void addComparableResources(BijectionMap matching) { + comparableResources.addAll(matching); + } + public void clearRels() { traversed.clear(); tested.clear(); + nonTraversed.clear(); + nonTested.clear(); } - public void test(ReadGraph g, Resource r1, Resource r2) throws ServiceException, DoesNotContainValueException, ValidationException { + public void test(ReadGraph g) throws DatabaseException { this.g = g; this.b = Layer0.getInstance(g); + comparator.setComparator(this); - changes1Set.clear(); - changes2Set.clear(); - modificationsSet.clear(); - changes1.clear(); - changes2.clear(); - modifications.clear(); + Stack objectsLeft = new Stack(); + Stack objectsRight = new Stack(); + objectsLeft.push(r1); + objectsRight.push(r2); - Stack stack1 = new Stack(); - Stack stack2 = new Stack(); - stack1.push(r1); - stack2.push(r2); List ss1 = new ArrayList(); List ss2 = new ArrayList(); - while (!stack1.isEmpty()) { - r1 = stack1.pop(); - r2 = stack2.pop(); + Set unreliableLeft = new HashSet(); + Set unreliableRight = new HashSet(); + + while (!objectsLeft.isEmpty()) { + Resource r1 = objectsLeft.pop(); + Resource r2 = objectsRight.pop(); + + if (comparableResources.contains(r1, r2)) { + //System.out.println("already tested " + NameUtils.getSafeName(g, r1) + " " + NameUtils.getSafeName(g, r2)); + continue; + } + comparableResources.map(r1, r2); - System.out.println("test " + NameUtils.getSafeName(g, r1) + " " + NameUtils.getSafeName(g, r2)); + //System.out.println("test " + NameUtils.getSafeName(g, r1) + " " + NameUtils.getSafeName(g, r2)); compareProps(r1, r2); for (Resource rel : tested) { @@ -138,8 +194,10 @@ public class GraphComparator { ss2 = filterAsserted(r2, ss2); ss1 = filterTraversed(ss1); ss2 = filterTraversed(ss2); + ss1 = filterNonTested(ss1); + ss2 = filterNonTested(ss2); - compareStatement(ss1, ss2, null, null); + compareStatements(ss1, ss2, null, null,null,null); ss1.clear(); ss2.clear(); } @@ -149,28 +207,136 @@ public class GraphComparator { ss2.addAll(g.getStatements(r2, rel)); ss1 = filterAsserted(r1, ss1); ss2 = filterAsserted(r2, ss2); - compareStatement(ss1, ss2, stack1, stack2); + compareStatements(ss1, ss2, objectsLeft, objectsRight,unreliableLeft,unreliableRight); ss1.clear(); ss2.clear(); + + } + } + MapList subjectLeft = new MapList(); + MapList subjectRight = new MapList(); + MapList objectLeft = new MapList(); + MapList objectRight = new MapList(); + + for (Statement s : unreliableLeft) { + subjectLeft.add(s.getSubject(),s); + objectLeft.add(s.getObject(),s); + } + for (Statement s : unreliableRight) { + subjectRight.add(s.getSubject(),s); + objectRight.add(s.getObject(),s); + } + + for (Resource ol : objectLeft.getKeys()) { + + // all statements to the left side object + List left = objectLeft.getValues(ol); + // all subjects that have statements to the left side object (ol) + Set sLeft = new HashSet(); + // all matching subjects on the right side + Set sRight = new HashSet(); + for (Statement s : left) { + sLeft.add(s.getSubject()); + sRight.add(comparableResources.getRight(s.getSubject())); + } + // all objects that subjects on the right side point to. Object left has its matching resource among these, if it has matching resource + MapList possibleOR = new MapList(); + for (Resource sr : sRight) { + for (Statement s : subjectRight.getValues(sr)) + possibleOR.add(s.getObject(),s); + } + + // filter possible right side objects to those that have same amount of statements as the left side object + for (Resource or : possibleOR.getKeys().toArray(new Resource[possibleOR.getKeys().size()])) { + List right = possibleOR.getValues(or); + if (right.size() != left.size()) + possibleOR.remove(or); + + } + + // check for matching statements (comparable subjects, matching predicates) + MapList matchingOR = new MapList(); // list of objects that have matching statements + Map> matchingStatements = new HashMap>(); // matching statements + for (Resource or : possibleOR.getKeys()) { + List right = possibleOR.getValues(or); + int iLeft[] = new int[left.size()]; + int iRight[] = new int[right.size()]; + + for (int i = 0; i < left.size(); i++) { + iLeft[i] = -1; + iRight[i] = -1; + } + + for (int l = 0; l < left.size(); l++) { + Statement ls = left.get(l); + for (int r = 0; r < right.size(); r++) { + if (iRight[r] >= 0) + continue; + Statement rs = right.get(r); + if (!comparableResources.contains(ls.getSubject(), rs.getSubject())) + continue; + if (rcomp.compare(ls.getPredicate(),rs.getPredicate()) == 0) { + iLeft[l] = r; + iRight[r] = l; + break; + } + } + + } + boolean success = true; + for (int i = 0; i < left.size(); i++) { + if (iLeft[i] < 0) { + success = false; + break; + } + if (iRight[i] < 0) { + success = false; + break; + } + + } + if (success) { + for (Statement s : right) + matchingOR.add(or,s); + matchingStatements.put(or, new Pair(iLeft, iRight)); + } + } + // if there is only one matching right side object, we have found a match + if (matchingOR.getKeySize() == 1) { + Resource or = matchingOR.getKeys().iterator().next(); + List right = matchingOR.getValues(or); + Pair indices = matchingStatements.get(or); + + comparableResources.map(ol, or); + for (int l = 0; l < left.size(); l++) { + int r = indices.first[l]; + comparableStatements.map(left.get(l), right.get(r)); + } + } + + } + + for (Statement s : unreliableLeft) { + if (!comparableStatements.containsLeft(s)) + addDeletion(s); } + for (Statement s : unreliableRight) { + if (!comparableStatements.containsRight(s)) + addAddition(s); + } + + } - public BijectionMap getComparable() { - return comparable; + public BijectionMap getComparableStatements() { + return comparableStatements; } public GraphChanges getChanges() { -// List deletions = new ArrayList(); -// List additions = new ArrayList(); -// deletions.addAll(changes1); -// additions.addAll(changes2); -// Collections.sort(deletions, new FullStatementComparator()); -// Collections.sort(additions, new FullStatementComparator()); -// return new GraphChanges(deletions, additions, modifications); - return new GraphChanges(changes1,changes2,modifications); + return new GraphChanges(r1,r2,changes1,changes2,modifications,comparableResources); } private List filterAsserted(Resource r, Collection in) throws ServiceException { @@ -187,11 +353,21 @@ public class GraphComparator { return NameUtils.getSafeName(graph, s.getSubject()) + " " + NameUtils.getSafeName(graph, s.getPredicate()) + " " + NameUtils.getSafeName(graph, s.getObject()); } - private List filterTraversed(Collection in) throws ServiceException { + private List filterTraversed(List in) throws ServiceException { + return filter(traversed, in); + } + + private List filterNonTested(List in) throws ServiceException { + return filter(nonTested, in); + } + + private List filter(Collection toFilter, List in) throws ServiceException { + if (toFilter.size() == 0) + return in; List out = new ArrayList(); for (Statement s : in) { boolean usable = true; - for (Resource r : traversed) { + for (Resource r : toFilter) { if (g.isSubrelationOf(s.getPredicate(),r)) { usable = false; break; @@ -228,9 +404,87 @@ public class GraphComparator { } } - private void compareStatement(List ss1, List ss2, Stack stack1, Stack stack2) throws ServiceException, DoesNotContainValueException, ValidationException { - Collections.sort(ss1, scomp); - Collections.sort(ss2, scomp); + public void sortStatement(List list1, List list2) { + sortStatement(list1, list2, scomp); + } + + public void sortStatement(List list1, List list2, Comparator scomp) { + Collections.sort(list1,scomp); + Collections.sort(list2,scomp); + + List sorted1 = new ArrayList(list1.size()); + List sorted2 = new ArrayList(list2.size()); + sorted1.addAll(list1); + sorted2.addAll(list2); + + int ss1 = 0; + int ss2 = 0; + for (int i = 0; i < list1.size(); ) { + Statement s1 = list1.get(i); + int same1 = sameRel(list1, i); + for (int j = 0; j < list2.size(); j++) { + Statement s2 = list2.get(j); + if (scomp.compare(s1, s2) == 0) { + int same2 = sameRel(list2, j); + copy(sorted1,ss1,list1,i,same1); + ss1 += same1; + copy(sorted2,ss2,list2,j,same2); + ss2 += same2; + break; + } + } + i+= same1; + } + if (ss1 < sorted1.size()) { + for (Statement s : list1) { + if (!sorted1.contains(s)) { + sorted1.set(ss1,s); + ss1++; + } + } + } + if (ss2 < sorted2.size()) { + for (Statement s : list2) { + if (!sorted2.contains(s)) { + sorted2.set(ss2,s); + ss2++; + } + } + } + + list1.clear(); + list2.clear(); + list1.addAll(sorted1); + list2.addAll(sorted2); + } + + public void copy(List to, int toIndex, List from, int fromIndex, int amount) { + for (int i = 0; i < amount; i++) { + to.set(toIndex + i, from.get(fromIndex+ i)); + } + } + + public void sortResource(List list1, List list2) { + Collections.sort(list1,rcomp); + int js = 0; + for (int i = 0; i < list1.size(); i++) { + Resource s1 = list1.get(i); + for (int j = js; j < list2.size(); j++) { + Resource s2 = list2.get(j); + if (rcomp.compare(s1, s2) == 0) { + Resource t = list2.get(js); + list2.set(js, s2); + list2.set(j, t); + break; + } + } + js++; + + } + } + + private void compareStatements(List ss1, List ss2, Stack objectsLeft, Stack objectsRight, Collection unreliableLeft, Collection unreliableRight) throws DatabaseException { + sortStatement(ss1, ss2); int i1 = 0; int i2 = 0; @@ -241,7 +495,7 @@ public class GraphComparator { break; } else { while (i2 < ss2.size()) { - System.out.println("Compare Statement diff2 " + printStatement(g,ss2.get(i2))); + System.out.println("Compare Statements diff2 " + printStatement(g,ss2.get(i2))); addAddition(ss2.get(i2)); i2++; @@ -250,7 +504,7 @@ public class GraphComparator { } } else if (i2 >= ss2.size()) { while (i1 < ss1.size()) { - System.out.println("Compare Statement diff1 " + printStatement(g,ss1.get(i1))); + System.out.println("Compare Statements diff1 " + printStatement(g,ss1.get(i1))); addDeletion(ss1.get(i1)); i1++; } @@ -260,18 +514,18 @@ public class GraphComparator { int same2 = sameRel(ss2, i2); int c = rcomp.compare(ss1.get(i1).getPredicate(),ss2.get(i2).getPredicate()); if (c == 0) { - compareObject(ss1, i1, same1, ss2, i2, same2,stack1,stack2); + compareStatements(ss1, i1, same1, ss2, i2, same2,objectsLeft,objectsRight,unreliableLeft,unreliableRight); i1+=same1; i2+=same2; } else if (c < 0) { for (int i = 0; i < same1; i++) { - System.out.println("Compare Statement diff1 " + printStatement(g,ss1.get(i+i1))); + System.out.println("Compare Statements diff1 " + printStatement(g,ss1.get(i+i1))); addDeletion(ss1.get(i+i1)); } i1 += same1; } else { for (int i = 0; i < same2; i++) { - System.out.println("Compare Statement diff2 " + printStatement(g,ss2.get(i+i2))); + System.out.println("Compare Statements diff2 " + printStatement(g,ss2.get(i+i2))); addAddition(ss2.get(i+i2)); } @@ -281,6 +535,8 @@ public class GraphComparator { } } + + private int sameRel(List statements, int off) { if (statements.size() <= off) return 0; @@ -296,8 +552,17 @@ public class GraphComparator { } + private int compareObject(Resource o1, Resource o2) throws DatabaseException { + if (comparableResources.contains(o1, o2)) + return (-1); + if (comparableResources.containsLeft(o1)) + return Integer.MAX_VALUE; + if (comparableResources.containsRight(o2)) + return Integer.MAX_VALUE; + return comparator.compare(g, o1, o2); + } - private void compareObject(List ss1, int off1, int len1, List ss2, int off2, int len2, Stack stack1, Stack stack2) throws ServiceException, DoesNotContainValueException, ValidationException { + private void compareStatements(List ss1, int off1, int len1, List ss2, int off2, int len2, Collection objectsLeft, Collection objectsRight, Collection unreliableLeft, Collection unreliableRight) throws DatabaseException { boolean[] used1 = new boolean[len1]; for (int i = 0; i < used1.length; i++) { used1[i] = false; @@ -312,15 +577,11 @@ public class GraphComparator { List> differences = new ArrayList>(); for (int i1 = off1; i1 < off1 + len1; i1++) { Statement s1 = ss1.get(i1); - //Map differences = new HashMap(); List diff = new ArrayList(); for (int i2 = off2; i2 < off2 + len2; i2++) { Statement s2 = ss2.get(i2); - if (!compareType(s1.getObject(), s2.getObject())) { - diff.add(Integer.MAX_VALUE); - continue; - } - diff.add(propsDiffCount(s1.getObject(), s2.getObject())); + int d = compareObject(s1.getObject(), s2.getObject()); + diff.add(d); } differences.add(diff); } @@ -337,8 +598,47 @@ public class GraphComparator { Arrays.sort(pris); for (Integer pri : pris) { - if (pri == Integer.MAX_VALUE) + 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()); + + } + comparableStatements.map(s1, s2); + //comparableResources.map(s1.getObject(), s2.getObject()); + break; + } + } + } + } + } + + for (Integer pri : pris) { + if (pri != 0) continue; + Set s1s = new HashSet(); + Set s2s = new HashSet(); + Set s1i = new HashSet(); + Set s2i = new HashSet(); List i1s = priorities.getValues(pri); for (Integer i1 : i1s) { if (used1[i1]) @@ -348,28 +648,24 @@ public class GraphComparator { if (i2diff.get(i2) == pri) { if (used2[i2]) continue; - used1[i1] = true; - used2[i2] = true; - if (stack1 != null) { - stack1.add(ss1.get(i1+off1).getObject()); - stack2.add(ss2.get(i2+off2).getObject()); - } else { - // TODO : how should we report non traversed differences - // using compareProps assumes that referenced objects are the same (references are not different) - // using propsDiffCount assumes that objects are different, and cannot report changes in referred object. - - -// int diff = propsDiffCount(ss1.get(i1+off1).getObject(), ss2.get(i2+off2).getObject()); -// if (diff != 0) { -// //changes1.add(ss1.get(i1+off1)); -// //changes2.add(ss2.get(i2+off2)); -// modifies.add(new Pair(ss1.get(i1+off1), ss2.get(i2+off2))); -// } - } - break; + Statement s1 = ss1.get(i1+off1); + Statement s2 = ss2.get(i2+off2); + s1s.add(s1); + s2s.add(s2); + s1i.add(i1); + s2i.add(i2); } } } + if (unreliableLeft != null) { + unreliableLeft.addAll(s1s); + unreliableRight.addAll(s2s); + } + for (Integer i : s1i) + used1[i] = true; + for (Integer i : s2i) + used2[i] = true; + } for (int i1 = off1; i1 < off1 + len1; i1++) { if (!used1[i1-off1]) { @@ -385,30 +681,7 @@ public class GraphComparator { } } - private boolean compareType(Resource r1, Resource r2) throws ServiceException, ManyObjectsForFunctionalRelationException { - rs1.addAll(g.getObjects(r1, b.InstanceOf)); - rs2.addAll(g.getObjects(r2, b.InstanceOf)); - if (rs1.size() != rs2.size()) { - rs1.clear(); - rs2.clear(); - return false; - } - Collections.sort(rs1, rcomp); - Collections.sort(rs2, rcomp); - for (int i = 0; i < rs1.size(); i++) { - int c = rcomp.compare(rs1.get(i), rs2.get(i)); - if (c != 0) { - rs1.clear(); - rs2.clear(); - return false; - } - } - - rs1.clear(); - rs2.clear(); - - return true; - } + /** * compares properties, assumes functional relations @@ -423,8 +696,9 @@ public class GraphComparator { ArrayList ss2 = new ArrayList(); ss1.addAll(g.getStatements(r1, b.HasProperty)); ss2.addAll(g.getStatements(r2, b.HasProperty)); - Collections.sort(ss1, scomp); - Collections.sort(ss2, scomp); + sortStatement(ss1, ss2); +// Collections.sort(ss1, scomp); +// Collections.sort(ss2, scomp); int i1 = 0; int i2 = 0; @@ -460,37 +734,19 @@ public class GraphComparator { if (b1) { Object v1 = g.getValue(s1.getObject()); Object v2 = g.getValue(s2.getObject()); - boolean eq = false; - if (v1 instanceof Object[] && v2 instanceof Object[]) - eq = Arrays.deepEquals((Object[])v1, (Object[])v2); - else if (v1 instanceof int[] && v2 instanceof int[]) - eq = Arrays.equals((int[])v1, (int[])v2); - else if (v1 instanceof float[] && v2 instanceof float[]) - eq = Arrays.equals((float[])v1, (float[])v2); - else if (v1 instanceof double[] && v2 instanceof double[]) - eq = Arrays.equals((double[])v1, (double[])v2); - else if (v1 instanceof long[] && v2 instanceof long[]) - eq = Arrays.equals((long[])v1, (long[])v2); - else if (v1 instanceof byte[] && v2 instanceof byte[]) - eq = Arrays.equals((byte[])v1, (byte[])v2); - else if (v1 instanceof boolean[] && v2 instanceof boolean[]) - eq = Arrays.equals((boolean[])v1, (boolean[])v2); - else - eq = v1.equals(v2); + boolean eq = compareValue(v1, v2); if (!eq) { - //changes1.add(s1); - //changes2.add(s2); addModification(s1, s2); - comparable.map(s1, s2); + comparableStatements.map(s1, s2); + comparableResources.map(s1.getObject(),s2.getObject()); } } else { compareProps(s1.getObject(), s2.getObject()); } } else { - //changes1.add(s1); - //changes2.add(s2); addModification(s1, s2); - comparable.map(s1, s2); + comparableStatements.map(s1, s2); + comparableResources.map(s1.getObject(),s2.getObject()); } i1++; i2++; @@ -519,99 +775,24 @@ public class GraphComparator { } - private int propsDiffCount(Resource r1, Resource r2) throws ServiceException, DoesNotContainValueException, ValidationException { - ArrayList ss1 = new ArrayList(); - ArrayList ss2 = new ArrayList(); - ss1.addAll(g.getStatements(r1, b.HasProperty)); - ss2.addAll(g.getStatements(r2, b.HasProperty)); - //System.out.println("Props count " + GraphUtils.getReadableName(g, r1) + " " + GraphUtils.getReadableName(g, r2)); - Collections.sort(ss1, scomp); - Collections.sort(ss2, scomp); - - int count = 0; - - int i1 = 0; - int i2 = 0; - - while (true) { - if (i1 >= ss1.size()) { - if (i2 >= ss2.size()) - break; - else { - while (i2 < ss2.size()) { - count++; - i2++; - } - break; - } - } else if (i2 >= ss2.size()) { - while (i1 < ss1.size()) { - count++; - i1++; - } - break; - } - Statement s1 = ss1.get(i1); - Statement s2 = ss2.get(i2); - int c = scomp.compare(s1, s2); - switch (c) { - case 0:{ - boolean b1 = g.hasValue(s1.getObject()); - boolean b2 = g.hasValue(s2.getObject()); - if (b1 == b2) { - if (b1) { - Object v1 = g.getValue(s1.getObject()); - Object v2 = g.getValue(s2.getObject()); - boolean eq = false; - if (v1 instanceof Object[] && v2 instanceof Object[]) - eq = Arrays.deepEquals((Object[])v1, (Object[])v2); - else if (v1 instanceof int[] && v2 instanceof int[]) - eq = Arrays.equals((int[])v1, (int[])v2); - else if (v1 instanceof float[] && v2 instanceof float[]) - eq = Arrays.equals((float[])v1, (float[])v2); - else if (v1 instanceof double[] && v2 instanceof double[]) - eq = Arrays.equals((double[])v1, (double[])v2); - else if (v1 instanceof long[] && v2 instanceof long[]) - eq = Arrays.equals((long[])v1, (long[])v2); - else if (v1 instanceof byte[] && v2 instanceof byte[]) - eq = Arrays.equals((byte[])v1, (byte[])v2); - else if (v1 instanceof boolean[] && v2 instanceof boolean[]) - eq = Arrays.equals((boolean[])v1, (boolean[])v2); - else - eq = v1.equals(v2); - if (!eq) { - count++; - } - //System.out.println("Prop count values " + v1 + " " + v2); - } else { - count += propsDiffCount(s1.getObject(), s2.getObject()); - } - } else { - //System.out.println("Props count structural vs literal"); - count++; - } - i1++; - i2++; - break; - } - case -1:{ - count++; - i1++; - break; - } - - case 1:{ - count++; - i2++; - break; - } - } - - } - - ss1.clear(); - ss2.clear(); - return count; + + public static boolean compareValue(Object v1, Object v2) { + if (v1 instanceof Object[] && v2 instanceof Object[]) + return Arrays.deepEquals((Object[])v1, (Object[])v2); + else if (v1 instanceof int[] && v2 instanceof int[]) + return Arrays.equals((int[])v1, (int[])v2); + else if (v1 instanceof float[] && v2 instanceof float[]) + return Arrays.equals((float[])v1, (float[])v2); + else if (v1 instanceof double[] && v2 instanceof double[]) + return Arrays.equals((double[])v1, (double[])v2); + else if (v1 instanceof long[] && v2 instanceof long[]) + return Arrays.equals((long[])v1, (long[])v2); + else if (v1 instanceof byte[] && v2 instanceof byte[]) + return Arrays.equals((byte[])v1, (byte[])v2); + else if (v1 instanceof boolean[] && v2 instanceof boolean[]) + return Arrays.equals((boolean[])v1, (boolean[])v2); + else + return v1.equals(v2); } @@ -619,6 +800,8 @@ public class GraphComparator { public class PredicateComparator implements Comparator { @Override public int compare(Statement o1, Statement o2) { + if (comparableResources.contains(o1.getPredicate(), o2.getPredicate())) + return 0; if (o1.getPredicate().getResourceId() < o2.getPredicate().getResourceId()) return -1; if (o1.getPredicate().getResourceId() > o2.getPredicate().getResourceId()) @@ -627,7 +810,33 @@ public class GraphComparator { } } - public class FullStatementComparator implements Comparator { + public class SubjectComparator implements Comparator { + @Override + public int compare(Statement o1, Statement o2) { + if (comparableResources.contains(o1.getSubject(), o2.getSubject())) + return 0; + if (o1.getSubject().getResourceId() < o2.getSubject().getResourceId()) + return -1; + if (o1.getSubject().getResourceId() > o2.getSubject().getResourceId()) + return 1; + return 0; + } + } + + public class ObjectComparator implements Comparator { + @Override + public int compare(Statement o1, Statement o2) { + if (comparableResources.contains(o1.getObject(), o2.getObject())) + return 0; + if (o1.getObject().getResourceId() < o2.getObject().getResourceId()) + return -1; + if (o1.getObject().getResourceId() > o2.getObject().getResourceId()) + return 1; + return 0; + } + } + + public static class FullStatementComparator implements Comparator { @Override public int compare(Statement o1, Statement o2) { if (o1.getSubject().getResourceId() < o2.getSubject().getResourceId()) @@ -648,9 +857,11 @@ public class GraphComparator { - public class ResourceComparator implements Comparator { + public class ResComparator implements Comparator { @Override public int compare(Resource o1, Resource o2) { + if (comparableResources.contains(o1, o2)) + return 0; if (o1.getResourceId() < o2.getResourceId()) return -1; if (o1.getResourceId() > o2.getResourceId()) @@ -658,4 +869,6 @@ public class GraphComparator { return 0; } } + + }