bundles/org.simantics.graph.db/src/org/simantics/graph/db/TGToGraphMap.java

   1 package org.simantics.graph.db;\r
   2 \r
   3 import java.util.Map;\r
   4 \r
   5 import org.simantics.databoard.Bindings;\r
   6 import org.simantics.db.ReadGraph;\r
   7 import org.simantics.db.Resource;\r
   8 import org.simantics.db.WriteGraph;\r
   9 import org.simantics.db.WriteOnlyGraph;\r
  10 import org.simantics.db.common.procedure.adapter.TransientCacheAsyncListener;\r
  11 import org.simantics.db.common.uri.UnescapedChildMapOfResource;\r
  12 import org.simantics.db.exception.DatabaseException;\r
  13 import org.simantics.db.exception.ResourceNotFoundException;\r
  14 import org.simantics.db.service.SerialisationSupport;\r
  15 import org.simantics.graph.representation.External;\r
  16 import org.simantics.graph.representation.Identity;\r
  17 import org.simantics.graph.representation.IdentityDefinition;\r
  18 import org.simantics.graph.representation.Internal;\r
  19 import org.simantics.graph.representation.Root;\r
  20 import org.simantics.graph.representation.TransferableGraph1;\r
  21 import org.simantics.graph.representation.Value;\r
  22 \r
  23 public class TGToGraphMap {\r
  24         private TransferableGraph1 tg;\r
  25         private Resource[] resources;\r
  26         \r
  27         private Resource RootLibrary;\r
  28         private Resource String;\r
  29         //private Resource Library;\r
  30         \r
  31         private Resource InstanceOf;\r
  32         private Resource ConsistsOf;\r
  33         private Resource PartOf;\r
  34         private Resource HasName;\r
  35         private Resource NameOf;\r
  36         \r
  37         private void findBuiltins(WriteOnlyGraph g) throws DatabaseException {\r
  38                 RootLibrary = g.getBuiltin("http:/");\r
  39                 String = g.getBuiltin(CoreInitialization.LAYER0 + "String");\r
  40                 //Library = g.getBuiltin(CoreInitialization.LAYER0 + "Library");\r
  41                 InstanceOf = g.getBuiltin(CoreInitialization.LAYER0 + "InstanceOf");\r
  42                 ConsistsOf = g.getBuiltin(CoreInitialization.LAYER0 + "ConsistsOf");\r
  43                 PartOf = g.getBuiltin(CoreInitialization.LAYER0 + "PartOf");\r
  44                 HasName = g.getBuiltin(CoreInitialization.LAYER0 + "HasName");\r
  45                 NameOf = g.getBuiltin(CoreInitialization.LAYER0 + "NameOf");\r
  46         }\r
  47         \r
  48         private void findBuiltins(ReadGraph g) throws DatabaseException {\r
  49                 RootLibrary = g.getBuiltin("http:/");\r
  50                 String = g.getBuiltin(CoreInitialization.LAYER0 + "String");\r
  51                 //Library = g.getBuiltin(CoreInitialization.LAYER0 + "Library");\r
  52                 InstanceOf = g.getBuiltin(CoreInitialization.LAYER0 + "InstanceOf");\r
  53                 ConsistsOf = g.getBuiltin(CoreInitialization.LAYER0 + "ConsistsOf");\r
  54                 PartOf = g.getBuiltin(CoreInitialization.LAYER0 + "PartOf");\r
  55                 HasName = g.getBuiltin(CoreInitialization.LAYER0 + "HasName");\r
  56                 NameOf = g.getBuiltin(CoreInitialization.LAYER0 + "NameOf");\r
  57         }\r
  58         \r
  59         public TGToGraphMap(TransferableGraph1 tg) {\r
  60                 this.tg = tg;\r
  61                 this.resources = new Resource[tg.resourceCount];\r
  62         }       \r
  63         \r
  64         public long[] getResources(SerialisationSupport serializer) throws DatabaseException {\r
  65                 final int count = resources.length;\r
  66                 long[] resourceIds = new long[count];\r
  67                 for(int i=0;i<count;++i)\r
  68                         resourceIds[i] = serializer.getRandomAccessId(resources[i]);\r
  69                 return resourceIds;\r
  70         }       \r
  71         \r
  72         public Resource[] getResources() {\r
  73                 return resources;\r
  74         }\r
  75         \r
  76         private void claimChild(WriteOnlyGraph graph, Resource parent, String name, Resource child) throws DatabaseException {\r
  77                 //graph.claim(parent, ConsistsOf, PartOf, child);\r
  78                 Resource nameResource = graph.newResource();\r
  79                 graph.claim(nameResource, InstanceOf, null, String);\r
  80                 graph.claimValue(nameResource, name, Bindings.STRING);\r
  81                 graph.claim(child, HasName, NameOf, nameResource);\r
  82         }\r
  83         \r
  84         public void addMappedOldResources(\r
  85                         SerialisationSupport serializer,\r
  86                         int[] oldToNew,\r
  87                         Resource[] oldResources) throws DatabaseException {\r
  88                 assert(oldToNew.length == oldResources.length);\r
  89                 for(int i=0;i<oldToNew.length;++i) {\r
  90                         int id = oldToNew[i];\r
  91                         if(id >= 0)\r
  92                                 resources[id] = oldResources[i];\r
  93                 }\r
  94         }\r
  95         \r
  96         public void addOldResources(\r
  97                         SerialisationSupport serializer, \r
  98                         long[] oldResources) throws DatabaseException {\r
  99                 assert(oldResources.length == resources.length);\r
 100                 for(int i=0;i<oldResources.length;++i) {\r
 101                         resources[i] = serializer.getResource(oldResources[i]);\r
 102                 }\r
 103         }\r
 104 \r
 105         public void prepare(ReadGraph graph) throws DatabaseException {\r
 106                 if(RootLibrary == null)\r
 107                         findBuiltins(graph);\r
 108                 Resource[] resources = this.resources;          \r
 109                 \r
 110                 for(Identity identity : tg.identities) {\r
 111                         IdentityDefinition definition = identity.definition;\r
 112                         if(definition instanceof External) {\r
 113                                 External def = (External)definition;\r
 114                                 Resource parent = resources[def.parent];\r
 115                                 Resource child = graph.syncRequest(\r
 116                                                 new UnescapedChildMapOfResource(parent), \r
 117                                                 new TransientCacheAsyncListener<Map<String, Resource>>())\r
 118                                                 .get(def.name);\r
 119                                 if(child == null)\r
 120                                         throw new ResourceNotFoundException(def.name);\r
 121                                 resources[identity.resource] = child;\r
 122                         }\r
 123                         else if(definition instanceof Root) {\r
 124                                 resources[identity.resource] = RootLibrary;             \r
 125                         }\r
 126                 }\r
 127         }\r
 128         \r
 129         public void claim(WriteOnlyGraph graph) throws DatabaseException {\r
 130                 if(RootLibrary == null)\r
 131                         findBuiltins(graph);\r
 132                 Resource[] resources = this.resources;\r
 133                         \r
 134                 // Create blank resources\r
 135                 for(int i=0;i<resources.length;++i)\r
 136                         if(resources[i] == null)\r
 137                                 resources[i] = graph.newResource();\r
 138                 \r
 139                 // Internal identities          \r
 140                 for(Identity identity : tg.identities) {\r
 141                         IdentityDefinition definition = identity.definition;\r
 142                         if(definition instanceof Internal) {\r
 143                                 Internal def = (Internal)definition;\r
 144                                 claimChild(graph, resources[def.parent], def.name, resources[identity.resource]);\r
 145                         }                       \r
 146                 }               \r
 147                 \r
 148                 // Write statements\r
 149                 int[] statements = tg.statements;\r
 150                 for(int i=0;i<statements.length;i+=4) {\r
 151                         int inv = statements[i+2];\r
 152                         graph.claim(\r
 153                                         resources[statements[i]],\r
 154                                         resources[statements[i+1]],\r
 155                                         inv < 0 ? null : resources[inv],\r
 156                                         resources[statements[i+3]]\r
 157                                         );\r
 158                 }\r
 159                                 \r
 160                 // Write values\r
 161                 for(Value value : tg.values)\r
 162                     graph.claimValue(resources[value.resource], \r
 163                             value.value.getValue(), value.value.getBinding());\r
 164         }\r
 165         \r
 166         public boolean checkClaim(ReadGraph graph) throws DatabaseException {\r
 167                 \r
 168                 if(RootLibrary == null)\r
 169                         findBuiltins(graph);\r
 170                 \r
 171                 Resource[] resources = this.resources;\r
 172                         \r
 173                 // Create blank resources\r
 174                 for(int i=0;i<resources.length;++i)\r
 175                         if(resources[i] == null)\r
 176                                 return true;\r
 177                 \r
 178                 // Internal identities          \r
 179                 for(Identity identity : tg.identities) {\r
 180                         IdentityDefinition definition = identity.definition;\r
 181                         if(definition instanceof Internal) {\r
 182                                 return true;\r
 183                         }                       \r
 184                 }               \r
 185                 \r
 186                 if(tg.statements.length > 0) return true;\r
 187                 if(tg.values.length > 0) return true;\r
 188                 \r
 189                 return false;\r
 190                 \r
 191         }\r
 192 \r
 193         public void deny(WriteGraph graph) throws DatabaseException {\r
 194                 if(RootLibrary == null)\r
 195                         findBuiltins((ReadGraph)graph);\r
 196                 Resource[] resources = this.resources;\r
 197                 \r
 198                 // Internal identities          \r
 199                 for(Identity identity : tg.identities) {\r
 200                         IdentityDefinition definition = identity.definition;\r
 201                         if(definition instanceof Internal) {\r
 202 //                              Internal def = (Internal)definition;\r
 203                                 /*graph.deny(resources[identity.resource],\r
 204                                                 PartOf,\r
 205                                                 resources[def.parent]\r
 206                                                 );*/\r
 207                                 graph.deny(resources[identity.resource], HasName);\r
 208                         }\r
 209                 }               \r
 210                 \r
 211                 // Deny statements\r
 212                 int[] statements = tg.statements;\r
 213                 for(int i=0;i<statements.length;i+=4) {\r
 214                         int inv = statements[i+2];\r
 215                         graph.deny(\r
 216                                         resources[statements[i]],\r
 217                                         resources[statements[i+1]],\r
 218                                         inv < 0 ? null : resources[inv],\r
 219                                         resources[statements[i+3]]\r
 220                                         );\r
 221                 }\r
 222                                 \r
 223                 // Deny values\r
 224                 for(Value value : tg.values)\r
 225                         graph.denyValue(resources[value.resource]);\r
 226         }\r
 227 \r
 228         public boolean checkDeny(ReadGraph graph) throws DatabaseException {\r
 229                 \r
 230                 if(RootLibrary == null)\r
 231                         findBuiltins((ReadGraph)graph);\r
 232                 \r
 233                 // Internal identities          \r
 234                 for(Identity identity : tg.identities) {\r
 235                         IdentityDefinition definition = identity.definition;\r
 236                         if(definition instanceof Internal) {\r
 237                                 return true;\r
 238                         }\r
 239                 }               \r
 240                 \r
 241                 if(tg.statements.length > 0) return true;\r
 242                 if(tg.values.length > 0) return true;\r
 243                 \r
 244                 return false;\r
 245                                 \r
 246         }\r
 247         \r
 248 }\r