Merge branch 'feature/funcwrite'

[simantics/platform.git] / bundles / org.simantics.graph / src / org / simantics / graph / refactoring / GraphRefactoringUtils.java

diff --git a/bundles/org.simantics.graph/src/org/simantics/graph/refactoring/GraphRefactoringUtils.java b/bundles/org.simantics.graph/src/org/simantics/graph/refactoring/GraphRefactoringUtils.java
index 55b9cbe2efb4164a4091b36595217037b8b539d5..9882048b788144c74de9ac5ec56b69f6954ff384 100644 (file)
--- a/bundles/org.simantics.graph/src/org/simantics/graph/refactoring/GraphRefactoringUtils.java
+++ b/bundles/org.simantics.graph/src/org/simantics/graph/refactoring/GraphRefactoringUtils.java
@@ -1,7 +1,9 @@
 package org.simantics.graph.refactoring;
 
 import java.util.ArrayList;
+import java.util.Arrays;
 
+import org.simantics.databoard.util.URIStringUtils;
 import org.simantics.graph.query.Path;
 import org.simantics.graph.query.PathChild;
 import org.simantics.graph.query.TransferableGraphConversion;
@@ -17,9 +19,11 @@ import org.simantics.graph.representation.TransferableGraph1;
 import org.simantics.graph.representation.TransferableGraphUtils;
 import org.simantics.graph.representation.old.OldTransferableGraph1;
 import org.simantics.graph.representation.old.OldValue1;
+import org.simantics.graph.store.GraphStore;
 import org.simantics.graph.store.IdentityStore;
 
 import gnu.trove.list.array.TIntArrayList;
+import gnu.trove.map.hash.TIntIntHashMap;
 import gnu.trove.set.hash.TIntHashSet;
 
 public class GraphRefactoringUtils {
@@ -89,6 +93,20 @@ public class GraphRefactoringUtils {
         
     }
     
+    private static Identity recursePath(TransferableGraph1 tg, String path) {
+       
+       Identity extId = TransferableGraphUtils.findExternal(tg, path);
+       if(extId != null) return extId;
+       if("http://".equals(path)) return TransferableGraphUtils.findRootWithName(tg, "");
+       String[] parts = URIStringUtils.splitURI(path);
+       Identity parentId = recursePath(tg, parts[0]);
+       tg.identities = Arrays.copyOf(tg.identities, tg.identities.length+1);
+       Identity childIdentity = new Identity(tg.resourceCount++, new External(parentId.resource, parts[1]));
+               tg.identities[tg.identities.length-1] = childIdentity;
+               return childIdentity;
+       
+    }
+    
     public static void fixOntologyRoot(TransferableGraph1 tg, boolean tryToFix) {
 
        Identity[] ids = tg.identities;
@@ -97,37 +115,36 @@ public class GraphRefactoringUtils {
             if(id.definition instanceof Root) {
                 Root ext = (Root)id.definition;
                 if(ext.name.startsWith("http://")) {
-                       String rootName = ext.name.substring(ext.name.lastIndexOf("/")+1);
-                       String path = ext.name.substring(0, ext.name.lastIndexOf("/"));
-                       Identity pathId = TransferableGraphUtils.findExternal(tg, path);
-                       System.err.println("GraphRefactoringUtils.rootName=" + rootName);
-                       System.err.println("GraphRefactoringUtils.path2=" + path);
-                       if(pathId == null) {
-                               if(!tryToFix) return;
-                               IdentityStore idStore = TransferableGraphConversion.extractIdentities(tg);
-                               idStore.createPathToId(UriUtils.uriToPath(path));
-                               tg.resourceCount = idStore.getResourceCount();
-                               tg.identities = idStore.toArray();
-                               fixOntologyRoot(tg, false);
-                               return;
-                       } else {
-                               id.definition = new Internal(pathId.resource, rootName);
-                               TIntArrayList stms = new TIntArrayList(tg.statements);
-                       Identity consistsOf = TransferableGraphUtils.findExternal(tg, "http://www.simantics.org/Layer0-1.1/ConsistsOf");
-                       Identity partOf = TransferableGraphUtils.findExternal(tg, "http://www.simantics.org/Layer0-1.1/PartOf");
-                               stms.add(id.resource);
-                               stms.add(partOf.resource);
-                               stms.add(consistsOf.resource);
-                               stms.add(pathId.resource);
-                               tg.statements = stms.toArray();
-                               return;
-                       }
+                       
+                       String[] parts = URIStringUtils.splitURI(ext.name);
+                       Identity path = recursePath(tg, parts[0]);
+                       id.definition = new Internal(path.resource, parts[1]);
+                       
+                       GraphStore store = TransferableGraphConversion.convert(tg);
+                       int rootId = store.identities.createPathToId(UriUtils.uriToPath(ext.name));
+                       propagateNewMarks(store.identities, rootId);
+
+                       TransferableGraph1 tgNew = TransferableGraphConversion.convert(store);
+                               
+                       tg.resourceCount = tgNew.resourceCount;
+                       tg.identities = tgNew.identities;
+                       tg.values = tgNew.values;
+                       tg.statements = tgNew.statements;
+                               
+                       return;
                        
                 }
             }
         }
        
     }
+    
+       private static void propagateNewMarks(IdentityStore identities, int resource) {
+               if(identities.markNew(resource)) {
+                       for(int child : identities.getChildren(resource))
+                               propagateNewMarks(identities, child);
+               }
+       }
 
     public static void unfixIncorrectRoot(Identity[] ids) {
         for(int i=0;i<ids.length;++i) {