Remove residual code that maps different literals.

[simantics/interop.git] / org.simantics.interop / src / org / simantics / interop / test / GraphComparator.java

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 ba9bdf099397a90a8a2bc423c26d24354a29a2bf..15b8c2c7e3cb1ef764e8e5915db059d49cabfc90 100644 (file)
--- a/org.simantics.interop/src/org/simantics/interop/test/GraphComparator.java
+++ b/org.simantics.interop/src/org/simantics/interop/test/GraphComparator.java
@@ -711,8 +711,23 @@ 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 (match) {
+                                               map.map(leftPath, rightPath);
+                                               break;
+                                       }
                                }
                        }
                }
@@ -782,6 +797,8 @@ public class GraphComparator {
        }
        
        private void addComparable(Resource left, Resource right) throws DatabaseException {
+               if (left.getResourceId() == 225745 || right.getResourceId() == 225745)
+                       System.out.println();
                if(!comparableResources.contains(left, right)) {
                        if (comparableResources.containsLeft(left)||comparableResources.containsRight(right)) {
                                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.");
@@ -881,8 +898,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);
@@ -1239,9 +1256,7 @@ public class GraphComparator {
                                        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 = compareValue(v1, v2);
+                                                       // Literals
                                                        boolean eq = compareValue(g,b,s1.getObject(), s2.getObject());
                                                        if (!eq) {
                                                                addModification(r1,s1,r2,s2);
@@ -1249,13 +1264,19 @@ public class GraphComparator {
                                                                        addComparable(s1, s2);
                                                        }
                                                } else {
-                                                       if (!s1.getObject().equals(s1.getSubject()) && !s2.getObject().equals(s2.getSubject()))
-                                                               compareProps(s1.getObject(), s2.getObject());
+                                                       // Non literal properties.
+                                                       if (comparator.compare(g, s1.getObject(), s2.getObject()) != ResourceComparator.NO_MATCH) {
+                                                               if (!s1.getObject().equals(s1.getSubject()) && !s2.getObject().equals(s2.getSubject()))
+                                                                       // TODO compare props matches objects, so this is questionable. 
+                                                                       compareProps(s1.getObject(), s2.getObject());
+                                                               else
+                                                                       addModification(r1,s1,r2,s2);
+                                                       } else {
+                                                               addModification(r1,s1,r2,s2);
+                                                       }
                                                }
                                        } else {
                                                addModification(r1,s1,r2,s2);
-                                               if (!s1.isAsserted(r1) && !s2.isAsserted(r2))
-                                                       addComparable(s1, s2);
                                        }
                                        i1++;
                                        i2++;