bundles/org.simantics.graph/src/org/simantics/graph/representation/TransferableGraphQueries.java

   1 package org.simantics.graph.representation;
   2
   3 import java.util.Comparator;
   4 import java.util.Set;
   5 import java.util.TreeMap;
   6 import java.util.TreeSet;
   7
   8 import gnu.trove.impl.Constants;
   9 import gnu.trove.list.array.TIntArrayList;
  10 import gnu.trove.map.hash.TIntObjectHashMap;
  11 import gnu.trove.map.hash.TObjectIntHashMap;
  12 import gnu.trove.procedure.TObjectProcedure;
  13
  14 public class TransferableGraphQueries {
  15
  16     private static final int NOT_FOUND = TransferableGraphUtils.NOT_FOUND;
  17
  18     private final TransferableGraph1 tg;
  19
  20     private final TIntObjectHashMap<Identity> internalIdentities = new TIntObjectHashMap<>(Constants.DEFAULT_CAPACITY, Constants.DEFAULT_LOAD_FACTOR, NOT_FOUND);
  21     private final TIntObjectHashMap<Identity> externalIdentities = new TIntObjectHashMap<>(Constants.DEFAULT_CAPACITY, Constants.DEFAULT_LOAD_FACTOR, NOT_FOUND);
  22     private final TIntObjectHashMap<Identity> rootIdentities = new TIntObjectHashMap<>(Constants.DEFAULT_CAPACITY, Constants.DEFAULT_LOAD_FACTOR, NOT_FOUND);
  23
  24     private final TObjectIntHashMap<String> internalIdentitiesByURI = new TObjectIntHashMap<>();
  25     private final TObjectIntHashMap<String> externalIdentitiesByURI = new TObjectIntHashMap<>();
  26     private final TObjectIntHashMap<String> rootIdentitiesByURI = new TObjectIntHashMap<>();
  27
  28     private final TIntObjectHashMap<TIntArrayList> statementsCache = new TIntObjectHashMap<>(Constants.DEFAULT_CAPACITY, Constants.DEFAULT_LOAD_FACTOR, NOT_FOUND);
  29
  30     public TransferableGraphQueries(TransferableGraph1 graph) {
  31         this.tg = graph;
  32
  33         // Calculate internals
  34         initializeIdentities();
  35     }
  36
  37     private void initializeIdentities() {
  38         for (Identity identity : tg.identities) {
  39             IdentityDefinition definition = identity.definition;
  40             if (definition instanceof Internal) {
  41                 Internal internal = (Internal) definition;
  42                 internalIdentities.put(identity.resource, identity);
  43                 internalIdentitiesByURI.put(getURI(identity), identity.resource);
  44             } else if (definition instanceof External) {
  45                 External external = (External) definition;
  46                 externalIdentities.put(identity.resource, identity);
  47                 externalIdentitiesByURI.put(getURI(identity), identity.resource);
  48             } else if (definition instanceof Root) {
  49                 Root root = (Root) definition;
  50                 rootIdentities.put(identity.resource, identity);
  51                 rootIdentitiesByURI.put(getURI(identity), identity.resource);
  52             }
  53         }
  54     }
  55
  56     public String getURI(Identity identity) {
  57         IdentityDefinition definition = identity.definition;
  58         if(definition instanceof External) {
  59             External def = (External)definition;
  60             if(def.parent == -1) return "http:/";
  61             else return getURI(def.parent) + "/" + def.name;
  62         } else if(definition instanceof Root) {
  63             Root def = (Root)definition;
  64             if(def.name.isEmpty()) return "http:/";
  65             return def.name;
  66         } else if (definition instanceof Internal) {
  67             Internal def = (Internal)definition;
  68             return getURI(def.parent) + "/" + def.name;
  69         } else if (definition instanceof Optional) {
  70             Optional def = (Optional)definition;
  71             return getURI(def.parent) + "/" + def.name;
  72         } else {
  73             return "";
  74         }
  75     }
  76
  77     public String getURI(int id) {
  78         Identity identity = getIdentity(id);
  79         if (identity == null)
  80             return "<internal reference " + id + ">:";
  81         return getURI(identity);
  82     }
  83
  84     private static final Comparator<Identity> IDENTITY_NAME_COMPARATOR = new Comparator<Identity>() {
  85
  86         @Override
  87         public int compare(Identity o1, Identity o2) {
  88             if (o1.definition instanceof Internal && o2.definition instanceof Internal) {
  89                 Internal i1 = (Internal) o1.definition;
  90                 Internal i2 = (Internal) o2.definition;
  91                 return i1.name.compareTo(i2.name);
  92             } else if (o1.definition instanceof External && o2.definition instanceof External) {
  93                 External e1 = (External) o1.definition;
  94                 External e2 = (External) o2.definition;
  95                 return e1.name.compareTo(e2.name);
  96             } else {
  97                 throw new IllegalArgumentException(o1 + " " + o2);
  98             }
  99         }
 100     };
 101
 102     public Set<Identity> getChildren(Identity parent) {
 103         TreeSet<Identity> children = new TreeSet<>(IDENTITY_NAME_COMPARATOR);
 104         internalIdentities.forEachEntry((resource, identity) -> {
 105             Internal internal = (Internal) identity.definition;
 106             if (internal.parent == parent.resource)
 107                 children.add(identity);
 108             return true;
 109         });
 110
 111         return children;
 112     }
 113
 114     public Identity findInternalByName(String name) {
 115         int internal = internalIdentitiesByURI.get(name);
 116         if (internal == NOT_FOUND)
 117             return null;
 118         return internalIdentities.get(internal);
 119     }
 120
 121     private Identity findExternalByName(String name) {
 122         int external = externalIdentitiesByURI.get(name);
 123         if (external == NOT_FOUND)
 124             return null;
 125         return externalIdentities.get(external);
 126     }
 127
 128     private Identity findExternalByNameAndParent(String name, int parent) {
 129         Identity external = findExternalByName(name);
 130         if (external.resource == parent)
 131             return external;
 132         return null;
 133     }
 134
 135     public Identity findExternalByURI(String uri) {
 136         int v = externalIdentitiesByURI.get(uri);
 137         if (v == NOT_FOUND)
 138             return null;
 139         return externalIdentities.get(v);
 140     }
 141
 142     public Identity findRootByName(String name) {
 143         int root = rootIdentitiesByURI.get(name);
 144         if (root == NOT_FOUND)
 145             return null;
 146         return rootIdentities.get(root);
 147     }
 148
 149     public String getName(Identity identity) {
 150         return TransferableGraphUtils.getName(identity);
 151     }
 152
 153     public void forIdentities(TObjectProcedure<Identity> procedure) {
 154         for (Identity identity : tg.identities) {
 155             if (!procedure.execute(identity)) {
 156                 break;
 157             }
 158         }
 159     }
 160
 161     public Identity getIdentity(int resource) {
 162         Identity result = rootIdentities.get(resource);
 163         if (result == null)
 164             result = externalIdentities.get(resource);
 165         if (result == null)
 166             result = internalIdentities.get(resource);
 167         return result;
 168     }
 169
 170     public Value findValue(int object) {
 171         return TransferableGraphUtils.findValue(tg, object);
 172     }
 173
 174     public TreeMap<String, TreeSet<Integer>> sortByPredicateUniqueStatements(int resource) {
 175         TreeMap<String, TreeSet<Integer>> results = new TreeMap<>();
 176         TIntArrayList statements = getStatements(resource);
 177         for (int i = 0; i < statements.size(); i += 2) {
 178             int predicate = statements.get(i);
 179             String predicateURI = getURI(predicate);
 180             TreeSet<Integer> objects = results.get(predicateURI);
 181             if (objects == null) {
 182                 objects = new TreeSet<>();
 183             }
 184             objects.add(statements.get(i + 1));
 185             results.put(predicateURI, objects);
 186         }
 187         return results;
 188     }
 189
 190     public TIntArrayList getStatements(int resource) {
 191 //        System.out.println("getting statements with " + resource);
 192         TIntArrayList statements = statementsCache.get(resource);
 193         if (statements == null) {
 194             statements = TransferableGraphUtils.getStatements(tg, resource);
 195             statementsCache.put(resource, statements);
 196         }
 197         return statements;
 198     }
 199
 200     public int getPossibleObject(int subject, Identity predicate) {
 201         return TransferableGraphUtils.getPossibleObject2(tg, subject, predicate);
 202     }
 203
 204     public TransferableGraph1 getGraph() {
 205         return tg;
 206     }
 207
 208 }