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

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