Only pair non asserted property statements.

[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 ac39e2f4f8f5d3b92c2176500c8751e31f8775d7..d24509395633f7471114302a9815d2a66ed108eb 100644 (file)
--- a/org.simantics.interop/src/org/simantics/interop/test/GraphComparator.java
+++ b/org.simantics.interop/src/org/simantics/interop/test/GraphComparator.java
@@ -52,7 +52,7 @@ import org.simantics.utils.datastructures.Pair;
  */
 public class GraphComparator {
        
-       private static final boolean DEBUG = true;
+       private static final boolean DEBUG = false;
 
        private Resource r1;
        private Resource r2;
@@ -308,8 +308,6 @@ public class GraphComparator {
                        
                        if (r1.equals(r2))
                                continue;
-                       if (r1.getResourceId() == 610446L)
-                               System.out.println();
                        if (processedResources.contains(r1))
                                continue;
                        processedResources.add(r1);
@@ -713,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;
+                                       }
                                }
                        }
                }
@@ -789,8 +802,6 @@ public class GraphComparator {
                                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);
-                               if (left.getResourceId() == 610381L)
-                                       System.out.println();
                                comparableResources.map(left, right);
                        }
                }
@@ -807,6 +818,31 @@ public class GraphComparator {
                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 {
@@ -860,8 +896,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);
@@ -1173,6 +1209,9 @@ public class GraphComparator {
                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;
@@ -1213,25 +1252,38 @@ 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.
+                                                       if (comparator.compare(g, s1.getObject(), s2.getObject()) != ResourceComparator.NO_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 {
+                                                               addModification(r1,s1,r2,s2);
+                                                       }
                                                }
                                        } else {
                                                addModification(r1,s1,r2,s2);
-                                               if (!s1.isAsserted(r1) && !s2.isAsserted(r2))
-                                                       addComparable(s1, s2);
                                        }
                                        i1++;
                                        i2++;