Merge branch 'feature/funcwrite'

[simantics/platform.git] / bundles / org.simantics.graph / src / org / simantics / graph / representation / TransferableGraphUtils.java

diff --git a/bundles/org.simantics.graph/src/org/simantics/graph/representation/TransferableGraphUtils.java b/bundles/org.simantics.graph/src/org/simantics/graph/representation/TransferableGraphUtils.java
index 82ac178fbdca32113993e7b2201ec2a81377aa71..4646116dc37d784255466ad55f1914e94c545596 100644 (file)
--- a/bundles/org.simantics.graph/src/org/simantics/graph/representation/TransferableGraphUtils.java
+++ b/bundles/org.simantics.graph/src/org/simantics/graph/representation/TransferableGraphUtils.java
@@ -4,6 +4,14 @@ import java.util.ArrayList;
 import java.util.Collection;
 import java.util.HashMap;
 import java.util.Map;
+import java.util.TreeMap;
+
+import org.simantics.databoard.Bindings;
+import org.simantics.databoard.adapter.AdaptException;
+
+import gnu.trove.list.array.TIntArrayList;
+import gnu.trove.map.TIntObjectMap;
+import gnu.trove.map.hash.TIntObjectHashMap;
 
 public class TransferableGraphUtils {
 
@@ -67,36 +75,89 @@ public class TransferableGraphUtils {
                
        }
        
+       public static Identity getIdentity(TransferableGraph1 tg, int resource) {
+               for(Identity id : tg.identities) {
+                       if(id.resource == resource) return id;
+               }
+               return null;
+       }
+       
+       public static TIntArrayList getStatements(TransferableGraph1 tg, int resource) {
+               TIntArrayList result = new TIntArrayList();
+               for(int i=0;i<tg.statements.length;i+=4) {
+                       if(tg.statements[i] == resource) {
+                               result.add(tg.statements[i+1]);
+                               result.add(tg.statements[i+3]);
+                       }
+               }
+               return result;
+       }
+       
        public static Collection<Identity> getChildren(TransferableGraph1 tg, Identity parent) {
-               ArrayList<Identity> result = new ArrayList<Identity>();
-               System.err.println("children for " + parent.resource);
+               TreeMap<String,Identity> result = new TreeMap<>();
                for(Identity id : tg.identities) {
                        if(id.definition instanceof Internal) {
                                Internal internal = (Internal)id.definition;
-                               System.err.println("internal with parent " + internal.parent);
-                               if(internal.parent == parent.resource) result.add(id);
+                               if(internal.parent == parent.resource) result.put(internal.name, id);
+                       }
+               }
+               Identity consistsOf = findExternal(tg, "http://www.simantics.org/Layer0-1.1/ConsistsOf");
+               Identity hasName = findExternal(tg, "http://www.simantics.org/Layer0-1.1/HasName");
+               for(int i=0;i<tg.statements.length;i+=4) {
+                       if(tg.statements[i] == parent.resource) {
+                               if(tg.statements[i+1] == consistsOf.resource) {
+                                       Identity identity = getIdentity(tg, tg.statements[i+3]);
+                                       if(identity != null) {
+                                               if(identity.definition instanceof Internal) {
+                                                       Internal internal = (Internal)identity.definition;
+                                                       result.put(internal.name, identity);
+                                               }
+                                       } else {
+                                               int possibleNameResource = getPossibleObject(tg, tg.statements[i+3], hasName);
+                                               if(possibleNameResource != 0) {
+                                                       Value value = findValue(tg, possibleNameResource);
+                                                       if(value != null) {
+                                                               try {
+                                                                       String name = (String)value.value.getValue(Bindings.STRING);
+                                                                       result.put(name, new Identity(tg.statements[i+3], new Internal(tg.statements[i], name)));
+                                                               } catch (AdaptException e) {
+                                                                       e.printStackTrace();
+                                                               }
+                                                       }
+                                               }
+                                       }
+                               }
                        }
                }
-               findExternal(tg, "http://www.simantics.org/Layer0-1.1/ConsistsOf");
+               return result.values();
+       }
+       
+       public static TIntArrayList getObjects(TransferableGraph1 tg, int subject, Identity predicate) {
+               TIntArrayList result = new TIntArrayList();
                for(int i=0;i<tg.statements.length;i+=4) {
-                       if(tg.statements[i] == parent.resource)
-                               System.err.println("related to parent  " + tg.statements[i+3]);
+                       if(tg.statements[i] == subject && tg.statements[i+1] == predicate.resource) {
+                               result.add(tg.statements[i+3]);
+                       }
                }
                return result;
        }
        
-       public static int getPossibleObject(TransferableGraph1 tg, Identity subject, String predicate) {
-               Identity p = findExternal(tg, predicate);
-               if(p == null) return 0;
+       public static int getPossibleObject(TransferableGraph1 tg, int subject, Identity predicate) {
                int result = 0;
                for(int i=0;i<tg.statements.length;i+=4) {
-                       if(tg.statements[i] == subject.resource && tg.statements[i+1] == p.resource) {
+                       if(tg.statements[i] == subject && tg.statements[i+1] == predicate.resource) {
                                if(result != 0) return 0;
                                result = tg.statements[i+3];
                        }
                }
                return result;
        }
+       
+       public static int getPossibleObject(TransferableGraph1 tg, Identity subject, String predicate) {
+               Identity p = findExternal(tg, predicate);
+               if(p == null) return 0;
+               return getPossibleObject(tg, subject.resource, p);
+       }
 
        public static Map<Identity, String> getNames(TransferableGraph1 tg, Collection<Identity> ids) {
                Map<Identity, String> result = new HashMap<Identity, String>();
@@ -159,11 +220,11 @@ public class TransferableGraphUtils {
                        else return getURI(resourceCount, identities, def.parent) + "/" + def.name;
                    } else if(definition instanceof Root) {
                        Root def = (Root)definition;
+                       if(def.name.isEmpty()) return "http:/";
                        return def.name;
                    } else if (definition instanceof Internal) {
                        Internal def = (Internal)definition;
-                       System.err.println("External URI error: parent was internal '" + def.name + "'");
-                       return "";
+                       return getURI(resourceCount, identities, def.parent) + "/" + def.name;
                    } else {
                        return "";
                    }
@@ -171,5 +232,39 @@ public class TransferableGraphUtils {
            }       
            return "<internal reference " + id + ">:";
        }
-       
+
+       public static TIntObjectMap<Identity> mapIdentities(TransferableGraph1 tg) {
+               return mapIdentities(tg.identities);
+       }
+
+       public static TIntObjectMap<Identity> mapIdentities(Identity[] identities) {
+               // Integer.MIN_VALUE cannot be the value of Identity.resource
+               TIntObjectMap<Identity> map = new TIntObjectHashMap<>(identities.length, 0.5f, Integer.MIN_VALUE);
+               for (Identity id : identities)
+                       map.put(id.resource, id);
+               return map;
+       }
+
+       public static String getURI(int resourceCount, TIntObjectMap<Identity> identities, int id) {
+               Identity identity = identities.get(id);
+               if(identity != null) {
+                       IdentityDefinition definition = identity.definition;
+                       if(definition instanceof External) {
+                               External def = (External)definition;
+                               if(def.parent == -1) return "http:/";
+                               else return getURI(resourceCount, identities, def.parent) + "/" + def.name;
+                       } else if(definition instanceof Root) {
+                               Root def = (Root)definition;
+                               if(def.name.isEmpty()) return "http:/";
+                               return def.name;
+                       } else if (definition instanceof Internal) {
+                               Internal def = (Internal)definition;
+                               return getURI(resourceCount, identities, def.parent) + "/" + def.name;
+                       } else {
+                               return "";
+                       }
+               }
+               return "<internal reference " + id + ">:";
+       }
+
 }