4162f91636d0b39dfb193d7bb93c076e9885b849
[simantics/platform.git] / bundles / org.simantics.db.layer0 / src / org / simantics / db / layer0 / genericrelation / DependenciesRelation.java
1 /*******************************************************************************
2  * Copyright (c) 2007, 2010 Association for Decentralized Information Management
3  * in Industry THTH ry.
4  * All rights reserved. This program and the accompanying materials
5  * are made available under the terms of the Eclipse Public License v1.0
6  * which accompanies this distribution, and is available at
7  * http://www.eclipse.org/legal/epl-v10.html
8  *
9  * Contributors:
10  *     VTT Technical Research Centre of Finland - initial API and implementation
11  *******************************************************************************/
12 package org.simantics.db.layer0.genericrelation;
13
14 import java.util.ArrayList;
15 import java.util.Arrays;
16 import java.util.Collection;
17 import java.util.Collections;
18 import java.util.HashSet;
19 import java.util.List;
20 import java.util.Map;
21 import java.util.UUID;
22
23 import org.simantics.databoard.Bindings;
24 import org.simantics.databoard.util.ObjectUtils;
25 import org.simantics.datatypes.literal.GUID;
26 import org.simantics.db.AsyncReadGraph;
27 import org.simantics.db.ChangeSet;
28 import org.simantics.db.ChangeSet.StatementChange;
29 import org.simantics.db.MetadataI;
30 import org.simantics.db.ReadGraph;
31 import org.simantics.db.RequestProcessor;
32 import org.simantics.db.Resource;
33 import org.simantics.db.Session;
34 import org.simantics.db.Statement;
35 import org.simantics.db.WriteGraph;
36 import org.simantics.db.common.Indexing;
37 import org.simantics.db.common.changeset.GenericChangeListener;
38 import org.simantics.db.common.request.IndexRoot;
39 import org.simantics.db.common.request.ReadRequest;
40 import org.simantics.db.common.request.SuperTypeString;
41 import org.simantics.db.common.request.TypeString;
42 import org.simantics.db.common.request.UnaryRead;
43 import org.simantics.db.common.utils.Logger;
44 import org.simantics.db.common.utils.NameUtils;
45 import org.simantics.db.event.ChangeListener;
46 import org.simantics.db.exception.DatabaseException;
47 import org.simantics.db.layer0.adapter.GenericRelation;
48 import org.simantics.db.layer0.adapter.GenericRelationIndex;
49 import org.simantics.db.layer0.genericrelation.DependencyChanges.Change;
50 import org.simantics.db.layer0.genericrelation.DependencyChanges.ComponentAddition;
51 import org.simantics.db.layer0.genericrelation.DependencyChanges.ComponentModification;
52 import org.simantics.db.layer0.genericrelation.DependencyChanges.ComponentRemoval;
53 import org.simantics.db.layer0.genericrelation.DependencyChanges.LinkChange;
54 import org.simantics.db.procedure.AsyncContextMultiProcedure;
55 import org.simantics.db.procedure.AsyncContextProcedure;
56 import org.simantics.db.service.CollectionSupport;
57 import org.simantics.db.service.DirectQuerySupport;
58 import org.simantics.db.service.GraphChangeListenerSupport;
59 import org.simantics.db.service.ManagementSupport;
60 import org.simantics.db.service.SerialisationSupport;
61 import org.simantics.layer0.Layer0;
62 import org.simantics.operation.Layer0X;
63 import org.simantics.utils.datastructures.Pair;
64 import org.simantics.utils.logging.TimeLogger;
65
66 public class DependenciesRelation extends UnsupportedRelation implements GenericRelationIndex {
67
68         private static final boolean DEBUG = false;
69         static final boolean DEBUG_LISTENERS = false;
70         private static final boolean PROFILE = false;
71
72         @SuppressWarnings("unchecked")
73         private final static Pair<String, String>[] fields = new Pair[] {
74                 Pair.make(Dependencies.FIELD_MODEL, "Long"),
75                 Pair.make(Dependencies.FIELD_PARENT, "Long"),
76                 Pair.make(Dependencies.FIELD_RESOURCE, "Long"),
77                 Pair.make(Dependencies.FIELD_NAME, "String"),
78                 Pair.make(Dependencies.FIELD_TYPES, "Text"),
79                 Pair.make(Dependencies.FIELD_GUID, "Text")
80         };
81
82         final Resource resource;
83
84         public DependenciesRelation(ReadGraph graph, Resource resource) {
85                 this.resource = resource;
86                 synchronized(this) {
87                         Session session = graph.getSession();
88                         DependenciesListenerStore store = session.peekService(DependenciesListenerStore.class);
89                         if(store == null) session.registerService(DependenciesListenerStore.class, new DependenciesListenerStore());
90                 }
91         }
92
93         class Process {
94
95                 final ArrayList<Entry> result = new ArrayList<Entry>();
96                 final AsyncContextMultiProcedure<Resource, Resource> structure;
97                 final AsyncContextProcedure<Entry, String> names;
98                 final AsyncContextProcedure<Entry, Resource> type;
99
100                 Process(ReadGraph graph, final Resource resource) throws DatabaseException {
101
102                         final Layer0 L0 = Layer0.getInstance(graph);
103                         final DirectQuerySupport dqs = graph.getService(DirectQuerySupport.class);
104                         final CollectionSupport cs = graph.getService(CollectionSupport.class);
105
106                         names = dqs.compilePossibleRelatedValue(graph, L0.HasName, new AsyncContextProcedure<Entry, String>() {
107
108                                 @Override
109                                 public void execute(AsyncReadGraph graph, Entry entry, String name) {
110                                         entry.name = name;
111                                 }
112
113                                 @Override
114                                 public void exception(AsyncReadGraph graph, Throwable throwable) {
115                                         Logger.defaultLogError(throwable);
116                                 }
117
118                         });
119
120                         type = new AsyncContextProcedure<Entry, Resource>() {
121
122                                 @Override
123                                 public void execute(AsyncReadGraph graph, Entry entry, Resource type) {
124                                         entry.principalType = type;
125                                 }
126
127                                 @Override
128                                 public void exception(AsyncReadGraph graph, Throwable throwable) {
129                                         Logger.defaultLogError(throwable);
130                                 }
131
132                         };
133
134                         structure = dqs.compileForEachObject(graph, L0.ConsistsOf, new AsyncContextMultiProcedure<Resource, Resource>() {
135
136                                 @Override
137                                 public void execute(AsyncReadGraph graph, Resource parent, Resource child) {
138                                         // WORKAROUND: don't browse virtual child resources
139                                         if(!child.isPersistent()) return;
140                                         Entry entry = new Entry(parent, child, "", "", "");
141                                         result.add(entry);
142                                         dqs.forEachObjectCompiled(graph, child, child, structure);
143                                         dqs.forPossibleRelatedValueCompiled(graph, child, entry, names);
144                                         dqs.forPossibleDirectType(graph, child, entry, type);
145                                 }
146
147                                 @Override
148                                 public void finished(AsyncReadGraph graph, Resource parent) {
149                                 }
150
151                                 @Override
152                                 public void exception(AsyncReadGraph graph, Throwable throwable) {
153                                         Logger.defaultLogError(throwable);
154                                 }
155
156                         });
157
158                         graph.syncRequest(new ReadRequest() {
159
160                                 @Override
161                                 public void run(ReadGraph graph) throws DatabaseException {
162                                         dqs.forEachObjectCompiled(graph, resource, resource, structure);
163                                 }
164
165                         });
166
167             Map<Resource, String> typeStrings = cs.createMap(String.class);
168                         for(Entry e : result) {
169                                 if(e.principalType != null) {
170                                     String typeString = typeStrings.get(e.principalType);
171                                     if(typeString == null) {
172                                         typeString = graph.syncRequest(new SuperTypeString(e.principalType));
173                                         if (typeString.isEmpty()) {
174                                             Logger.defaultLogError(new DatabaseException("No name for type " + NameUtils.getURIOrSafeNameInternal(graph, e.resource) + " (" + e.resource + ")"));
175                                         }
176                                         typeStrings.put(e.principalType, typeString);
177                                     }
178                                     e.types = typeString;
179                                 } else {
180                                     e.types = graph.syncRequest(new TypeString(L0, graph.getTypes(e.resource)));
181                                 }
182                                 GUID id = graph.getPossibleRelatedValue(e.resource, L0.identifier, GUID.BINDING);
183                                 if(id != null)
184                                         e.id = id.indexString();
185                                 else 
186                                         e.id = "";
187                         }
188
189                         //SessionGarbageCollection.gc(null, graph.getSession(), false, null);
190                         
191                 }
192
193         }
194
195         public ArrayList<Entry> find(ReadGraph graph, final Resource model) throws DatabaseException {
196                 return new Process(graph, model).result;
197         }
198
199         @Override
200         public GenericRelation select(String bindingPattern, Object[] constants) {
201                 checkSelectionArguments(bindingPattern, constants, new String[] { Dependencies.getBindingPattern() });
202                 final long subjectId = (Long)constants[0];
203                 return new UnsupportedRelation() {
204
205                         @Override
206                         public boolean isRealizable() {
207                                 return true;
208                         }
209
210                         @Override
211                         final public List<Object[]> realize(ReadGraph graph) throws DatabaseException {
212
213                                 long time = System.nanoTime();
214
215                 SerialisationSupport ss = graph.getService(SerialisationSupport.class);
216
217                                 Resource subject = ss.getResource(subjectId); 
218                                 
219                                 Collection<Entry> entries = find(graph, subject);
220
221                                 long time2 = System.nanoTime();
222
223                                 if (PROFILE)
224                                         System.out.println("Found " + entries.size() + " dependencies in " + 1e-6 * (time2 - time) + "ms for " + graph.getPossibleURI(subject) + ".");
225
226                                 ArrayList<Object[]> result = new ArrayList<Object[]>();
227                                 for (Entry entry : entries) {
228                                         result.add(new Object[] { ss.getRandomAccessId(entry.parent), ss.getRandomAccessId(entry.resource), entry.name, entry.types, entry.id });
229                                 }
230                                 return result;
231
232                         }
233
234                 };
235         }
236
237         @Override
238         public Pair<String, String>[] getFields() {
239                 return fields;
240         }
241
242         @Override
243         public List<Map<String, Object>> query(RequestProcessor session, String search, String bindingPattern, Object[] constants, int maxResultCount) {
244                 if(!Dependencies.getBindingPattern().equals(bindingPattern)) throw new IllegalArgumentException("DependenciesRelation supports indexing only with 'bfffff'");
245                 IndexedRelations indexer = session.getService(IndexedRelations.class);
246                 return indexer.query(null, search, session, resource, (Resource)constants[0], maxResultCount);
247         }
248         
249         @Override
250         public List<Resource> queryResources(RequestProcessor session, String search, String bindingPattern, Object[] constants, int maxResultCount) {
251                 if(!Dependencies.getBindingPattern().equals(bindingPattern)) throw new IllegalArgumentException("DependenciesRelation supports indexing only with 'bfffff'");
252                 IndexedRelations indexer = session.getService(IndexedRelations.class);
253                 return indexer.queryResources(null, search, session, resource, (Resource)constants[0], maxResultCount);
254         }
255
256         @Override
257         public List<Map<String, Object>> list(RequestProcessor session, String bindingPattern, Object[] constants, int maxResultCount) {
258                 if(!Dependencies.getBindingPattern().equals(bindingPattern)) throw new IllegalArgumentException("DependenciesRelation supports indexing only with 'bfffff'");
259                 IndexedRelations indexer = session.getService(IndexedRelations.class);
260                 return indexer.query(null, null, session, resource, (Resource)constants[0], maxResultCount);
261         }
262
263         public static class DependencyChangesRequest extends UnaryRead<ChangeSet, DependencyChanges> {
264
265                 @SuppressWarnings("unused")
266                 final private static boolean LOG = false;
267
268                 public DependencyChangesRequest(ChangeSet parameter) {
269                         super(parameter);
270                 }
271
272                 @Override
273                 public DependencyChanges perform(ReadGraph graph) throws DatabaseException {
274
275                         DependencyChangesWriter w = new DependencyChangesWriter(graph);
276                         Layer0 l0 = w.l0;
277                         Resource changeInformation = graph.getPossibleResource("http://www.simantics.org/Modeling-1.2/changeInformation/Inverse");
278
279                         for (Resource value : parameter.changedValues()) {
280                                 Statement modifiedComponent = graph.getPossibleStatement(value, l0.PropertyOf);
281                                 if (modifiedComponent == null
282                                                 || modifiedComponent.getPredicate().equals(changeInformation))
283                                         continue;
284                                 //System.err.println("+comp modi " + NameUtils.getSafeName(graph, renamedComponent, true));
285                                 w.addComponentModification(modifiedComponent.getObject());
286                         }
287                         for (Resource value : parameter.changedResources()) {
288                                 // No more info => need to check further
289                                 if(!graph.isImmutable(value))
290                                         w.addComponentModification(value);
291                         }
292                         for (StatementChange change : parameter.changedStatements()) {
293                                 //System.err.println("-stm " + NameUtils.getSafeName(graph, change.getSubject(), true) + " " + NameUtils.getSafeName(graph, change.getPredicate(), true) + " " + NameUtils.getSafeName(graph, change.getObject(), true));
294                                 Resource subject = change.getSubject();
295                                 Resource predicate = change.getPredicate();
296                                 Resource object = change.getObject();
297                                 if(!object.isPersistent()) continue;
298                                 if (predicate.equals(l0.ConsistsOf)) {
299                                         if (change.isClaim())
300                                                 w.addComponentAddition(subject, object);
301                                         else 
302                                                 w.addComponentRemoval(subject, object);
303                                 } else if (predicate.equals(l0.IsLinkedTo)) {
304                                         w.addLinkChange(subject);
305                                 } else /*if (graph.isSubrelationOf(predicate, l0.DependsOn))*/ {
306                                         //System.err.println("-modi " + NameUtils.getSafeName(graph, subject, true));
307                                         w.addComponentModification(subject);
308                                 } 
309                         }
310                         return w.getResult();
311                 }
312
313         };
314
315         private static int trackers = 0;
316         
317         private static ChangeListener listener;
318
319         public static void assertFinishedTracking() {
320             if(trackers != 0) throw new IllegalStateException("Trackers should be 0 (was " + trackers + ")");
321         }
322         
323         @Override
324         public synchronized void untrack(RequestProcessor processor, final Resource model) {
325
326             trackers--;
327             
328             if(trackers < 0) throw new IllegalStateException("Dependency tracking reference count is broken");
329             
330             if(trackers == 0) {
331                 
332                 if(listener == null) throw new IllegalStateException("Dependency tracking was not active");
333             
334                 GraphChangeListenerSupport changeSupport = processor.getService(GraphChangeListenerSupport.class);
335                 changeSupport.removeMetadataListener(listener);
336                 listener = null;
337                         
338             }
339             
340         }
341
342         @Override
343         public synchronized void trackAndIndex(RequestProcessor processor, Resource model__) {
344
345             if(trackers == 0) {
346
347                 if(listener != null) throw new IllegalStateException("Dependency tracking was active");
348
349                 listener = new GenericChangeListener<DependencyChangesRequest, DependencyChanges>() {
350
351                     @Override
352                     public boolean preEventRequest() {
353                         return !Indexing.isDependenciesIndexingDisabled();
354                     }
355
356                     @Override
357                     public void onEvent(ReadGraph graph, MetadataI metadata, DependencyChanges event) throws DatabaseException {
358
359                         TimeLogger.log(DependenciesRelation.class, "trackAndIndex.onEvent: starting index update processing");
360
361                         if(DEBUG)
362                             System.err.println("Adding metadata " + event + " in revision " + graph.getService(ManagementSupport.class).getHeadRevisionId());
363
364                         WriteGraph w = (WriteGraph)graph;
365                         if(!event.isEmpty())
366                                 w.addMetadata(event);
367
368                         final Session session = graph.getSession();
369                         final IndexedRelations indexer = session.getService(IndexedRelations.class);
370                         Layer0 L0 = Layer0.getInstance(graph);
371                         SerialisationSupport ss = graph.getService(SerialisationSupport.class);
372
373                         for(Map.Entry<Resource, Change[]>  modelEntry : event.get().entrySet()) {
374
375                             final Resource model = modelEntry.getKey();
376                             final Change[] changes = modelEntry.getValue();
377
378                             boolean linkChange = false;
379
380                             Collection<Object[]> _additions = Collections.emptyList();
381                             Collection<Object> _removals = Collections.emptyList();
382                             Collection<Object> _replacementKeys = Collections.emptyList();
383                             Collection<Object[]> _replacementObjects = Collections.emptyList();
384                             Collection<Pair<String, String>> _typeChanges = Collections.emptyList();
385
386                             if(DEBUG) System.out.println("MODEL: " + NameUtils.getSafeLabel(graph, model));
387                             //                final Change[] changes = event.get(model);
388                             if(DEBUG) System.out.println("  CHANGES: " + Arrays.toString(changes));
389                             if (changes != null) {
390                                 _additions = new ArrayList<Object[]>();
391                                 _removals = new ArrayList<Object>();
392                                 _replacementKeys = new ArrayList<Object>();
393                                 _replacementObjects = new ArrayList<Object[]>();
394                                 _typeChanges = new HashSet<Pair<String, String>>();
395
396                                 for (Change _entry : changes) {
397                                     if (_entry instanceof ComponentAddition) {
398                                         ComponentAddition entry = (ComponentAddition)_entry;
399                                         final String name = graph.getPossibleRelatedValue(entry.component, L0.HasName, Bindings.STRING);
400                                         final GUID id = graph.getPossibleRelatedValue(entry.component, L0.identifier, GUID.BINDING);
401                                         final String types = graph.syncRequest(new TypeString(L0, graph.getTypes(entry.component)));
402                                         if (name != null && types != null) {
403                                                 if(!entry.isValid(graph)) continue;
404                                             Resource parent = graph.getPossibleObject(entry.component, L0.PartOf);
405                                             if (parent != null) {
406                                                 _additions.add(new Object[] { ss.getRandomAccessId(parent), ss.getRandomAccessId(entry.component), name, types, id != null ? id.indexString() : "" });
407                                             } else {
408                                                     //System.err.println("resource " + entry.component + ": no parent for entry " + name + " " + types);
409                                             }
410                                         } else {
411                                             //System.err.println("resource " + entry.component + ": " + name + " " + types);
412                                         }
413                                     } else if(_entry instanceof ComponentModification) {
414                                         ComponentModification entry = (ComponentModification)_entry;
415                                         final String name = graph.getPossibleRelatedValue(entry.component, L0.HasName, Bindings.STRING);
416                                         final GUID id = graph.getPossibleRelatedValue(entry.component, L0.identifier, GUID.BINDING);
417                                         if(graph.isInstanceOf(entry.component, L0.Type)) {
418                                             SerialisationSupport support = session.getService(SerialisationSupport.class);
419                                             _typeChanges.add(new Pair<String, String>(name, String.valueOf(support.getRandomAccessId((Resource) entry.component))));
420                                         } else {
421                                             final String types = graph.syncRequest(new TypeString(L0, graph.getTypes(entry.component)));
422                                             if (name != null && types != null) {
423                                                 Resource part = graph.getPossibleObject(entry.component, L0.PartOf);
424                                                 if(part != null) {
425                                                     _replacementKeys.add(ss.getRandomAccessId(entry.component));
426                                                     _replacementObjects.add(new Object[] { ss.getRandomAccessId(part), 
427                                                             ss.getRandomAccessId(entry.component), name, types, id != null ? id.indexString() : "" });
428                                                 }
429                                             }
430                                         }
431                                     } else if (_entry instanceof ComponentRemoval) {
432                                         ComponentRemoval entry = (ComponentRemoval)_entry;
433                                         if(!entry.isValid(graph)) continue;
434                                         _removals.add(ss.getRandomAccessId(((ComponentRemoval)_entry).component));
435                                     } else if (_entry instanceof LinkChange) {
436                                         linkChange = true;
437                                     }
438                                 }
439                             }
440
441                             final boolean reset = linkChange || event.hasUnresolved;
442                             //System.err.println("dependencies(" + NameUtils.getSafeLabel(graph, model) + "): reset=" + reset + " linkChange=" + linkChange + " unresolved=" + event.hasUnresolved );
443
444                             if (reset || !_additions.isEmpty() || !_removals.isEmpty() || !_replacementKeys.isEmpty() || !_typeChanges.isEmpty()) {
445
446                                 TimeLogger.log(DependenciesRelation.class, "trackAndIndex.onEvent: starting index update");
447
448                                 final Collection<Object[]> additions = _additions;
449                                 final Collection<Object> removals = _removals;
450                                 final Collection<Object> replacementKeys = _replacementKeys;
451                                 final Collection<Object[]> replacementObjects = _replacementObjects; 
452                                 final boolean typeNameChanges = typeNameChanges(graph, indexer, model, _typeChanges);
453
454                             final UUID pending = Indexing.makeIndexPending();
455
456                             {
457                                 {
458                                         try {
459                                             boolean didChange = false;
460                                             // Unresolved and linkChanges are not relevant any more
461                                             boolean doReset = typeNameChanges;
462
463                                             if (doReset) {
464
465                                             if(DEBUG) {
466                                                 System.err.println("resetIndex " + reset + " " + typeNameChanges);
467                                             }
468
469                                                 indexer.removeAll(null, graph, DependenciesRelation.this, resource, model);
470                                                 didChange = true;
471
472                                             } else {
473
474                                                 if (!replacementKeys.isEmpty() && (replacementKeys.size() == replacementObjects.size())) {
475                                                     if(DEBUG) {
476                                                         System.out.println(replacementKeys.size() + " index replacements: " + replacementKeys);
477                                                     }
478                                                     didChange |= indexer.replace(null, graph, DependenciesRelation.this, resource, model, Dependencies.FIELD_RESOURCE, replacementKeys, replacementObjects);
479                                                 }
480                                                 if (!removals.isEmpty()) {
481                                                     if(DEBUG) {
482                                                         System.out.println(removals.size() + " index removals: " + removals);
483                                                     }
484                                                     indexer.remove(null, graph, DependenciesRelation.this, resource, model, Dependencies.FIELD_RESOURCE, removals);
485                                                     didChange = true;
486                                                 }
487                                                 if (!additions.isEmpty()) {
488                                                     if(DEBUG) {
489                                                         for(Object[] os : additions) System.err.println("Adding to index " + model + ": " + Arrays.toString(os));
490                                                     }
491                                                     //System.out.println(additions.size() + " index insertions");
492                                                     indexer.insert(null, graph, DependenciesRelation.this, resource, model, additions);
493                                                     didChange = true;
494                                                 }
495
496                                             }
497
498                                             if (didChange)
499                                                 // TODO: because this data is ran with
500                                                 // ThreadUtils.getBlockingWorkExecutor()
501                                                 // fireListeners needs to use peekService,
502                                                 // not getService since there is no
503                                                 // guarantee that the session isn't being
504                                                 // disposed while this method is executing.
505                                                 fireListeners(graph, model);
506
507                                         } catch (Throwable t) {
508                                             // Just to know if something unexpected happens here.
509                                             Logger.defaultLogError("Dependencies index update failed for model "
510                                                     + model + " and relation " + resource + ".", t);
511                                             t.printStackTrace();
512
513                                             // NOTE: Last resort: failure to update index
514                                             // properly results in removal of the whole index.
515                                             // This is the only thing that can be done
516                                             // at this point to ensure that the index will
517                                             // return correct results in the future, through
518                                             // complete reinitialization. 
519                                             //indexer.removeAll(null, session, DependenciesRelation.this, resource, model);
520                                         } finally {
521                                             Indexing.releaseIndexPending(pending);
522                                             Indexing.clearCaches(model);
523                                         }
524                                 }
525                             }
526
527                                 TimeLogger.log(DependenciesRelation.class, "trackAndIndex.onEvent: index update done");
528                             }
529                         }
530
531                     }
532
533                 };
534
535                 GraphChangeListenerSupport changeSupport = processor.getService(GraphChangeListenerSupport.class);
536                 changeSupport.addMetadataListener(listener);
537
538             }
539
540             trackers++;
541
542         }
543
544         private boolean typeNameChanges(ReadGraph graph, IndexedRelations indexer,
545                         Resource model, final Collection<Pair<String, String>> typeChanges)
546                         throws DatabaseException {
547                 if (typeChanges.isEmpty())
548                         return false;
549
550                 for (Pair<String, String> nr : typeChanges) {
551                         String query = Dependencies.FIELD_RESOURCE + ":[" + nr.second + " TO " + nr.second + "]";
552                         //System.out.println("query: " + query);
553                         List<Map<String, Object>> results = indexer.query(null, query, graph, resource, model, Integer.MAX_VALUE);
554                         if (results.size() != 1) {
555                                 return true;
556                         } else {
557                                 Map<String, Object> result = results.get(0);
558                                 if (!ObjectUtils.objectEquals(result.get(Dependencies.FIELD_NAME), nr.first)) {
559                                         return true;
560                                 }
561                         }
562 //                      System.err.println("Type " + nr.first + " was unchanged.");
563                 }
564                 return false;
565         }
566
567         @Override
568         public void addListener(RequestProcessor processor, Resource model, Runnable observer) {
569                 DependenciesListenerStore store = processor.getSession().getService(DependenciesListenerStore.class);
570                 store.addListener(model, observer);
571         }
572
573         @Override
574         public void removeListener(RequestProcessor processor, Resource model, Runnable observer) {
575                 DependenciesListenerStore store = processor.getSession().getService(DependenciesListenerStore.class);
576                 store.removeListener(model, observer);
577         }
578
579         void fireListeners(RequestProcessor processor, Resource model) {
580                 DependenciesListenerStore store = processor.getSession().peekService(DependenciesListenerStore.class);
581                 if (store != null)
582                         store.fireListeners(model);
583         }
584
585         @Override
586         public void reset(RequestProcessor processor, Resource input) {
587                 if (DEBUG) {
588                         System.out.println("DependenciesRelation.reset: " + input);
589                         new Exception("DependenciesRelation.reset(" + listener + ")").printStackTrace(System.out);
590                 }
591                 DependenciesListenerStore store = processor.getSession().getService(DependenciesListenerStore.class);
592                 store.fireListeners(input);
593         }
594
595         public static void addSubtree(ReadGraph graph, Resource root) throws DatabaseException {
596
597                 Resource indexRoot = graph.syncRequest(new IndexRoot(root));
598                 addSubtree(graph, indexRoot, root);
599
600         }
601
602         public static void addSubtree(ReadGraph graph, Resource indexRoot, Resource subtreeRoot) throws DatabaseException {
603                 
604                 DependenciesRelation dr = new DependenciesRelation(graph, indexRoot);
605         SerialisationSupport ss = graph.getService(SerialisationSupport.class);
606
607         ArrayList<Entry> entries = dr.find(graph, subtreeRoot);
608         entries.add(new Entry(graph, subtreeRoot));
609
610                 ArrayList<Object[]> result = new ArrayList<Object[]>(entries.size());
611                 for (Entry entry : entries) {
612                         result.add(new Object[] { ss.getRandomAccessId(entry.parent), ss.getRandomAccessId(entry.resource), entry.name, entry.types, entry.id });
613                 }
614
615                 Layer0X L0X = Layer0X.getInstance(graph);
616         IndexedRelations indexer = graph.getService(IndexedRelations.class);
617         indexer.insert(null, graph, dr, L0X.DependenciesRelation, indexRoot, result);
618                 
619         }
620         
621 }