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

   1 package org.simantics.interop.test;
   2
   3 import java.util.ArrayList;
   4 import java.util.Comparator;
   5
   6 import org.simantics.db.ReadGraph;
   7 import org.simantics.db.Resource;
   8 import org.simantics.db.Statement;
   9 import org.simantics.db.exception.DatabaseException;
  10 import org.simantics.layer0.Layer0;
  11
  12 /**
  13  * Object comparator that uses type of objects to check if objects are comparable.
  14  *
  15  * Difference value is amount of properties that have different values. If objects have no properties, the result is 0 (unreliable).
  16  *
  17  *
  18  * @author Marko Luukkainen <marko.luukkainen@vtt.fi>
  19  *
  20  */
  21 public class TypeComparator extends ResourceComparator {
  22
  23
  24         ArrayList<Resource> rs1 = new ArrayList<Resource>();
  25         ArrayList<Resource> rs2 = new ArrayList<Resource>();
  26
  27         @Override
  28         public int compare(ReadGraph g, Resource o1, Resource o2, boolean local) throws DatabaseException {
  29                 if (o1.equals(o2)) {
  30                         return EXACT_MATCH;
  31                 }
  32                 return compare(g, o1, o2);
  33         }
  34
  35         @Override
  36         public int compare(ReadGraph g, Resource o1, Resource o2) throws DatabaseException{
  37                 if (!compareType(g,o1, o2)) {
  38                         return NO_MATCH;
  39                 }
  40                 return propsDiffCount(g,o1, o2);
  41         }
  42
  43         /**
  44          * Compares resources based on L0.InstaceOf relations.
  45          * If there are no L0.InstanceOf relations, uses ResourceComparator for comparison.
  46          *
  47          * @param g
  48          * @param r1
  49          * @param r2
  50          * @return
  51          * @throws DatabaseException
  52          */
  53         protected boolean compareType(ReadGraph g,Resource r1, Resource r2) throws DatabaseException {
  54                 Layer0 l0 = Layer0.getInstance(g);
  55                 rs1.addAll(g.getObjects(r1, l0.InstanceOf));
  56                 rs2.addAll(g.getObjects(r2, l0.InstanceOf));
  57                 if (rs1.size() != rs2.size()) {
  58                         rs1.clear();
  59                         rs2.clear();
  60                         return false;
  61                 }
  62
  63                 Comparator<Resource> rcomp = getComparator().getResourceComparator();
  64                 if (rs1.size() == 0) {
  65                         return rcomp.compare(r1, r2) == 0;
  66                 }
  67
  68                 getComparator().sortResource(rs1, rs2);
  69
  70                 for (int i = 0; i < rs1.size(); i++) {
  71                         int c = rcomp.compare(rs1.get(i), rs2.get(i));
  72                         if (c != 0) {
  73                                 rs1.clear();
  74                                 rs2.clear();
  75                                 return false;
  76                         }
  77                 }
  78                 if (rs1.size() == 1) {
  79                         // Check for enumeration type. Without this enumeration instances could be mixed together.
  80                         if (g.hasStatement(rs1.get(0), l0.Enumeration, rs1.get(0))) {
  81                                 if (!r1.equals(r2)) {
  82                                         rs1.clear();
  83                                         rs2.clear();
  84                                         return false;
  85                                 }
  86                         }
  87                 }
  88
  89                 rs1.clear();
  90                 rs2.clear();
  91
  92                 return true;
  93         }
  94
  95         protected boolean compareInheritance(ReadGraph g, Resource r1, Resource r2) throws DatabaseException {
  96                 Layer0 l0 = Layer0.getInstance(g);
  97
  98                 rs1.addAll(g.getObjects(r1, l0.Inherits));
  99                 rs2.addAll(g.getObjects(r2, l0.Inherits));
 100
 101                 if (rs1.size() != rs2.size()) {
 102                         rs1.clear();
 103                         rs2.clear();
 104                         return false;
 105                 }
 106                 if (rs1.size() == 0) {
 107                         rs1.addAll(g.getObjects(r1, l0.SubrelationOf));
 108                         rs2.addAll(g.getObjects(r2, l0.SubrelationOf));
 109                 }
 110                 if (rs1.size() != rs2.size()) {
 111                         rs1.clear();
 112                         rs2.clear();
 113                         return false;
 114                 }
 115                 Comparator<Resource> rcomp = getComparator().getResourceComparator();
 116                 if (rs1.size() == 0) {
 117                         return rcomp.compare(r1, r2) == 0;
 118                 }
 119
 120                 getComparator().sortResource(rs1, rs2);
 121
 122                 for (int i = 0; i < rs1.size(); i++) {
 123                         int c = rcomp.compare(rs1.get(i), rs2.get(i));
 124                         if (c != 0) {
 125                                 rs1.clear();
 126                                 rs2.clear();
 127                                 return false;
 128                         }
 129                 }
 130
 131                 rs1.clear();
 132                 rs2.clear();
 133
 134                 return true;
 135         }
 136
 137
 138         protected int propsDiffCount(ReadGraph g, Resource r1, Resource r2) throws DatabaseException {
 139                 Layer0 l0 = Layer0.getInstance(g);
 140                 ArrayList<Statement> ss1 = new ArrayList<Statement>();
 141                 ArrayList<Statement> ss2 = new ArrayList<Statement>();
 142                 ss1.addAll(g.getStatements(r1, l0.HasProperty));
 143                 ss2.addAll(g.getStatements(r2, l0.HasProperty));
 144
 145                 if (ss1.size() == 0 && ss2.size() == 0)
 146                         return 0;
 147
 148                 Comparator<Statement> scomp = getComparator().getStatementComparator();
 149
 150                 getComparator().sortStatement(ss1, ss2);
 151
 152                 int count = 1;
 153
 154                 int i1 = 0;
 155                 int i2 = 0;
 156
 157                 while (true) {
 158                         if (i1 >= ss1.size()) {
 159                                 if (i2 >= ss2.size())
 160                                         break;
 161                                 else {
 162                                         while (i2 < ss2.size()) {
 163                                                 count++;
 164                                                 i2++;
 165                                         }
 166                                         break;
 167                                 }
 168                         } else if (i2 >= ss2.size()) {
 169                                 while (i1 < ss1.size()) {
 170                                         count++;
 171                                         i1++;
 172                                 }
 173                                 break;
 174                         }
 175                         Statement s1 = ss1.get(i1);
 176                         Statement s2 = ss2.get(i2);
 177                         if (s1.isAsserted(r1) && s2.isAsserted(r2)) {
 178                                 i1++;
 179                                 i2++;
 180                                 continue;
 181                         }
 182                         int c = scomp.compare(s1, s2);
 183                         switch (c) {
 184                                 case 0:{
 185                                         boolean b1 = g.hasValue(s1.getObject());
 186                                         boolean b2 = g.hasValue(s2.getObject());
 187                                         if (b1 == b2) {
 188                                                 if (b1) {
 189                                                         boolean eq = GraphComparator.compareValue(g, l0 , s1.getObject(), s2.getObject());
 190                                                         if (!eq) {
 191                                                                 count++;
 192                                                         }
 193                                                 } else {
 194                                                         count += propsDiffCount(g,s1.getObject(), s2.getObject());
 195                                                 }
 196                                         } else {
 197                                                 //System.out.println("Props count structural vs literal");
 198                                                 count++;
 199                                         }
 200                                         i1++;
 201                                         i2++;
 202                                         break;
 203                                 }
 204                                 case -1:{
 205                                         count++;
 206                                         i1++;
 207                                         break;
 208                                 }
 209
 210                                 case 1:{
 211                                         count++;
 212                                         i2++;
 213                                         break;
 214                                 }
 215                         }
 216
 217                 }
 218
 219                 ss1.clear();
 220                 ss2.clear();
 221                 return count;
 222         }
 223
 224 }