org.simantics.interop/src/org/simantics/interop/test/TypeComparator.java

   1 package org.simantics.interop.test;\r
   2 \r
   3 import java.util.ArrayList;\r
   4 import java.util.Comparator;\r
   5 \r
   6 import org.simantics.db.ReadGraph;\r
   7 import org.simantics.db.Resource;\r
   8 import org.simantics.db.Statement;\r
   9 import org.simantics.db.exception.DatabaseException;\r
  10 import org.simantics.db.exception.DoesNotContainValueException;\r
  11 import org.simantics.db.exception.ManyObjectsForFunctionalRelationException;\r
  12 import org.simantics.db.exception.ServiceException;\r
  13 import org.simantics.db.exception.ValidationException;\r
  14 import org.simantics.layer0.Layer0;\r
  15 \r
  16 /**\r
  17  * Object comparator that uses type of objects to check if objects are comparable. \r
  18  * \r
  19  * Difference value is amount of properties that have different values.\r
  20  * \r
  21  * @author Marko Luukkainen <marko.luukkainen@vtt.fi>\r
  22  *\r
  23  */\r
  24 public class TypeComparator extends ObjectComparator {\r
  25 \r
  26         \r
  27         ArrayList<Resource> rs1 = new ArrayList<Resource>();\r
  28         ArrayList<Resource> rs2 = new ArrayList<Resource>();\r
  29         \r
  30         @Override\r
  31         public int compare(ReadGraph g, Resource o1, Resource o2) throws DatabaseException{\r
  32                 if (!compareType(g,o1, o2)) {\r
  33                         return (Integer.MAX_VALUE);\r
  34                 }\r
  35                 return propsDiffCount(g,o1, o2);\r
  36         }\r
  37         \r
  38         protected boolean compareType(ReadGraph g,Resource r1, Resource r2) throws ServiceException, ManyObjectsForFunctionalRelationException {\r
  39                 Layer0 l0 = Layer0.getInstance(g);\r
  40                 rs1.addAll(g.getObjects(r1, l0.InstanceOf));\r
  41                 rs2.addAll(g.getObjects(r2, l0.InstanceOf));\r
  42                 if (rs1.size() != rs2.size()) {\r
  43                         rs1.clear();\r
  44                         rs2.clear();\r
  45                         return false;\r
  46                 }\r
  47                 Comparator<Resource> rcomp = getComparator().getResourceComparator();\r
  48                 getComparator().sortResource(rs1, rs2);\r
  49 \r
  50                 for (int i = 0; i < rs1.size(); i++) {\r
  51                         int c = rcomp.compare(rs1.get(i), rs2.get(i));\r
  52                         if (c != 0) {\r
  53                                 rs1.clear();\r
  54                                 rs2.clear();\r
  55                                 return false;\r
  56                         }\r
  57                 }\r
  58                 \r
  59                 rs1.clear();\r
  60                 rs2.clear();\r
  61                 \r
  62                 return true;\r
  63         }\r
  64         \r
  65         protected int propsDiffCount(ReadGraph g, Resource r1, Resource r2) throws ServiceException, DoesNotContainValueException, ValidationException {\r
  66                 Layer0 l0 = Layer0.getInstance(g);\r
  67                 ArrayList<Statement> ss1 = new ArrayList<Statement>();\r
  68                 ArrayList<Statement> ss2 = new ArrayList<Statement>();\r
  69                 ss1.addAll(g.getStatements(r1, l0.HasProperty));\r
  70                 ss2.addAll(g.getStatements(r2, l0.HasProperty));\r
  71                 \r
  72                 Comparator<Statement> scomp = getComparator().getStatementComparator();\r
  73                 \r
  74                 getComparator().sortStatement(ss1, ss2);\r
  75                 \r
  76                 int count = 0;\r
  77                 \r
  78                 int i1 = 0; \r
  79                 int i2 = 0;\r
  80                 \r
  81                 while (true) {\r
  82                         if (i1 >= ss1.size()) {\r
  83                                 if (i2 >= ss2.size())\r
  84                                         break;\r
  85                                 else {\r
  86                                         while (i2 < ss2.size()) {\r
  87                                                 count++;\r
  88                                                 i2++;\r
  89                                         }\r
  90                                         break;\r
  91                                 }\r
  92                         } else if (i2 >= ss2.size()) {\r
  93                                 while (i1 < ss1.size()) {\r
  94                                         count++;\r
  95                                         i1++;\r
  96                                 }\r
  97                                 break;\r
  98                         }\r
  99                         Statement s1 = ss1.get(i1);\r
 100                         Statement s2 = ss2.get(i2);\r
 101                         int c = scomp.compare(s1, s2);\r
 102                         switch (c) {\r
 103                                 case 0:{\r
 104                                         boolean b1 = g.hasValue(s1.getObject());\r
 105                                         boolean b2 = g.hasValue(s2.getObject());\r
 106                                         if (b1 == b2) {\r
 107                                                 if (b1) {\r
 108                                                         Object v1 = g.getValue(s1.getObject());\r
 109                                                         Object v2 = g.getValue(s2.getObject());\r
 110                                                         boolean eq = GraphComparator.compareValue(v1, v2);\r
 111                                                         \r
 112                                                         if (!eq) {\r
 113                                                                 count++;\r
 114                                                         }\r
 115                                                         //System.out.println("Prop count values " + v1 + " " + v2);\r
 116                                                 } else {\r
 117                                                         count += propsDiffCount(g,s1.getObject(), s2.getObject());\r
 118                                                 }\r
 119                                         } else {\r
 120                                                 //System.out.println("Props count structural vs literal");\r
 121                                                 count++;\r
 122                                         }\r
 123                                         i1++;\r
 124                                         i2++;\r
 125                                         break;\r
 126                                 }\r
 127                                 case -1:{\r
 128                                         count++;\r
 129                                         i1++;\r
 130                                         break;\r
 131                                 }\r
 132                                         \r
 133                                 case 1:{\r
 134                                         count++;\r
 135                                         i2++;\r
 136                                         break;\r
 137                                 }\r
 138                         }\r
 139 \r
 140                 }\r
 141                 \r
 142                 ss1.clear();\r
 143                 ss2.clear();\r
 144                 return count;\r
 145         }\r
 146 \r
 147 }\r