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