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;
import org.simantics.graph.refactoring.MappingSpecification.MappingRule;
import org.simantics.graph.representation.External;
import org.simantics.graph.representation.Identity;
-import org.simantics.graph.representation.IdentityDefinition;
import org.simantics.graph.representation.Internal;
-import org.simantics.graph.representation.Optional;
import org.simantics.graph.representation.Root;
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 org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
-import gnu.trove.list.array.TIntArrayList;
import gnu.trove.set.hash.TIntHashSet;
public class GraphRefactoringUtils {
-
+ private static final Logger LOGGER = LoggerFactory.getLogger(GraphRefactoringUtils.class);
/**
* Moves an external resource. Returns true if did something.
* @param parentsAffected
// Find parent id
int toParentId = ids.createPathToId(to.parent);
if(ids.hasChild(toParentId, to.name)) {
- System.err.println("refactor statements from " + from + " to " + to);
+ LOGGER.info("refactor statements from " + from + " to " + to);
//throw new GraphRefactoringException("External reference to " + to + " already exists.");
int toId = ids.pathToId(to);
int[] statements = tg.statements;
if(!(rule.to instanceof PathChild))
throw new GraphRefactoringException("Invalid target URI " + rule.to);
if(!moveExternal(tg, ids, rule.from, (PathChild)rule.to, parentsAffected))
- System.err.println("Didn't find " + rule.from);
+ LOGGER.warn("Didn't find " + rule.from);
}
}
}
+ 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, URIStringUtils.unescape(parts[1])));
+ tg.identities[tg.identities.length-1] = childIdentity;
+ return childIdentity;
+
+ }
+
public static void fixOntologyRoot(TransferableGraph1 tg, boolean tryToFix) {
Identity[] ids = tg.identities;
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, URIStringUtils.unescape(parts[1]));
+
+ GraphStore store = TransferableGraphConversion.convert(tg);
+ int rootId = store.identities.createPathToId(UriUtils.uriToPathUnescaped(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;
+
+ } else if (ext.type.startsWith("http://")) {
+ String first = "http://Projects/Development%20Project";
+ Identity path = recursePath(tg, first);
+ id.definition = new Internal(path.resource, ext.name);
+
+ GraphStore store = TransferableGraphConversion.convert(tg);
+ int rootId = store.identities.createPathToId(UriUtils.uriToPathUnescaped(first + "/" + 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;
+
}
}
}
}
+
+ 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) {
}
}
- public static void compactify(OldTransferableGraph1 tg,
- TIntHashSet removed) {
- // Filter removed set
- for(Identity id : tg.identities) {
- IdentityDefinition def = id.definition;
- if(def instanceof Root)
- removed.remove(id.resource);
- else if(def instanceof External)
- removed.remove(((External)def).parent);
- else if(def instanceof Internal)
- removed.remove(((Internal)def).parent);
- else if(def instanceof Optional)
- removed.remove(((Optional)def).parent);
- }
- for(int r : tg.statements)
- removed.remove(r);
- for(OldValue1 value : tg.values)
- removed.remove(value.resource);
-
- // Compactify
- if(!removed.isEmpty()) {
- // create map
- int resourceCount = tg.resourceCount;
- int[] map = new int[resourceCount];
- for(int i=0;i<resourceCount;++i)
- map[i] = i;
- for(int r : removed.toArray()) {
- map[--resourceCount] = map[r];
- }
-
- // map
- ArrayList<Identity> newIdentities = new ArrayList<Identity>(tg.identities.length);
- for(Identity id : tg.identities) {
- if(removed.contains(id.resource))
- continue;
- else
- newIdentities.add(id);
- id.resource = map[id.resource];
- IdentityDefinition def = id.definition;
- if(def instanceof External) {
- External d = (External)def;
- d.parent = map[d.parent];
- }
- else if(def instanceof Internal) {
- External d = (External)def;
- d.parent = map[d.parent];
- }
- else if(def instanceof Optional) {
- External d = (External)def;
- d.parent = map[d.parent];
- }
- }
- tg.identities = newIdentities.toArray(new Identity[newIdentities.size()]);
- int[] statements = tg.statements;
- for(int i=0;i<statements.length;++i) {
- int r = statements[i];
- if(r >= 0)
- statements[i] = map[r];
- }
- for(OldValue1 value : tg.values)
- value.resource = map[value.resource];
- tg.resourceCount = resourceCount;
- }
- }
-
}