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. If objects have no properties, the result is 0 (unreliable).\r
  20  * \r
  21  * \r
  22  * @author Marko Luukkainen <marko.luukkainen@vtt.fi>\r
  23  *\r
  24  */\r
  25 public class TypeComparator extends ResourceComparator {\r
  26 \r
  27         \r
  28         ArrayList<Resource> rs1 = new ArrayList<Resource>();\r
  29         ArrayList<Resource> rs2 = new ArrayList<Resource>();\r
  30         \r
  31         @Override\r
  32         public int compare(ReadGraph g, Resource o1, Resource o2) throws DatabaseException{\r
  33                 if (!compareType(g,o1, o2)) {\r
  34                         return (Integer.MAX_VALUE);\r
  35                 }\r
  36                 return propsDiffCount(g,o1, o2);\r
  37         }\r
  38         \r
  39         protected boolean compareType(ReadGraph g,Resource r1, Resource r2) throws ServiceException, ManyObjectsForFunctionalRelationException {\r
  40                 Layer0 l0 = Layer0.getInstance(g);\r
  41                 rs1.addAll(g.getObjects(r1, l0.InstanceOf));\r
  42                 rs2.addAll(g.getObjects(r2, l0.InstanceOf));\r
  43                 if (rs1.size() != rs2.size()) {\r
  44                         rs1.clear();\r
  45                         rs2.clear();\r
  46                         return false;\r
  47                 }\r
  48                 Comparator<Resource> rcomp = getComparator().getResourceComparator();\r
  49                 getComparator().sortResource(rs1, rs2);\r
  50 \r
  51                 for (int i = 0; i < rs1.size(); i++) {\r
  52                         int c = rcomp.compare(rs1.get(i), rs2.get(i));\r
  53                         if (c != 0) {\r
  54                                 rs1.clear();\r
  55                                 rs2.clear();\r
  56                                 return false;\r
  57                         }\r
  58                 }\r
  59                 \r
  60                 rs1.clear();\r
  61                 rs2.clear();\r
  62                 \r
  63                 return true;\r
  64         }\r
  65         \r
  66         protected int propsDiffCount(ReadGraph g, Resource r1, Resource r2) throws ServiceException, DoesNotContainValueException, ValidationException {\r
  67                 Layer0 l0 = Layer0.getInstance(g);\r
  68                 ArrayList<Statement> ss1 = new ArrayList<Statement>();\r
  69                 ArrayList<Statement> ss2 = new ArrayList<Statement>();\r
  70                 ss1.addAll(g.getStatements(r1, l0.HasProperty));\r
  71                 ss2.addAll(g.getStatements(r2, l0.HasProperty));\r
  72                 \r
  73                 if (ss1.size() == 0 && ss2.size() == 0)\r
  74                         return 0;\r
  75                 \r
  76                 Comparator<Statement> scomp = getComparator().getStatementComparator();\r
  77                 \r
  78                 getComparator().sortStatement(ss1, ss2);\r
  79                 \r
  80                 int count = 1;\r
  81                 \r
  82                 int i1 = 0; \r
  83                 int i2 = 0;\r
  84                 \r
  85                 while (true) {\r
  86                         if (i1 >= ss1.size()) {\r
  87                                 if (i2 >= ss2.size())\r
  88                                         break;\r
  89                                 else {\r
  90                                         while (i2 < ss2.size()) {\r
  91                                                 count++;\r
  92                                                 i2++;\r
  93                                         }\r
  94                                         break;\r
  95                                 }\r
  96                         } else if (i2 >= ss2.size()) {\r
  97                                 while (i1 < ss1.size()) {\r
  98                                         count++;\r
  99                                         i1++;\r
 100                                 }\r
 101                                 break;\r
 102                         }\r
 103                         Statement s1 = ss1.get(i1);\r
 104                         Statement s2 = ss2.get(i2);\r
 105                         if (s1.isAsserted(r1) && s2.isAsserted(r2)) {\r
 106                                 i1++;\r
 107                                 i2++;\r
 108                                 continue;\r
 109                         }\r
 110                         int c = scomp.compare(s1, s2);\r
 111                         switch (c) {\r
 112                                 case 0:{\r
 113                                         boolean b1 = g.hasValue(s1.getObject());\r
 114                                         boolean b2 = g.hasValue(s2.getObject());\r
 115                                         if (b1 == b2) {\r
 116                                                 if (b1) {\r
 117                                                         Object v1 = g.getValue(s1.getObject());\r
 118                                                         Object v2 = g.getValue(s2.getObject());\r
 119                                                         boolean eq = GraphComparator.compareValue(v1, v2);\r
 120                                                         \r
 121                                                         if (!eq) {\r
 122                                                                 count++;\r
 123                                                         }\r
 124                                                         //System.out.println("Prop count values " + v1 + " " + v2);\r
 125                                                 } else {\r
 126                                                         count += propsDiffCount(g,s1.getObject(), s2.getObject());\r
 127                                                 }\r
 128                                         } else {\r
 129                                                 //System.out.println("Props count structural vs literal");\r
 130                                                 count++;\r
 131                                         }\r
 132                                         i1++;\r
 133                                         i2++;\r
 134                                         break;\r
 135                                 }\r
 136                                 case -1:{\r
 137                                         count++;\r
 138                                         i1++;\r
 139                                         break;\r
 140                                 }\r
 141                                         \r
 142                                 case 1:{\r
 143                                         count++;\r
 144                                         i2++;\r
 145                                         break;\r
 146                                 }\r
 147                         }\r
 148 \r
 149                 }\r
 150                 \r
 151                 ss1.clear();\r
 152                 ss2.clear();\r
 153                 return count;\r
 154         }\r
 155 \r
 156 }\r