bundles/org.simantics.graph.db/src/org/simantics/graph/db/old/OldTransferableGraphImportProcess1.java

   1 package org.simantics.graph.db.old;\r
   2 \r
   3 import java.io.DataOutput;\r
   4 import java.io.DataOutputStream;\r
   5 import java.io.FileNotFoundException;\r
   6 import java.io.FileOutputStream;\r
   7 import java.io.IOException;\r
   8 import java.util.HashSet;\r
   9 import java.util.Map;\r
  10 import java.util.Set;\r
  11 \r
  12 import org.simantics.databoard.Bindings;\r
  13 import org.simantics.databoard.adapter.AdaptException;\r
  14 import org.simantics.databoard.binding.mutable.Variant;\r
  15 import org.simantics.db.ReadGraph;\r
  16 import org.simantics.db.Resource;\r
  17 import org.simantics.db.VirtualGraph;\r
  18 import org.simantics.db.WriteOnlyGraph;\r
  19 import org.simantics.db.common.WriteBindings;\r
  20 import org.simantics.db.common.procedure.adapter.TransientCacheAsyncListener;\r
  21 import org.simantics.db.common.uri.UnescapedChildMapOfResource;\r
  22 import org.simantics.db.common.utils.Logger;\r
  23 import org.simantics.db.exception.DatabaseException;\r
  24 import org.simantics.db.exception.ResourceNotFoundException;\r
  25 import org.simantics.db.service.ClusterBuilder;\r
  26 import org.simantics.db.service.ClusterBuilder.ResourceHandle;\r
  27 import org.simantics.db.service.SerialisationSupport;\r
  28 import org.simantics.db.service.TransferableGraphSupport;\r
  29 import org.simantics.graph.db.CoreInitialization;\r
  30 import org.simantics.graph.db.IImportAdvisor;\r
  31 import org.simantics.graph.representation.Extensions;\r
  32 import org.simantics.graph.representation.External;\r
  33 import org.simantics.graph.representation.Identity;\r
  34 import org.simantics.graph.representation.IdentityDefinition;\r
  35 import org.simantics.graph.representation.Internal;\r
  36 import org.simantics.graph.representation.Optional;\r
  37 import org.simantics.graph.representation.Root;\r
  38 import org.simantics.graph.representation.TransferableGraphUtils;\r
  39 import org.simantics.graph.representation.old.OldTransferableGraph1;\r
  40 import org.simantics.graph.representation.old.OldValue1;\r
  41 \r
  42 public class OldTransferableGraphImportProcess1 {\r
  43         \r
  44     public static String LOG_FILE = "transferableGraphs.log";\r
  45     final static private boolean LOG = false;\r
  46     \r
  47     static DataOutput log;\r
  48 \r
  49     static {\r
  50 \r
  51         if (LOG) {\r
  52             try {\r
  53                 FileOutputStream stream = new FileOutputStream(LOG_FILE);\r
  54                 log = new DataOutputStream(stream);\r
  55             } catch (FileNotFoundException e) {\r
  56                 e.printStackTrace();\r
  57             }\r
  58         }\r
  59 \r
  60     }\r
  61     \r
  62     private static void log(String line) {\r
  63         if (LOG) {\r
  64             try {\r
  65                 log.writeUTF(line + "\n");\r
  66             } catch (IOException e) {\r
  67                 e.printStackTrace();\r
  68             }\r
  69         }\r
  70     }\r
  71     \r
  72     OldTransferableGraph1 tg;\r
  73     IImportAdvisor advisor;\r
  74     \r
  75     Resource[] resources;\r
  76     ResourceHandle[] handles;\r
  77     \r
  78     Set<String> missingExternals = new HashSet<String>(); \r
  79     \r
  80     // Builtins\r
  81     Resource RootLibrary;\r
  82     Resource String;\r
  83     Resource Library;\r
  84     \r
  85     Resource InstanceOf;\r
  86     Resource ConsistsOf;\r
  87     Resource PartOf;\r
  88     Resource HasName;\r
  89     Resource NameOf;    \r
  90                 \r
  91     public OldTransferableGraphImportProcess1(OldTransferableGraph1 tg, IImportAdvisor advisor) {\r
  92         this.tg = tg;\r
  93         this.advisor = advisor;\r
  94         /*System.out.println("Transferable graph identities:");\r
  95         for(Identity id : tg.identities) {\r
  96             if(id.definition instanceof Internal) {\r
  97                 Internal def = (Internal)id.definition;\r
  98                 System.out.println("    internal " + def.name);\r
  99             }\r
 100             else if(id.definition instanceof External) {\r
 101                 External def = (External)id.definition;\r
 102                 System.out.println("    external " + def.name);\r
 103             }\r
 104         }*/\r
 105     }\r
 106     \r
 107     public void findBuiltins(WriteOnlyGraph g) throws DatabaseException {\r
 108         RootLibrary = g.getBuiltin("http:/");\r
 109         String = g.getBuiltin(CoreInitialization.LAYER0 + "String");\r
 110         Library = g.getBuiltin(CoreInitialization.LAYER0 + "Library");\r
 111         InstanceOf = g.getBuiltin(CoreInitialization.LAYER0 + "InstanceOf");\r
 112         ConsistsOf = g.getBuiltin(CoreInitialization.LAYER0 + "ConsistsOf");\r
 113         PartOf = g.getBuiltin(CoreInitialization.LAYER0 + "PartOf");\r
 114         HasName = g.getBuiltin(CoreInitialization.LAYER0 + "HasName");\r
 115         NameOf = g.getBuiltin(CoreInitialization.LAYER0 + "NameOf");\r
 116     }\r
 117     \r
 118     public void findBuiltins(ReadGraph g) throws DatabaseException {\r
 119         RootLibrary = g.getBuiltin("http:/");\r
 120         String = g.getBuiltin(CoreInitialization.LAYER0 + "String");\r
 121         Library = g.getBuiltin(CoreInitialization.LAYER0 + "Library");\r
 122         InstanceOf = g.getBuiltin(CoreInitialization.LAYER0 + "InstanceOf");\r
 123         ConsistsOf = g.getBuiltin(CoreInitialization.LAYER0 + "ConsistsOf");\r
 124         PartOf = g.getBuiltin(CoreInitialization.LAYER0 + "PartOf");\r
 125         HasName = g.getBuiltin(CoreInitialization.LAYER0 + "HasName");\r
 126         NameOf = g.getBuiltin(CoreInitialization.LAYER0 + "NameOf");\r
 127     }\r
 128 \r
 129     /* Preparation that is used when the core is empty. \r
 130      */\r
 131     void initialPrepare(WriteOnlyGraph graph) throws DatabaseException {\r
 132         findBuiltins(graph);\r
 133         \r
 134         resources = new Resource[tg.resourceCount];\r
 135         \r
 136         int Root = -1;\r
 137         int SimanticsDomain = -1;\r
 138         int Layer0 = -1;\r
 139         \r
 140         for(Identity identity : tg.identities) {\r
 141             if(identity.definition instanceof Internal) {\r
 142                 Internal def = (Internal)identity.definition;\r
 143                 Resource res = null;\r
 144                 if(def.parent == Layer0) {\r
 145                     try {\r
 146                         res = graph.getBuiltin(CoreInitialization.LAYER0 + def.name);\r
 147                     } catch(ResourceNotFoundException e) {                                      \r
 148                     }\r
 149                 }\r
 150                 else if(def.parent == SimanticsDomain) {\r
 151                     if(def.name.equals("Layer0-1.1"))\r
 152                         Layer0 = identity.resource;\r
 153                 }\r
 154                 else if(def.parent == Root) {\r
 155                     if(def.name.equals("www.simantics.org"))\r
 156                         SimanticsDomain = identity.resource;\r
 157                 }\r
 158 \r
 159                 if(res == null)\r
 160                     res = createChild(graph, resources[def.parent], def.name);\r
 161                 else\r
 162                     createChild(graph, res, resources[def.parent], def.name);\r
 163                 resources[identity.resource] = res;\r
 164             }\r
 165             else if(identity.definition instanceof Root) {\r
 166                 Root = identity.resource;\r
 167                 resources[identity.resource] = RootLibrary;             \r
 168             } \r
 169         }\r
 170     }\r
 171     \r
 172     void addMissing(String external) {\r
 173         Set<String> removals = new HashSet<String>();\r
 174         for(String ext : missingExternals) if(ext.startsWith(external)) return;\r
 175         for(String ext : missingExternals) if(external.startsWith(ext)) removals.add(ext);\r
 176         missingExternals.removeAll(removals);\r
 177         missingExternals.add(external);\r
 178     }\r
 179     \r
 180     void prepare(ReadGraph graph) throws DatabaseException {\r
 181         findBuiltins(graph);\r
 182         \r
 183         Resource[] resources = new Resource[tg.resourceCount];\r
 184         \r
 185         for(Identity identity : tg.identities) {\r
 186             IdentityDefinition definition = identity.definition;\r
 187             if(definition instanceof External) {\r
 188                 External def = (External)definition;\r
 189                 if(def.parent == -1) {\r
 190                     resources[identity.resource] = RootLibrary;\r
 191                 } else {\r
 192                     if("@inverse".equals(def.name)) {\r
 193                         Resource parent = resources[def.parent];\r
 194                         Resource child = graph.getInverse(parent);\r
 195                         resources[identity.resource] = child;\r
 196                     } else {\r
 197                         Resource parent = resources[def.parent];\r
 198                         // TODO: escape should be removed when names become well-behaving\r
 199                         if(parent != null) {\r
 200                             Resource child = graph\r
 201                             .syncRequest(new UnescapedChildMapOfResource(parent),\r
 202                                     new TransientCacheAsyncListener<Map<String, Resource>>())\r
 203                                     .get(def.name);\r
 204                             if(child == null) {\r
 205                                 addMissing(graph.getURI(parent) + "/" + def.name);\r
 206                             }\r
 207                             resources[identity.resource] = child;\r
 208                         } else {\r
 209                             addMissing(TransferableGraphUtils.getURI(tg.resourceCount, tg.identities, def.parent) + "/" + def.name);\r
 210                         }\r
 211                     }\r
 212                 }\r
 213             }\r
 214             else if(definition instanceof Internal) {\r
 215                 // Do not do anything for now\r
 216             }\r
 217             else if(definition instanceof Root) {\r
 218                 Root root = (Root)definition;\r
 219                 if(root.name.equals(""))\r
 220                     resources[identity.resource] = RootLibrary;\r
 221                 else \r
 222                     advisor.analyzeRoot(graph, root);                   \r
 223             }\r
 224             else if(definition instanceof Optional) {\r
 225                 External def = (External)definition;\r
 226                 Resource parent = resources[def.parent];\r
 227                 if(parent != null)\r
 228                     resources[identity.resource] = \r
 229                         graph.syncRequest(new UnescapedChildMapOfResource(parent)).get(def.name);               \r
 230             }\r
 231         }       \r
 232         \r
 233         this.resources = resources;\r
 234         \r
 235         if(!missingExternals.isEmpty()) throw new OldMissingDependencyException(this);\r
 236         \r
 237     }\r
 238 \r
 239     Resource createChild(WriteOnlyGraph graph, Resource parent, String name) throws DatabaseException {\r
 240         Resource child = graph.newResource();\r
 241         graph.claim(parent, ConsistsOf, PartOf, child);\r
 242         Resource nameResource = graph.newResource();\r
 243         graph.claim(nameResource, InstanceOf, null, String);\r
 244         graph.claimValue(nameResource, name, WriteBindings.STRING);\r
 245         graph.claim(child, HasName, NameOf, nameResource);\r
 246         return child;\r
 247     }\r
 248     \r
 249     void createChild(WriteOnlyGraph graph, Resource child, Resource parent, String name) throws DatabaseException {\r
 250         graph.claim(parent, ConsistsOf, PartOf, child);\r
 251         Resource nameResource = graph.newResource();\r
 252         graph.claim(nameResource, InstanceOf, null, String);\r
 253         graph.claimValue(nameResource, name, WriteBindings.STRING);\r
 254         graph.claim(child, HasName, NameOf, nameResource);\r
 255     }\r
 256     \r
 257     int[] getClustering() {\r
 258         Variant v = tg.extensions.get(Extensions.CLUSTERING);\r
 259         if(v == null) return null;\r
 260         try {\r
 261             return (int[])v.getValue(Bindings.INT_ARRAY);\r
 262         } catch (AdaptException e) {\r
 263             Logger.defaultLogError(e);\r
 264             return null;\r
 265         }\r
 266     }\r
 267     \r
 268     void write(WriteOnlyGraph graph) throws DatabaseException {\r
 269 \r
 270         Resource[] resources = this.resources;\r
 271 \r
 272         this.handles = new ResourceHandle[resources.length];\r
 273         \r
 274         ResourceHandle[] handles = this.handles; \r
 275 \r
 276         int[] clustering = getClustering();\r
 277 \r
 278         // Internal identities      \r
 279         for(Identity identity : tg.identities) {\r
 280             IdentityDefinition definition = identity.definition;\r
 281             if(resources[identity.resource] != null)\r
 282                 continue;\r
 283             if(definition instanceof External) {\r
 284                 // Already done everything\r
 285             }\r
 286             else if(definition instanceof Internal) {\r
 287                 Internal def = (Internal)definition;\r
 288                 resources[identity.resource] = \r
 289                     createChild(graph, resources[def.parent], def.name);\r
 290             }\r
 291             else if(definition instanceof Root) {\r
 292                 Root root = (Root)definition;               \r
 293                 resources[identity.resource] = advisor.createRoot(graph, root);                 \r
 294             }\r
 295             else if(definition instanceof Optional) {\r
 296                 Optional def = (Optional)definition;\r
 297                 Resource child = createChild(graph, resources[def.parent], def.name);\r
 298                 graph.claim(child, InstanceOf, null, Library); // ???\r
 299                 resources[identity.resource] = child;                   \r
 300             }\r
 301         }       \r
 302 \r
 303         ClusterBuilder builder = graph.getService(ClusterBuilder.class);\r
 304         SerialisationSupport ss = graph.getService(SerialisationSupport.class);\r
 305 \r
 306         if(clustering != null) {\r
 307             \r
 308             int i = 0;\r
 309             for(int c : clustering) {\r
 310                 builder.newCluster();\r
 311                 for(int r=0;r<c;r++, i++)\r
 312                     if(resources[i] == null)\r
 313                         handles[i] = builder.newResource();\r
 314                     else \r
 315                         handles[i] = builder.resource(resources[i]);\r
 316 \r
 317             }\r
 318 \r
 319             for(;i<resources.length;++i)\r
 320                 if(resources[i] == null)\r
 321                     handles[i] = builder.newResource();\r
 322                 else \r
 323                     handles[i] = builder.resource(resources[i]);\r
 324             \r
 325         } else {\r
 326         \r
 327             // Create blank resources\r
 328             for(int i=0;i<resources.length;++i)\r
 329                 if(resources[i] == null)\r
 330                     handles[i] = builder.newResource();\r
 331                 else \r
 332                     handles[i] = builder.resource(resources[i]);\r
 333 \r
 334         }\r
 335         \r
 336         // Write statements\r
 337         int[] statements = tg.statements;\r
 338         \r
 339         int internals = tg.resourceCount - tg.identities.length;\r
 340         \r
 341         for(int i=0;i<statements.length;i+=4) {\r
 342 \r
 343             int sub = statements[i];\r
 344             int pred = statements[i+1];\r
 345             int inv = statements[i+2];\r
 346             int obj = statements[i+3];\r
 347 \r
 348             ResourceHandle subject = handles[sub];\r
 349             ResourceHandle predicate = handles[pred];\r
 350             ResourceHandle object = handles[obj];\r
 351 \r
 352             if(resources[sub] == null) {\r
 353                 subject.addStatement(graph, predicate, object); \r
 354             } else {\r
 355                 graph.claim(\r
 356                         handles[sub].resource(ss),\r
 357                         handles[pred].resource(ss),\r
 358                         null, handles[obj].resource(ss));\r
 359             }\r
 360             \r
 361             if(inv >= 0) {\r
 362                 \r
 363                 if(resources[obj] == null) {\r
 364                     ResourceHandle inverse = handles[inv];\r
 365                     object.addStatement(graph, inverse, subject);   \r
 366                 } else {\r
 367                     graph.claim(\r
 368                             handles[obj].resource(ss),\r
 369                             handles[inv].resource(ss),\r
 370                             null, handles[sub].resource(ss));\r
 371                 }\r
 372                 \r
 373             }\r
 374             \r
 375             if(LOG) {\r
 376                 log("[STATEMENT] " + resources[statements[i]].getResourceId() + ", " + resources[statements[i+1]].getResourceId() + ", " + resources[statements[i+3]].getResourceId());\r
 377             }\r
 378             \r
 379         }\r
 380                 \r
 381         // Write values\r
 382         TransferableGraphSupport tgSupport = \r
 383             graph.getService(TransferableGraphSupport.class);\r
 384         VirtualGraph vg = graph.getProvider();\r
 385         for(OldValue1 value : tg.values) {\r
 386             int file = value.resource & 0x80000000;\r
 387             int resource = value.resource & 0x7FFFFFFF;\r
 388             if (file != 0) {\r
 389                 graph.claimValue(handles[resource].resource(ss), value.value, Bindings.BYTE_ARRAY);\r
 390             } else {\r
 391                 if(resource < internals) {\r
 392                     handles[resource].addValue(graph, value.value);\r
 393                 } else {\r
 394                     tgSupport.setValue(graph, handles[resource].resource(ss), vg, value.value);\r
 395                 }\r
 396                 //tgSupport.setValue(resources[resource], vg, value.value);\r
 397             }\r
 398         }\r
 399     }\r
 400     \r
 401     void write2(WriteOnlyGraph graph) throws DatabaseException {\r
 402         Resource[] resources = this.resources;\r
 403         \r
 404         // Internal identities      \r
 405         for(Identity identity : tg.identities) {\r
 406             IdentityDefinition definition = identity.definition;\r
 407             if(resources[identity.resource] != null)\r
 408                 continue;\r
 409             if(definition instanceof External) {\r
 410                 // Already done everything\r
 411             }\r
 412             else if(definition instanceof Internal) {\r
 413                 Internal def = (Internal)definition;\r
 414                 resources[identity.resource] = \r
 415                     createChild(graph, resources[def.parent], def.name);\r
 416             }\r
 417             else if(definition instanceof Root) {               \r
 418                 Root root = (Root)definition;               \r
 419                 resources[identity.resource] = advisor.createRoot(graph, root);                 \r
 420             }\r
 421             else if(definition instanceof Optional) {\r
 422                 Optional def = (Optional)definition;\r
 423                 Resource child = createChild(graph, resources[def.parent], def.name);\r
 424                 graph.claim(child, InstanceOf, null, Library); // ???\r
 425                 resources[identity.resource] = child;                   \r
 426             }\r
 427         }       \r
 428         \r
 429         // Create blank resources\r
 430         for(int i=0;i<resources.length;++i)\r
 431             if(resources[i] == null)\r
 432                 resources[i] = graph.newResource();\r
 433         \r
 434         // Write statements\r
 435         int[] statements = tg.statements;\r
 436         \r
 437         for(int i=0;i<statements.length;i+=4) {\r
 438             int inv = statements[i+2];\r
 439             graph.claim(\r
 440                     resources[statements[i]],\r
 441                     resources[statements[i+1]],\r
 442                     inv < 0 ? null : resources[inv],\r
 443                     resources[statements[i+3]]\r
 444                     );\r
 445             if(LOG) {\r
 446                 log("[STATEMENT] " + resources[statements[i]].getResourceId() + ", " + resources[statements[i+1]].getResourceId() + ", " + resources[statements[i+3]].getResourceId());\r
 447             }\r
 448         }\r
 449                 \r
 450         // Write values\r
 451         TransferableGraphSupport tgSupport = \r
 452             graph.getService(TransferableGraphSupport.class);\r
 453         VirtualGraph vg = graph.getProvider();\r
 454         for(OldValue1 value : tg.values) {\r
 455             int file = value.resource & 0x80000000;\r
 456             int resource = value.resource & 0x7FFFFFFF;\r
 457             if (file != 0) {\r
 458                 graph.claimValue(resources[resource], value.value, Bindings.BYTE_ARRAY);\r
 459             } else {\r
 460                 tgSupport.setValue(graph, resources[resource], vg, value.value);\r
 461             }\r
 462         }\r
 463     }\r
 464     \r
 465     \r
 466     public long[] getResourceIds(SerialisationSupport serializer) throws DatabaseException {\r
 467         final int count = resources.length;\r
 468         long[] resourceIds = new long[count];\r
 469         if(handles != null) {\r
 470             for(int i=0;i<count;++i)\r
 471                 resourceIds[i] = serializer.getRandomAccessId(handles[i].resource(serializer));\r
 472         } else {\r
 473             for(int i=0;i<count;++i)\r
 474                 resourceIds[i] = serializer.getRandomAccessId(resources[i]);\r
 475         }\r
 476         return resourceIds;\r
 477     }\r
 478     \r
 479 }