1 package org.simantics.interop.mapping;
\r
3 import java.util.Collection;
\r
4 import java.util.Set;
\r
5 import java.util.TreeMap;
\r
7 import org.simantics.databoard.accessor.Accessor;
\r
8 import org.simantics.databoard.binding.Binding;
\r
9 import org.simantics.databoard.type.Datatype;
\r
10 import org.simantics.databoard.util.binary.RandomAccessBinary;
\r
11 import org.simantics.db.Metadata;
\r
12 import org.simantics.db.Resource;
\r
13 import org.simantics.db.Session;
\r
14 import org.simantics.db.Statement;
\r
15 import org.simantics.db.VirtualGraph;
\r
16 import org.simantics.db.WriteGraph;
\r
17 import org.simantics.db.exception.AdaptionException;
\r
18 import org.simantics.db.exception.AssumptionException;
\r
19 import org.simantics.db.exception.BindingException;
\r
20 import org.simantics.db.exception.DatabaseException;
\r
21 import org.simantics.db.exception.DoesNotContainValueException;
\r
22 import org.simantics.db.exception.ManyObjectsForFunctionalRelationException;
\r
23 import org.simantics.db.exception.NoInverseException;
\r
24 import org.simantics.db.exception.NoSingleResultException;
\r
25 import org.simantics.db.exception.ResourceNotFoundException;
\r
26 import org.simantics.db.exception.ServiceException;
\r
27 import org.simantics.db.exception.ServiceNotFoundException;
\r
28 import org.simantics.db.exception.ValidationException;
\r
29 import org.simantics.db.procedure.AsyncListener;
\r
30 import org.simantics.db.procedure.AsyncMultiListener;
\r
31 import org.simantics.db.procedure.AsyncMultiProcedure;
\r
32 import org.simantics.db.procedure.AsyncProcedure;
\r
33 import org.simantics.db.procedure.AsyncSetListener;
\r
34 import org.simantics.db.procedure.Listener;
\r
35 import org.simantics.db.procedure.MultiListener;
\r
36 import org.simantics.db.procedure.MultiProcedure;
\r
37 import org.simantics.db.procedure.Procedure;
\r
38 import org.simantics.db.procedure.SetListener;
\r
39 import org.simantics.db.procedure.SyncListener;
\r
40 import org.simantics.db.procedure.SyncMultiListener;
\r
41 import org.simantics.db.procedure.SyncMultiProcedure;
\r
42 import org.simantics.db.procedure.SyncProcedure;
\r
43 import org.simantics.db.procedure.SyncSetListener;
\r
44 import org.simantics.db.request.AsyncMultiRead;
\r
45 import org.simantics.db.request.AsyncRead;
\r
46 import org.simantics.db.request.DelayedWrite;
\r
47 import org.simantics.db.request.DelayedWriteResult;
\r
48 import org.simantics.db.request.ExternalRead;
\r
49 import org.simantics.db.request.MultiRead;
\r
50 import org.simantics.db.request.Read;
\r
51 import org.simantics.db.request.ReadInterface;
\r
52 import org.simantics.db.request.Write;
\r
53 import org.simantics.db.request.WriteInterface;
\r
54 import org.simantics.db.request.WriteOnly;
\r
55 import org.simantics.db.request.WriteOnlyResult;
\r
56 import org.simantics.db.request.WriteResult;
\r
57 import org.simantics.db.request.WriteTraits;
\r
58 import org.simantics.scl.types.Type;
\r
59 import org.simantics.utils.datastructures.Callback;
\r
63 * @author Marko Luukkainen <marko.luukkainen@vtt.fi>
\r
66 public class WriteGraphProxy implements WriteGraph {
\r
68 protected WriteGraph graph;
\r
72 public <T> T getRelatedValue2(Resource subject, Resource relation)
\r
73 throws DatabaseException {
\r
74 return graph.getRelatedValue2(subject, relation);
\r
78 public <T> T getRelatedValue2(Resource subject, Resource relation,
\r
79 Binding binding) throws DatabaseException {
\r
80 return graph.getRelatedValue2(subject, relation, binding);
\r
84 public <T> T getRelatedValue2(Resource subject, Resource relation,
\r
85 Object context) throws DatabaseException {
\r
86 return graph.getRelatedValue2(subject, relation, context);
\r
90 public <T> T getRelatedValue2(Resource subject, Resource relation,
\r
91 Object context, Binding binding) throws DatabaseException {
\r
92 return graph.getRelatedValue2(subject, relation, context, binding);
\r
96 public <T> T getPossibleRelatedValue2(Resource subject, Resource relation)
\r
97 throws DatabaseException {
\r
98 return graph.getPossibleRelatedValue2(subject, relation);
\r
102 public <T> T getPossibleRelatedValue2(Resource subject, Resource relation,
\r
103 Binding binding) throws DatabaseException {
\r
104 return graph.getPossibleRelatedValue2(subject, relation, binding);
\r
108 public <T> T getPossibleRelatedValue2(Resource subject, Resource relation,
\r
109 Object context) throws DatabaseException {
\r
110 return graph.getPossibleRelatedValue2(subject, relation, context);
\r
114 public <T> T getPossibleRelatedValue2(Resource subject, Resource relation,
\r
115 Object context, Binding binding) throws DatabaseException {
\r
116 return getPossibleRelatedValue2(subject, relation, context, binding);
\r
120 public <T> void async(ReadInterface<T> r, AsyncListener<T> procedure) {
\r
121 graph.async(r,procedure);
\r
125 public <T> void async(ReadInterface<T> r, AsyncProcedure<T> procedure) {
\r
126 graph.async(r, procedure);
\r
130 public <T> void async(ReadInterface<T> r, Listener<T> procedure) {
\r
131 graph.async(r, procedure);
\r
135 public <T> void async(ReadInterface<T> r, Procedure<T> procedure) {
\r
136 graph.async(r, procedure);
\r
140 public <T> void async(ReadInterface<T> r, SyncListener<T> procedure) {
\r
141 graph.async(r, procedure);
\r
145 public <T> void async(ReadInterface<T> r, SyncProcedure<T> procedure) {
\r
146 graph.async(r, procedure);
\r
150 public <T> void async(WriteInterface<T> r) {
\r
155 public <T> void async(WriteInterface<T> r, Procedure<T> procedure) {
\r
156 graph.async(r, procedure);
\r
160 public <T> T sync(ReadInterface<T> r) throws DatabaseException {
\r
161 return graph.sync(r);
\r
165 public <T> T sync(WriteInterface<T> r) throws DatabaseException {
\r
166 return graph.sync(r);
\r
170 public Resource getRootLibrary() {
\r
171 return graph.getRootLibrary();
\r
176 public void clearUndoList(WriteTraits writeTraits) {
\r
177 graph.clearUndoList(writeTraits);
\r
181 public void combineWithPrevious(WriteTraits writeTraits) {
\r
182 graph.combineWithPrevious(writeTraits);
\r
186 public TreeMap<String, byte[]> getMetadata() {
\r
187 return graph.getMetadata();
\r
191 public <T extends Metadata> T getMetadata(Class<T> clazz)
\r
192 throws ServiceException {
\r
193 return graph.getMetadata(clazz);
\r
197 public Type getRelatedValueType(Resource subject, Resource relation)
\r
198 throws DatabaseException {
\r
199 return graph.getRelatedValueType(subject, relation);
\r
203 public void deny(Resource subject, Resource predicate, Resource inverse,
\r
204 Resource object, VirtualGraph graph) throws ServiceException {
\r
205 this.graph.deny(subject, predicate, inverse, object, graph);
\r
212 public <T> T adaptRelated(Resource resource, Resource relation,
\r
213 Class<T> clazz) throws AdaptionException, NoSingleResultException,
\r
214 ValidationException, ServiceException {
\r
215 return graph.adaptRelated(resource, relation, clazz);
\r
219 public <T> T getPossibleRelatedAdapter(Resource resource,
\r
220 Resource relation, Class<T> clazz) throws ValidationException,
\r
222 return graph.getPossibleRelatedAdapter(resource, relation, clazz);
\r
226 public void inc() {
\r
231 public void dec() {
\r
236 public Collection<Resource> getObjects(Resource subject, Resource relation) throws ServiceException
\r
238 return graph.getObjects(subject, relation);
\r
242 public <T extends Accessor> T newLiteral(Resource resource,
\r
243 Resource predicate, Datatype datatype, Object initialValue)
\r
244 throws DatabaseException {
\r
245 return graph.newLiteral(resource, predicate, datatype, initialValue);
\r
249 public RandomAccessBinary createRandomAccessBinary(Resource resource,
\r
250 Resource predicate, Datatype datatype, Object initialValue)
\r
251 throws DatabaseException {
\r
252 return graph.createRandomAccessBinary(resource, predicate, datatype, initialValue);
\r
256 public RandomAccessBinary createRandomAccessBinary(Resource resource,
\r
257 Datatype datatype, Object initialValue) throws DatabaseException {
\r
258 return graph.createRandomAccessBinary(resource, datatype, initialValue);
\r
262 // public void claimFile(Resource resource, Object content, Binding binding)
\r
263 // throws DatabaseException {
\r
264 // graph.claimFile(resource, content, binding);
\r
268 // public void denyFile(Resource resource) throws DatabaseException {
\r
269 // graph.denyFile(resource);
\r
272 public <T, C> T adaptContextual(Resource resource, C context, java.lang.Class<C> contextClass, java.lang.Class<T> clazz) throws AdaptionException ,NoSingleResultException ,ValidationException ,ServiceException {
\r
273 return graph.adaptContextual(resource, context, contextClass, clazz);
\r
276 public <T, C> T getPossibleContextualAdapter(Resource resource, C context, java.lang.Class<C> contextClass, java.lang.Class<T> clazz) throws ValidationException ,ServiceException {
\r
277 return graph.getPossibleContextualAdapter(resource, context, contextClass, clazz);
\r
281 public WriteGraphProxy(WriteGraph graph) {
\r
282 this.graph = graph;
\r
286 public Resource newResource() throws ServiceException {
\r
287 return graph.newResource();
\r
291 public Resource newResource(long clusterId) throws ServiceException {
\r
292 return graph.newResource(clusterId);
\r
296 public <T> T adapt(Resource resource, Class<T> clazz)
\r
297 throws AdaptionException, ValidationException, ServiceException {
\r
298 return graph.adapt(resource, clazz);
\r
302 public <T> T adaptUnique(Resource resource, Class<T> clazz)
\r
303 throws AdaptionException, ValidationException, ServiceException {
\r
304 return adaptUnique(resource, clazz);
\r
308 public void addLiteral(Resource resource, Resource predicate,
\r
309 Resource inverse, Object value, Binding binding)
\r
310 throws BindingException,
\r
311 ManyObjectsForFunctionalRelationException, ServiceException {
\r
312 graph.addLiteral(resource, predicate, inverse, value, binding);
\r
316 public void addLiteral(Resource resource, Resource predicate,
\r
317 Resource inverse, Resource type, Object value, Binding binding)
\r
318 throws BindingException,
\r
319 ManyObjectsForFunctionalRelationException, ServiceException {
\r
320 graph.addLiteral(resource, predicate, inverse, type, value, binding);
\r
324 public <T> void addMetadata(Metadata data) throws ServiceException {
\r
325 graph.addMetadata(data);
\r
328 @SuppressWarnings("deprecation")
\r
330 public void addValue(Resource resource, Resource predicate,
\r
331 Resource inverse, Resource type, Object value, Binding binding)
\r
332 throws BindingException,
\r
333 ManyObjectsForFunctionalRelationException, ServiceException {
\r
334 graph.addValue(resource, predicate, inverse, type, value, binding);
\r
338 public <T> void asyncRequest(AsyncMultiRead<T> request) {
\r
339 graph.asyncRequest(request);
\r
343 public <T> void asyncRequest(AsyncMultiRead<T> request,
\r
344 AsyncMultiListener<T> procedure) {
\r
345 graph.asyncRequest(request,procedure);
\r
349 public <T> void asyncRequest(AsyncMultiRead<T> request,
\r
350 AsyncMultiProcedure<T> procedure) {
\r
351 graph.asyncRequest(request,procedure);
\r
355 public <T> void asyncRequest(AsyncMultiRead<T> request,
\r
356 MultiListener<T> procedure) {
\r
357 graph.asyncRequest(request,procedure);
\r
361 public <T> void asyncRequest(AsyncMultiRead<T> request,
\r
362 MultiProcedure<T> procedure) {
\r
363 graph.asyncRequest(request,procedure);
\r
367 public <T> void asyncRequest(AsyncMultiRead<T> request,
\r
368 SyncMultiListener<T> procedure) {
\r
369 graph.asyncRequest(request,procedure);
\r
373 public <T> void asyncRequest(AsyncMultiRead<T> request,
\r
374 SyncMultiProcedure<T> procedure) {
\r
375 graph.asyncRequest(request,procedure);
\r
379 public <T> void asyncRequest(AsyncRead<T> request) {
\r
380 graph.asyncRequest(request);
\r
384 public <T> void asyncRequest(AsyncRead<T> request,
\r
385 AsyncListener<T> procedure) {
\r
386 graph.asyncRequest(request,procedure);
\r
390 public <T> void asyncRequest(AsyncRead<T> request,
\r
391 AsyncProcedure<T> procedure) {
\r
392 graph.asyncRequest(request,procedure);
\r
396 public <T> void asyncRequest(AsyncRead<T> request, Listener<T> procedure) {
\r
397 graph.asyncRequest(request,procedure);
\r
401 public <T> void asyncRequest(AsyncRead<T> request,
\r
402 Procedure<T> procedure) {
\r
403 graph.asyncRequest(request,procedure);
\r
407 public <T> void asyncRequest(AsyncRead<T> request,
\r
408 SyncListener<T> procedure) {
\r
409 graph.asyncRequest(request,procedure);
\r
413 public <T> void asyncRequest(AsyncRead<T> request,
\r
414 SyncProcedure<T> procedure) {
\r
415 graph.asyncRequest(request,procedure);
\r
419 public void asyncRequest(DelayedWrite request) {
\r
420 graph.asyncRequest(request);
\r
424 public void asyncRequest(DelayedWrite request,
\r
425 Callback<DatabaseException> callback) {
\r
426 graph.asyncRequest(request,callback);
\r
430 public <T> void asyncRequest(DelayedWriteResult<T> r,
\r
431 Procedure<T> procedure) {
\r
432 graph.asyncRequest(r,procedure);
\r
436 public <T> void asyncRequest(ExternalRead<T> request) {
\r
437 graph.asyncRequest(request);
\r
441 public <T> void asyncRequest(ExternalRead<T> request,
\r
442 Listener<T> procedure) {
\r
443 graph.asyncRequest(request,procedure);
\r
447 public <T> void asyncRequest(ExternalRead<T> request,
\r
448 Procedure<T> procedure) {
\r
449 graph.asyncRequest(request,procedure);
\r
453 public <T> void asyncRequest(MultiRead<T> request) {
\r
454 graph.asyncRequest(request);
\r
458 public <T> void asyncRequest(MultiRead<T> request,
\r
459 AsyncMultiListener<T> procedure) {
\r
460 graph.asyncRequest(request,procedure);
\r
464 public <T> void asyncRequest(MultiRead<T> request,
\r
465 AsyncMultiProcedure<T> procedure) {
\r
466 graph.asyncRequest(request,procedure);
\r
470 public <T> void asyncRequest(MultiRead<T> request,
\r
471 MultiListener<T> procedure) {
\r
472 graph.asyncRequest(request,procedure);
\r
476 public <T> void asyncRequest(MultiRead<T> request,
\r
477 MultiProcedure<T> procedure) {
\r
478 graph.asyncRequest(request,procedure);
\r
482 public <T> void asyncRequest(MultiRead<T> request,
\r
483 SyncMultiListener<T> procedure) {
\r
484 graph.asyncRequest(request,procedure);
\r
488 public <T> void asyncRequest(MultiRead<T> request,
\r
489 SyncMultiProcedure<T> procedure) {
\r
490 graph.asyncRequest(request,procedure);
\r
494 public <T> void asyncRequest(Read<T> request) {
\r
495 graph.asyncRequest(request);
\r
499 public <T> void asyncRequest(Read<T> request, AsyncListener<T> procedure) {
\r
500 graph.asyncRequest(request,procedure);
\r
504 public <T> void asyncRequest(Read<T> request,
\r
505 AsyncProcedure<T> procedure) {
\r
506 graph.asyncRequest(request,procedure);
\r
510 public <T> void asyncRequest(Read<T> request, Listener<T> procedure) {
\r
511 graph.asyncRequest(request,procedure);
\r
515 public <T> void asyncRequest(Read<T> request, Procedure<T> procedure) {
\r
516 graph.asyncRequest(request,procedure);
\r
520 public <T> void asyncRequest(Read<T> request, SyncListener<T> procedure) {
\r
521 graph.asyncRequest(request,procedure);
\r
525 public <T> void asyncRequest(Read<T> request, SyncProcedure<T> procedure) {
\r
526 graph.asyncRequest(request,procedure);
\r
530 public void asyncRequest(Write request) {
\r
531 graph.asyncRequest(request);
\r
535 public void asyncRequest(Write request,
\r
536 Callback<DatabaseException> callback) {
\r
537 graph.asyncRequest(request, callback);
\r
541 public void asyncRequest(WriteOnly r) {
\r
542 graph.asyncRequest(r);
\r
546 public void asyncRequest(WriteOnly r,
\r
547 Callback<DatabaseException> callback) {
\r
548 graph.asyncRequest(r,callback);
\r
552 public <T> void asyncRequest(WriteOnlyResult<T> r,
\r
553 Procedure<T> procedure) {
\r
554 graph.asyncRequest(r,procedure);
\r
558 public <T> void asyncRequest(WriteResult<T> r, Procedure<T> procedure) {
\r
559 graph.asyncRequest(r,procedure);
\r
565 public void claim(Resource subject, Resource predicate,
\r
566 Resource inverse, Resource object) throws ServiceException {
\r
567 graph.claim(subject, predicate, inverse, object);
\r
571 public void claim(Resource subject, Resource predicate, Resource object)
\r
572 throws ServiceException {
\r
573 graph.claim(subject, predicate, object);
\r
578 public void claimLiteral(Resource resource, Resource predicate,
\r
579 Object value) throws ManyObjectsForFunctionalRelationException,
\r
581 graph.claimLiteral(resource, predicate, value);
\r
585 public void claimLiteral(Resource resource, Resource predicate,
\r
586 Object value, Binding binding) throws BindingException,
\r
587 ManyObjectsForFunctionalRelationException, ServiceException {
\r
588 graph.claimLiteral(resource, predicate, value, binding);
\r
592 public void claimLiteral(Resource resource, Resource predicate,
\r
593 Resource inverse, Resource type, Object value)
\r
594 throws BindingException,
\r
595 ManyObjectsForFunctionalRelationException, ServiceException {
\r
596 graph.claimLiteral(resource, predicate, inverse, type, value);
\r
600 public void claimLiteral(Resource resource, Resource predicate,
\r
601 Resource inverse, Resource type, Object value, Binding binding)
\r
602 throws BindingException,
\r
603 ManyObjectsForFunctionalRelationException, ServiceException {
\r
604 graph.claimLiteral(resource, predicate, inverse, type, value, binding);
\r
608 public void claimLiteral(Resource resource, Resource predicate,
\r
609 Resource type, Object value) throws BindingException,
\r
610 ManyObjectsForFunctionalRelationException, ServiceException {
\r
611 graph.claimLiteral(resource, predicate, type, value);
\r
615 public void claimLiteral(Resource resource, Resource predicate,
\r
616 Resource type, Object value, Binding binding)
\r
617 throws BindingException,
\r
618 ManyObjectsForFunctionalRelationException, ServiceException {
\r
619 graph.claimLiteral(resource, predicate, type, value, binding);
\r
623 public void claimValue(Resource resource, Object value)
\r
624 throws ServiceException {
\r
625 graph.claimValue(resource, value);
\r
629 public void claimValue(Resource resource, Object value, Binding binding)
\r
630 throws ServiceException {
\r
631 graph.claimValue(resource, value, binding);
\r
634 @SuppressWarnings("deprecation")
\r
636 public void claimValue(Resource resource, Resource predicate,
\r
637 Object value) throws ManyObjectsForFunctionalRelationException,
\r
639 graph.claimValue(resource, predicate, value);
\r
642 @SuppressWarnings("deprecation")
\r
644 public void claimValue(Resource resource, Resource predicate,
\r
645 Object value, Binding binding) throws BindingException,
\r
646 ManyObjectsForFunctionalRelationException, ServiceException {
\r
647 graph.claimValue(resource, predicate, value, binding);
\r
650 @SuppressWarnings("deprecation")
\r
652 public void claimValue(Resource resource, Resource predicate,
\r
653 Resource inverse, Resource type, Object value, Binding binding)
\r
654 throws BindingException,
\r
655 ManyObjectsForFunctionalRelationException, ServiceException {
\r
656 graph.claimValue(resource, predicate, inverse, type, value, binding);
\r
660 public void deny(Resource subject) throws ServiceException {
\r
661 graph.deny(subject);
\r
665 public void deny(Resource subject, Resource predicate)
\r
666 throws ServiceException {
\r
667 graph.deny(subject, predicate);
\r
671 public void deny(Resource subject, Resource predicate,
\r
672 Resource inverse, Resource object) throws ServiceException {
\r
673 graph.deny(subject, predicate, inverse, object);
\r
677 public void deny(Resource subject, Resource predicate, Resource object)
\r
678 throws ServiceException {
\r
679 graph.deny(subject, predicate, object);
\r
683 public void deny(Statement statement) throws ServiceException {
\r
684 graph.deny(statement);
\r
689 public void denyStatement(Resource subject, Resource predicate,
\r
690 Resource object) throws ServiceException {
\r
691 graph.denyStatement(subject, predicate, object);
\r
695 public void denyValue(Resource resource) throws ServiceException {
\r
696 graph.denyValue(resource);
\r
700 public void denyValue(Resource resource, Resource predicate)
\r
701 throws ManyObjectsForFunctionalRelationException,
\r
703 graph.denyValue(resource, predicate);
\r
707 public void flushCluster() throws ServiceException {
\r
708 graph.flushCluster();
\r
712 public void flushCluster(Resource r) throws ServiceException {
\r
713 graph.flushCluster(r);
\r
717 public <T> void forAdapted(Resource resource, Class<T> clazz,
\r
718 AsyncListener<T> procedure) {
\r
719 graph.forAdapted(resource, clazz, procedure);
\r
723 public <T> void forAdapted(Resource resource, Class<T> clazz,
\r
724 AsyncProcedure<T> procedure) {
\r
725 graph.forAdapted(resource, clazz, procedure);
\r
729 public <T> void forAdapted(Resource resource, Class<T> clazz,
\r
730 Listener<T> procedure) {
\r
731 graph.forAdapted(resource, clazz, procedure);
\r
735 public <T> void forAdapted(Resource resource, Class<T> clazz,
\r
736 Procedure<T> procedure) {
\r
737 graph.forAdapted(resource, clazz, procedure);
\r
741 public <T> void forAdapted(Resource resource, Class<T> clazz,
\r
742 SyncListener<T> procedure) {
\r
743 graph.forAdapted(resource, clazz, procedure);
\r
747 public <T> void forAdapted(Resource resource, Class<T> clazz,
\r
748 SyncProcedure<T> procedure) {
\r
749 graph.forAdapted(resource, clazz, procedure);
\r
753 public void forAssertedObjectSet(Resource subject, Resource relation,
\r
754 AsyncSetListener<Resource> procedure) {
\r
755 graph.forAssertedObjectSet(subject, relation, procedure);
\r
759 public void forAssertedObjectSet(Resource subject, Resource relation,
\r
760 SetListener<Resource> procedure) {
\r
761 graph.forAssertedObjectSet(subject, relation, procedure);
\r
765 public void forAssertedObjectSet(Resource subject, Resource relation,
\r
766 SyncSetListener<Resource> procedure) {
\r
767 graph.forAssertedObjectSet(subject, relation, procedure);
\r
771 public void forAssertedStatementSet(Resource subject,
\r
772 Resource relation, AsyncSetListener<Statement> procedure) {
\r
773 graph.forAssertedStatementSet(subject, relation, procedure);
\r
777 public void forAssertedStatementSet(Resource subject,
\r
778 Resource relation, SetListener<Statement> procedure) {
\r
779 graph.forAssertedStatementSet(subject, relation, procedure);
\r
783 public void forAssertedStatementSet(Resource subject,
\r
784 Resource relation, SyncSetListener<Statement> procedure) {
\r
785 graph.forAssertedStatementSet(subject, relation, procedure);
\r
789 public void forBuiltin(String id, AsyncListener<Resource> procedure) {
\r
790 graph.forBuiltin(id, procedure);
\r
794 public void forBuiltin(String id, Listener<Resource> procedure) {
\r
795 graph.forBuiltin(id, procedure);
\r
799 public void forBuiltin(String id, AsyncProcedure<Resource> procedure) {
\r
800 graph.forBuiltin(id, procedure);
\r
804 public void forBuiltin(String id, Procedure<Resource> procedure) {
\r
805 graph.forBuiltin(id, procedure);
\r
809 public void forBuiltin(String id, SyncListener<Resource> procedure) {
\r
810 graph.forBuiltin(id, procedure);
\r
814 public void forBuiltin(String id, SyncProcedure<Resource> procedure) {
\r
815 graph.forBuiltin(id, procedure);
\r
819 public void forDirectSuperrelations(Resource subject,
\r
820 AsyncMultiProcedure<Resource> procedure) {
\r
821 graph.forDirectSuperrelations(subject, procedure);
\r
825 public void forEachAssertedObject(Resource subject, Resource relation,
\r
826 AsyncMultiProcedure<Resource> procedure) {
\r
827 graph.forEachAssertedObject(subject, relation, procedure);
\r
831 public void forEachAssertedObject(Resource subject, Resource relation,
\r
832 MultiProcedure<Resource> procedure) {
\r
833 graph.forEachAssertedObject(subject, relation, procedure);
\r
837 public void forEachAssertedObject(Resource subject, Resource relation,
\r
838 SyncMultiProcedure<Resource> procedure) {
\r
839 graph.forEachAssertedObject(subject, relation, procedure);
\r
843 public void forEachAssertedStatement(Resource subject,
\r
844 Resource relation, AsyncMultiProcedure<Statement> procedure) {
\r
845 graph.forEachAssertedStatement(subject, relation, procedure);
\r
849 public void forEachAssertedStatement(Resource subject,
\r
850 Resource relation, MultiProcedure<Statement> procedure) {
\r
851 graph.forEachAssertedStatement(subject, relation, procedure);
\r
855 public void forEachAssertedStatement(Resource subject,
\r
856 Resource relation, SyncMultiProcedure<Statement> procedure) {
\r
857 graph.forEachAssertedStatement(subject, relation, procedure);
\r
861 // public void forEachDirectObject(Resource subject, Resource relation,
\r
862 // AsyncMultiProcedure<Resource> procedure) {
\r
863 // graph.forEachDirectObject(subject, relation, procedure);
\r
867 // public void forEachDirectObject(Resource subject, Resource relation,
\r
868 // MultiProcedure<Resource> procedure) {
\r
869 // graph.forEachDirectObject(subject, relation, procedure);
\r
873 // public void forEachDirectObject(Resource subject, Resource relation,
\r
874 // SyncMultiProcedure<Resource> procedure) {
\r
875 // graph.forEachDirectObject(subject, relation, procedure);
\r
879 public void forEachDirectPredicate(Resource subject,
\r
880 AsyncMultiProcedure<Resource> procedure) {
\r
881 graph.forEachDirectPredicate(subject, procedure);
\r
885 public void forEachDirectPredicate(Resource subject,
\r
886 MultiProcedure<Resource> procedure) {
\r
887 graph.forEachDirectPredicate(subject, procedure);
\r
891 public void forEachDirectPredicate(Resource subject,
\r
892 SyncMultiProcedure<Resource> procedure) {
\r
893 graph.forEachDirectPredicate(subject, procedure);
\r
897 public void forEachObject(Resource subject, Resource relation,
\r
898 AsyncMultiProcedure<Resource> procedure) {
\r
899 graph.forEachObject(subject, relation, procedure);
\r
903 public void forEachObject(Resource subject, Resource relation,
\r
904 MultiProcedure<Resource> procedure) {
\r
905 graph.forEachObject(subject, relation, procedure);
\r
909 public void forEachObject(Resource subject, Resource relation,
\r
910 SyncMultiProcedure<Resource> procedure) {
\r
911 graph.forEachObject(subject, relation, procedure);
\r
915 public void forEachPredicate(Resource subject,
\r
916 AsyncMultiProcedure<Resource> procedure) {
\r
917 graph.forEachPredicate(subject, procedure);
\r
921 public void forEachPredicate(Resource subject,
\r
922 MultiProcedure<Resource> procedure) {
\r
923 graph.forEachPredicate(subject, procedure);
\r
927 public void forEachPredicate(Resource subject,
\r
928 SyncMultiProcedure<Resource> procedure) {
\r
929 graph.forEachPredicate(subject, procedure);
\r
933 public void forEachPrincipalType(Resource subject,
\r
934 AsyncMultiProcedure<Resource> procedure) {
\r
935 graph.forEachPrincipalType(subject, procedure);
\r
939 public void forEachPrincipalType(Resource subject,
\r
940 MultiProcedure<Resource> procedure) {
\r
941 graph.forEachPrincipalType(subject, procedure);
\r
945 public void forEachPrincipalType(Resource subject,
\r
946 SyncMultiProcedure<Resource> procedure) {
\r
947 graph.forEachPrincipalType(subject, procedure);
\r
951 public void forEachStatement(Resource subject, Resource relation,
\r
952 AsyncMultiProcedure<Statement> procedure) {
\r
953 graph.forEachStatement(subject, relation, procedure);
\r
957 public void forEachStatement(Resource subject, Resource relation,
\r
958 MultiProcedure<Statement> procedure) {
\r
959 graph.forEachStatement(subject, relation, procedure);
\r
963 public void forEachStatement(Resource subject, Resource relation,
\r
964 SyncMultiProcedure<Statement> procedure) {
\r
965 graph.forEachStatement(subject, relation, procedure);
\r
969 public void forHasStatement(Resource subject,
\r
970 AsyncListener<Boolean> procedure) {
\r
971 graph.forHasStatement(subject, procedure);
\r
975 public void forHasStatement(Resource subject,
\r
976 AsyncProcedure<Boolean> procedure) {
\r
977 graph.forHasStatement(subject, procedure);
\r
981 public void forHasStatement(Resource subject,
\r
982 Listener<Boolean> procedure) {
\r
983 graph.forHasStatement(subject, procedure);
\r
987 public void forHasStatement(Resource subject,
\r
988 Procedure<Boolean> procedure) {
\r
989 graph.forHasStatement(subject, procedure);
\r
993 public void forHasStatement(Resource subject, Resource relation,
\r
994 AsyncListener<Boolean> procedure) {
\r
995 graph.forHasStatement(subject, relation, procedure);
\r
999 public void forHasStatement(Resource subject, Resource relation,
\r
1000 AsyncProcedure<Boolean> procedure) {
\r
1001 graph.forHasStatement(subject, relation, procedure);
\r
1005 public void forHasStatement(Resource subject, Resource relation,
\r
1006 Listener<Boolean> procedure) {
\r
1007 graph.forHasStatement(subject, relation, procedure);
\r
1011 public void forHasStatement(Resource subject, Resource relation,
\r
1012 Procedure<Boolean> procedure) {
\r
1013 graph.forHasStatement(subject, relation, procedure);
\r
1017 public void forHasStatement(Resource subject, Resource relation,
\r
1018 Resource object, AsyncListener<Boolean> procedure) {
\r
1019 graph.forHasStatement(subject, relation, object, procedure);
\r
1023 public void forHasStatement(Resource subject, Resource relation,
\r
1024 Resource object, AsyncProcedure<Boolean> procedure) {
\r
1025 graph.forHasStatement(subject, relation, object, procedure);
\r
1029 public void forHasStatement(Resource subject, Resource relation,
\r
1030 Resource object, Listener<Boolean> procedure) {
\r
1031 graph.forHasStatement(subject, relation, object, procedure);
\r
1035 public void forHasStatement(Resource subject, Resource relation,
\r
1036 Resource object, Procedure<Boolean> procedure) {
\r
1037 graph.forHasStatement(subject, relation, object, procedure);
\r
1041 public void forHasStatement(Resource subject, Resource relation,
\r
1042 Resource object, SyncListener<Boolean> procedure) {
\r
1043 graph.forHasStatement(subject, relation, object, procedure);
\r
1047 public void forHasStatement(Resource subject, Resource relation,
\r
1048 Resource object, SyncProcedure<Boolean> procedure) {
\r
1049 graph.forHasStatement(subject, relation, object, procedure);
\r
1053 public void forHasStatement(Resource subject, Resource relation,
\r
1054 SyncListener<Boolean> procedure) {
\r
1055 graph.forHasStatement(subject, relation, procedure);
\r
1059 public void forHasStatement(Resource subject, Resource relation,
\r
1060 SyncProcedure<Boolean> procedure) {
\r
1061 graph.forHasStatement(subject, relation, procedure);
\r
1065 public void forHasStatement(Resource subject,
\r
1066 SyncListener<Boolean> procedure) {
\r
1067 graph.forHasStatement(subject, procedure);
\r
1071 public void forHasStatement(Resource subject,
\r
1072 SyncProcedure<Boolean> procedure) {
\r
1073 graph.forHasStatement(subject, procedure);
\r
1077 public void forHasValue(Resource subject,
\r
1078 AsyncListener<Boolean> procedure) {
\r
1079 graph.forHasValue(subject, procedure);
\r
1083 public void forHasValue(Resource subject,
\r
1084 AsyncProcedure<Boolean> procedure) {
\r
1085 graph.forHasValue(subject, procedure);
\r
1089 public void forHasValue(Resource subject, Listener<Boolean> procedure) {
\r
1090 graph.forHasValue(subject, procedure);
\r
1094 public void forHasValue(Resource subject, Procedure<Boolean> procedure) {
\r
1095 graph.forHasValue(subject, procedure);
\r
1099 public void forHasValue(Resource subject,
\r
1100 SyncListener<Boolean> procedure) {
\r
1101 graph.forHasValue(subject, procedure);
\r
1105 public void forHasValue(Resource subject,
\r
1106 SyncProcedure<Boolean> procedure) {
\r
1107 graph.forHasValue(subject, procedure);
\r
1111 public void forInverse(Resource relation,
\r
1112 AsyncListener<Resource> procedure) {
\r
1113 graph.forInverse(relation, procedure);
\r
1117 public <T> T getService(Class<T> api) throws ServiceNotFoundException {
\r
1118 return graph.getService(api);
\r
1122 public <T> T peekService(Class<T> api) {
\r
1123 return graph.peekService(api);
\r
1127 public boolean hasService(Class<?> api) {
\r
1128 return graph.hasService(api);
\r
1132 public <T> void registerService(Class<T> api, T service) {
\r
1133 graph.registerService(api, service);
\r
1137 public String getURI(Resource resource)
\r
1138 throws ValidationException,
\r
1139 ServiceException, AssumptionException {
\r
1140 return graph.getURI(resource);
\r
1144 public String getPossibleURI(Resource resource)
\r
1145 throws ValidationException,
\r
1146 ServiceException {
\r
1147 return graph.getPossibleURI(resource);
\r
1151 public Resource getResource(String uri)
\r
1152 throws ResourceNotFoundException, ValidationException,
\r
1153 ServiceException {
\r
1154 return graph.getResource(uri);
\r
1158 public Resource getPossibleResource(String uri)
\r
1159 throws ResourceNotFoundException, ValidationException,
\r
1160 ServiceException {
\r
1161 return graph.getPossibleResource(uri);
\r
1165 public Collection<Statement> getStatements(Resource subject,
\r
1166 Resource relation)
\r
1167 throws ManyObjectsForFunctionalRelationException,
\r
1168 ServiceException {
\r
1169 return graph.getStatements(subject, relation);
\r
1173 public Collection<Statement> getAssertedStatements(Resource subject,
\r
1174 Resource relation)
\r
1175 throws ManyObjectsForFunctionalRelationException,
\r
1176 ServiceException {
\r
1177 return graph.getAssertedStatements(subject, relation);
\r
1181 public Collection<Resource> getPredicates(Resource subject)
\r
1182 throws ServiceException {
\r
1183 return graph.getPredicates(subject);
\r
1187 public Collection<Resource> getPrincipalTypes(Resource subject)
\r
1188 throws ServiceException {
\r
1189 return graph.getPrincipalTypes(subject);
\r
1193 public Set<Resource> getTypes(Resource subject) throws ServiceException {
\r
1194 return graph.getTypes(subject);
\r
1198 public Set<Resource> getSupertypes(Resource subject)
\r
1199 throws ServiceException {
\r
1200 return graph.getSupertypes(subject);
\r
1204 public Set<Resource> getSuperrelations(Resource subject)
\r
1205 throws ServiceException {
\r
1206 return graph.getSuperrelations(subject);
\r
1210 public Resource getPossibleSuperrelation(Resource subject)
\r
1211 throws ServiceException {
\r
1212 return graph.getPossibleSuperrelation(subject);
\r
1216 // public Collection<Resource> getObjects(Resource subject,
\r
1217 // Resource relation)
\r
1218 // throws ManyObjectsForFunctionalRelationException,
\r
1219 // ServiceException {
\r
1220 // return graph.getObjects(subject, relation);
\r
1224 public Collection<Resource> getAssertedObjects(Resource subject,
\r
1225 Resource relation)
\r
1226 throws ManyObjectsForFunctionalRelationException,
\r
1227 ServiceException {
\r
1228 return graph.getAssertedObjects(subject, relation);
\r
1232 public Resource getInverse(Resource relation)
\r
1233 throws NoInverseException,
\r
1234 ManyObjectsForFunctionalRelationException, ServiceException {
\r
1235 return graph.getInverse(relation);
\r
1239 public Resource getSingleObject(Resource subject, Resource relation)
\r
1240 throws NoSingleResultException,
\r
1241 ManyObjectsForFunctionalRelationException, ServiceException {
\r
1242 return graph.getSingleObject(subject, relation);
\r
1246 public Statement getSingleStatement(Resource subject, Resource relation)
\r
1247 throws NoSingleResultException,
\r
1248 ManyObjectsForFunctionalRelationException, ServiceException {
\r
1249 return graph.getSingleStatement(subject, relation);
\r
1253 public Resource getSingleType(Resource subject)
\r
1254 throws NoSingleResultException, ServiceException {
\r
1255 return graph.getSingleType(subject);
\r
1259 public Resource getSingleType(Resource subject, Resource baseType)
\r
1260 throws NoSingleResultException, ServiceException {
\r
1261 return graph.getSingleType(subject, baseType);
\r
1265 public <T> T getValue(Resource subject)
\r
1266 throws DoesNotContainValueException, ServiceException {
\r
1267 return graph.getValue(subject);
\r
1271 public <T> T getValue(Resource subject, Binding binding)
\r
1272 throws DoesNotContainValueException, BindingException,
\r
1273 ServiceException {
\r
1274 return graph.getValue(subject, binding);
\r
1278 public <T> T getRelatedValue(Resource subject, Resource relation)
\r
1279 throws NoSingleResultException, DoesNotContainValueException,
\r
1280 ServiceException {
\r
1281 return graph.getRelatedValue(subject, relation);
\r
1285 public <T> T getRelatedValue(Resource subject, Resource relation,
\r
1286 Binding binding) throws NoSingleResultException,
\r
1287 DoesNotContainValueException, BindingException,
\r
1288 ServiceException {
\r
1289 return graph.getRelatedValue(subject, relation, binding);
\r
1293 public Resource getPossibleInverse(Resource relation)
\r
1294 throws ManyObjectsForFunctionalRelationException,
\r
1295 ServiceException {
\r
1296 return graph.getPossibleInverse(relation);
\r
1300 public Resource getPossibleObject(Resource subject, Resource relation)
\r
1301 throws ManyObjectsForFunctionalRelationException,
\r
1302 ServiceException {
\r
1303 return graph.getPossibleObject(subject, relation);
\r
1307 public Statement getPossibleStatement(Resource subject,
\r
1308 Resource relation)
\r
1309 throws ManyObjectsForFunctionalRelationException,
\r
1310 ServiceException {
\r
1311 return graph.getPossibleStatement(subject, relation);
\r
1315 public Resource getPossibleType(Resource subject, Resource baseType)
\r
1316 throws ServiceException {
\r
1317 return graph.getPossibleType(subject, baseType);
\r
1321 public <T> T getPossibleValue(Resource subject) throws ServiceException {
\r
1322 return graph.getPossibleValue(subject);
\r
1326 public <T> T getPossibleValue(Resource subject, Binding binding)
\r
1327 throws BindingException, ServiceException {
\r
1328 return graph.getPossibleValue(subject, binding);
\r
1332 public <T> T getPossibleRelatedValue(Resource subject, Resource relation)
\r
1333 throws ManyObjectsForFunctionalRelationException,
\r
1334 ServiceException {
\r
1335 return graph.getPossibleRelatedValue(subject, relation);
\r
1339 public <T> T getPossibleRelatedValue(Resource subject,
\r
1340 Resource relation, Binding binding)
\r
1341 throws ManyObjectsForFunctionalRelationException,
\r
1342 BindingException, ServiceException {
\r
1343 return graph.getPossibleRelatedValue(subject, relation, binding);
\r
1347 public <T> T getPossibleAdapter(Resource resource, Class<T> clazz)
\r
1348 throws ValidationException, ServiceException {
\r
1349 return graph.getPossibleAdapter(resource, clazz);
\r
1353 public <T> T getPossibleUniqueAdapter(Resource resource, Class<T> clazz)
\r
1354 throws ValidationException, ServiceException {
\r
1355 return graph.getPossibleUniqueAdapter(resource, clazz);
\r
1359 public boolean isInstanceOf(Resource resource, Resource type)
\r
1360 throws ServiceException {
\r
1361 return graph.isInstanceOf(resource, type);
\r
1365 public boolean isInheritedFrom(Resource resource, Resource type)
\r
1366 throws ServiceException {
\r
1367 return graph.isInheritedFrom(resource, type);
\r
1371 public boolean isSubrelationOf(Resource resource, Resource relation)
\r
1372 throws ServiceException {
\r
1373 return graph.isSubrelationOf(resource, relation);
\r
1377 public boolean hasStatement(Resource subject) throws ServiceException {
\r
1378 return graph.hasStatement(subject);
\r
1382 public boolean hasStatement(Resource subject, Resource relation)
\r
1383 throws ServiceException {
\r
1384 return graph.hasStatement(subject, relation);
\r
1388 public boolean hasStatement(Resource subject, Resource relation,
\r
1389 Resource object) throws ServiceException {
\r
1390 return graph.hasStatement(subject, relation, object);
\r
1394 public boolean hasValue(Resource subject) throws ServiceException {
\r
1395 return graph.hasValue(subject);
\r
1399 public Datatype getDataType(Resource subject) throws DatabaseException {
\r
1400 return graph.getDataType(subject);
\r
1404 public <T extends Accessor> T getAccessor(Resource subject)
\r
1405 throws DatabaseException {
\r
1406 return graph.getAccessor(subject);
\r
1410 public RandomAccessBinary getRandomAccessBinary(Resource subject)
\r
1411 throws DatabaseException {
\r
1412 return graph.getRandomAccessBinary(subject);
\r
1416 public <T> T syncRequest(Read<T> request) throws DatabaseException {
\r
1417 return graph.syncRequest(request);
\r
1421 public <T> T syncRequest(Read<T> request, AsyncListener<T> procedure)
\r
1422 throws DatabaseException {
\r
1423 return graph.syncRequest(request, procedure);
\r
1427 public <T> T syncRequest(Read<T> request, SyncListener<T> procedure)
\r
1428 throws DatabaseException {
\r
1429 return graph.syncRequest(request, procedure);
\r
1433 public <T> T syncRequest(Read<T> request, Listener<T> procedure)
\r
1434 throws DatabaseException {
\r
1435 return graph.syncRequest(request, procedure);
\r
1439 public <T> T syncRequest(Read<T> request, AsyncProcedure<T> procedure)
\r
1440 throws DatabaseException {
\r
1441 return graph.syncRequest(request, procedure);
\r
1445 public <T> T syncRequest(Read<T> request, SyncProcedure<T> procedure)
\r
1446 throws DatabaseException {
\r
1447 return graph.syncRequest(request, procedure);
\r
1451 public <T> T syncRequest(Read<T> request, Procedure<T> procedure)
\r
1452 throws DatabaseException {
\r
1453 return graph.syncRequest(request, procedure);
\r
1457 public <T> T syncRequest(AsyncRead<T> request) throws DatabaseException {
\r
1458 return graph.syncRequest(request);
\r
1462 public <T> T syncRequest(AsyncRead<T> request,
\r
1463 AsyncListener<T> procedure) throws DatabaseException {
\r
1464 return graph.syncRequest(request, procedure);
\r
1468 public <T> T syncRequest(AsyncRead<T> request, SyncListener<T> procedure)
\r
1469 throws DatabaseException {
\r
1470 return graph.syncRequest(request, procedure);
\r
1474 public <T> T syncRequest(AsyncRead<T> request, Listener<T> procedure)
\r
1475 throws DatabaseException {
\r
1476 return graph.syncRequest(request, procedure);
\r
1480 public <T> T syncRequest(AsyncRead<T> request,
\r
1481 AsyncProcedure<T> procedure) throws DatabaseException {
\r
1482 return graph.syncRequest(request, procedure);
\r
1486 public <T> T syncRequest(AsyncRead<T> request,
\r
1487 SyncProcedure<T> procedure) throws DatabaseException {
\r
1488 return graph.syncRequest(request, procedure);
\r
1492 public <T> T syncRequest(AsyncRead<T> request, Procedure<T> procedure)
\r
1493 throws DatabaseException {
\r
1494 return graph.syncRequest(request, procedure);
\r
1498 public <T> Collection<T> syncRequest(MultiRead<T> request)
\r
1499 throws DatabaseException {
\r
1500 return graph.syncRequest(request);
\r
1504 public <T> Collection<T> syncRequest(MultiRead<T> request,
\r
1505 AsyncMultiListener<T> procedure) throws DatabaseException {
\r
1506 return graph.syncRequest(request, procedure);
\r
1510 public <T> Collection<T> syncRequest(MultiRead<T> request,
\r
1511 SyncMultiListener<T> procedure) throws DatabaseException {
\r
1512 return graph.syncRequest(request, procedure);
\r
1516 public <T> Collection<T> syncRequest(MultiRead<T> request,
\r
1517 MultiListener<T> procedure) throws DatabaseException {
\r
1518 return graph.syncRequest(request, procedure);
\r
1522 public <T> Collection<T> syncRequest(MultiRead<T> request,
\r
1523 AsyncMultiProcedure<T> procedure) throws DatabaseException {
\r
1524 return graph.syncRequest(request, procedure);
\r
1528 public <T> Collection<T> syncRequest(MultiRead<T> request,
\r
1529 SyncMultiProcedure<T> procedure) throws DatabaseException {
\r
1530 return graph.syncRequest(request, procedure);
\r
1534 public <T> Collection<T> syncRequest(MultiRead<T> request,
\r
1535 MultiProcedure<T> procedure) throws DatabaseException {
\r
1536 return graph.syncRequest(request, procedure);
\r
1540 public <T> Collection<T> syncRequest(AsyncMultiRead<T> request)
\r
1541 throws DatabaseException {
\r
1542 return graph.syncRequest(request);
\r
1546 public <T> Collection<T> syncRequest(AsyncMultiRead<T> request,
\r
1547 AsyncMultiListener<T> procedure) throws DatabaseException {
\r
1548 return graph.syncRequest(request, procedure);
\r
1552 public <T> Collection<T> syncRequest(AsyncMultiRead<T> request,
\r
1553 SyncMultiListener<T> procedure) throws DatabaseException {
\r
1554 return graph.syncRequest(request, procedure);
\r
1558 public <T> Collection<T> syncRequest(AsyncMultiRead<T> request,
\r
1559 MultiListener<T> procedure) throws DatabaseException {
\r
1560 return graph.syncRequest(request, procedure);
\r
1564 public <T> Collection<T> syncRequest(AsyncMultiRead<T> request,
\r
1565 AsyncMultiProcedure<T> procedure) throws DatabaseException {
\r
1566 return graph.syncRequest(request, procedure);
\r
1570 public <T> Collection<T> syncRequest(AsyncMultiRead<T> request,
\r
1571 SyncMultiProcedure<T> procedure) throws DatabaseException {
\r
1572 return graph.syncRequest(request, procedure);
\r
1576 public <T> Collection<T> syncRequest(AsyncMultiRead<T> request,
\r
1577 MultiProcedure<T> procedure) throws DatabaseException {
\r
1578 return graph.syncRequest(request, procedure);
\r
1582 public <T> T syncRequest(ExternalRead<T> request)
\r
1583 throws DatabaseException {
\r
1584 return graph.syncRequest(request);
\r
1588 public <T> T syncRequest(ExternalRead<T> request, Listener<T> procedure)
\r
1589 throws DatabaseException {
\r
1590 return graph.syncRequest(request, procedure);
\r
1594 public <T> T syncRequest(ExternalRead<T> request, Procedure<T> procedure)
\r
1595 throws DatabaseException {
\r
1596 return graph.syncRequest(request, procedure);
\r
1600 public void syncRequest(Write request) throws DatabaseException {
\r
1601 graph.syncRequest(request);
\r
1605 public void syncRequest(DelayedWrite request) throws DatabaseException {
\r
1606 graph.syncRequest(request);
\r
1610 public void syncRequest(WriteOnly r) throws DatabaseException {
\r
1611 graph.syncRequest(r);
\r
1615 public <T> T syncRequest(WriteResult<T> request)
\r
1616 throws DatabaseException {
\r
1617 return graph.syncRequest(request);
\r
1621 public <T> T syncRequest(DelayedWriteResult<T> request)
\r
1622 throws DatabaseException {
\r
1623 return graph.syncRequest(request);
\r
1627 public <T> T syncRequest(WriteOnlyResult<T> r) throws DatabaseException {
\r
1628 return graph.syncRequest(r);
\r
1632 public void forURI(Resource resource, AsyncListener<String> procedure) {
\r
1633 graph.forURI(resource, procedure);
\r
1637 public void forURI(Resource resource, SyncListener<String> procedure) {
\r
1638 graph.forURI(resource, procedure);
\r
1642 public void forURI(Resource resource, Listener<String> procedure) {
\r
1643 graph.forURI(resource, procedure);
\r
1647 public void forURI(Resource resource, AsyncProcedure<String> procedure) {
\r
1648 graph.forURI(resource, procedure);
\r
1652 public void forURI(Resource resource, SyncProcedure<String> procedure) {
\r
1653 graph.forURI(resource, procedure);
\r
1657 public void forURI(Resource resource, Procedure<String> procedure) {
\r
1658 graph.forURI(resource, procedure);
\r
1662 public void forResource(String id, AsyncListener<Resource> procedure) {
\r
1663 graph.forResource(id, procedure);
\r
1667 public void forResource(String id, SyncListener<Resource> procedure) {
\r
1668 graph.forResource(id, procedure);
\r
1672 public void forResource(String id, Listener<Resource> procedure) {
\r
1673 graph.forResource(id, procedure);
\r
1677 public void forResource(String id, AsyncProcedure<Resource> procedure) {
\r
1678 graph.forResource(id, procedure);
\r
1682 public void forResource(String id, SyncProcedure<Resource> procedure) {
\r
1683 graph.forResource(id, procedure);
\r
1687 public void forResource(String id, Procedure<Resource> procedure) {
\r
1688 graph.forResource(id, procedure);
\r
1692 public void forStatementSet(Resource subject, Resource relation,
\r
1693 AsyncSetListener<Statement> procedure) {
\r
1694 graph.forStatementSet(subject, relation, procedure);
\r
1698 public void forStatementSet(Resource subject, Resource relation,
\r
1699 SyncSetListener<Statement> procedure) {
\r
1700 graph.forStatementSet(subject, relation, procedure);
\r
1704 public void forStatementSet(Resource subject, Resource relation,
\r
1705 SetListener<Statement> procedure) {
\r
1706 graph.forStatementSet(subject, relation, procedure);
\r
1710 public void forPredicateSet(Resource subject,
\r
1711 AsyncSetListener<Resource> procedure) {
\r
1712 graph.forPredicateSet(subject, procedure);
\r
1716 public void forPredicateSet(Resource subject,
\r
1717 SyncSetListener<Resource> procedure) {
\r
1718 graph.forPredicateSet(subject, procedure);
\r
1722 public void forPredicateSet(Resource subject,
\r
1723 SetListener<Resource> procedure) {
\r
1724 graph.forPredicateSet(subject, procedure);
\r
1728 public void forPrincipalTypeSet(Resource subject,
\r
1729 AsyncSetListener<Resource> procedure) {
\r
1730 graph.forPrincipalTypeSet(subject, procedure);
\r
1734 public void forPrincipalTypeSet(Resource subject,
\r
1735 SyncSetListener<Resource> procedure) {
\r
1736 graph.forPrincipalTypeSet(subject, procedure);
\r
1740 public void forPrincipalTypeSet(Resource subject,
\r
1741 SetListener<Resource> procedure) {
\r
1742 graph.forPrincipalTypeSet(subject, procedure);
\r
1746 public void forTypes(Resource subject,
\r
1747 AsyncListener<Set<Resource>> procedure) {
\r
1748 graph.forTypes(subject, procedure);
\r
1752 public void forTypes(Resource subject,
\r
1753 SyncListener<Set<Resource>> procedure) {
\r
1754 graph.forTypes(subject, procedure);
\r
1758 public void forTypes(Resource subject, Listener<Set<Resource>> procedure) {
\r
1759 graph.forTypes(subject, procedure);
\r
1763 public void forTypes(Resource subject,
\r
1764 AsyncProcedure<Set<Resource>> procedure) {
\r
1765 graph.forTypes(subject, procedure);
\r
1769 public void forTypes(Resource subject,
\r
1770 SyncProcedure<Set<Resource>> procedure) {
\r
1771 graph.forTypes(subject, procedure);
\r
1775 public void forTypes(Resource subject,
\r
1776 Procedure<Set<Resource>> procedure) {
\r
1777 graph.forTypes(subject, procedure);
\r
1781 public void forSupertypes(Resource subject,
\r
1782 AsyncListener<Set<Resource>> procedure) {
\r
1783 graph.forSupertypes(subject, procedure);
\r
1787 public void forSupertypes(Resource subject,
\r
1788 SyncListener<Set<Resource>> procedure) {
\r
1789 graph.forSupertypes(subject, procedure);
\r
1793 public void forSupertypes(Resource subject,
\r
1794 Listener<Set<Resource>> procedure) {
\r
1795 graph.forSupertypes(subject, procedure);
\r
1799 public void forSupertypes(Resource subject,
\r
1800 AsyncProcedure<Set<Resource>> procedure) {
\r
1801 graph.forSupertypes(subject, procedure);
\r
1805 public void forSupertypes(Resource subject,
\r
1806 SyncProcedure<Set<Resource>> procedure) {
\r
1807 graph.forSupertypes(subject, procedure);
\r
1811 public void forSupertypes(Resource subject,
\r
1812 Procedure<Set<Resource>> procedure) {
\r
1813 graph.forSupertypes(subject, procedure);
\r
1817 public void forPossibleSuperrelation(Resource subject,
\r
1818 AsyncProcedure<Resource> procedure) {
\r
1819 graph.forPossibleSuperrelation(subject, procedure);
\r
1823 public void forSuperrelations(Resource subject,
\r
1824 AsyncListener<Set<Resource>> procedure) {
\r
1825 graph.forSuperrelations(subject, procedure);
\r
1829 public void forSuperrelations(Resource subject,
\r
1830 SyncListener<Set<Resource>> procedure) {
\r
1831 graph.forSuperrelations(subject, procedure);
\r
1835 public void forSuperrelations(Resource subject,
\r
1836 Listener<Set<Resource>> procedure) {
\r
1837 graph.forSuperrelations(subject, procedure);
\r
1841 public void forSuperrelations(Resource subject,
\r
1842 AsyncProcedure<Set<Resource>> procedure) {
\r
1843 graph.forSuperrelations(subject, procedure);
\r
1847 public void forSuperrelations(Resource subject,
\r
1848 SyncProcedure<Set<Resource>> procedure) {
\r
1849 graph.forSuperrelations(subject, procedure);
\r
1853 public void forSuperrelations(Resource subject,
\r
1854 Procedure<Set<Resource>> procedure) {
\r
1855 graph.forSuperrelations(subject, procedure);
\r
1859 public void forObjectSet(Resource subject, Resource relation,
\r
1860 AsyncSetListener<Resource> procedure) {
\r
1861 graph.forObjectSet(subject, relation, procedure);
\r
1865 public void forObjectSet(Resource subject, Resource relation,
\r
1866 SyncSetListener<Resource> procedure) {
\r
1867 graph.forObjectSet(subject, relation, procedure);
\r
1871 public void forObjectSet(Resource subject, Resource relation,
\r
1872 SetListener<Resource> procedure) {
\r
1873 graph.forObjectSet(subject, relation, procedure);
\r
1877 public void forInverse(Resource relation,
\r
1878 SyncListener<Resource> procedure) {
\r
1879 graph.forInverse(relation, procedure);
\r
1883 public void forInverse(Resource relation, Listener<Resource> procedure) {
\r
1884 graph.forInverse(relation, procedure);
\r
1888 public void forInverse(Resource relation,
\r
1889 AsyncProcedure<Resource> procedure) {
\r
1890 graph.forInverse(relation, procedure);
\r
1894 public void forInverse(Resource relation,
\r
1895 SyncProcedure<Resource> procedure) {
\r
1896 graph.forInverse(relation, procedure);
\r
1900 public void forInverse(Resource relation, Procedure<Resource> procedure) {
\r
1901 graph.forInverse(relation, procedure);
\r
1905 public void forSingleObject(Resource subject, Resource relation,
\r
1906 AsyncListener<Resource> procedure) {
\r
1907 graph.forSingleObject(subject, relation, procedure);
\r
1911 public void forSingleObject(Resource subject, Resource relation,
\r
1912 SyncListener<Resource> procedure) {
\r
1913 graph.forSingleObject(subject, relation, procedure);
\r
1917 public void forSingleObject(Resource subject, Resource relation,
\r
1918 Listener<Resource> procedure) {
\r
1919 graph.forSingleObject(subject, relation, procedure);
\r
1923 public void forSingleObject(Resource subject, Resource relation,
\r
1924 AsyncProcedure<Resource> procedure) {
\r
1925 graph.forSingleObject(subject, relation, procedure);
\r
1929 public void forSingleObject(Resource subject, Resource relation,
\r
1930 SyncProcedure<Resource> procedure) {
\r
1931 graph.forSingleObject(subject, relation, procedure);
\r
1935 public void forSingleObject(Resource subject, Resource relation,
\r
1936 Procedure<Resource> procedure) {
\r
1937 graph.forSingleObject(subject, relation, procedure);
\r
1941 public void forSingleStatement(Resource subject, Resource relation,
\r
1942 AsyncListener<Statement> procedure) {
\r
1943 graph.forSingleStatement(subject, relation, procedure);
\r
1947 public void forSingleStatement(Resource subject, Resource relation,
\r
1948 SyncListener<Statement> procedure) {
\r
1949 graph.forSingleStatement(subject, relation, procedure);
\r
1953 public void forSingleStatement(Resource subject, Resource relation,
\r
1954 Listener<Statement> procedure) {
\r
1955 graph.forSingleStatement(subject, relation, procedure);
\r
1959 public void forSingleStatement(Resource subject, Resource relation,
\r
1960 AsyncProcedure<Statement> procedure) {
\r
1961 graph.forSingleStatement(subject, relation, procedure);
\r
1965 public void forSingleStatement(Resource subject, Resource relation,
\r
1966 SyncProcedure<Statement> procedure) {
\r
1967 graph.forSingleStatement(subject, relation, procedure);
\r
1971 public void forSingleStatement(Resource subject, Resource relation,
\r
1972 Procedure<Statement> procedure) {
\r
1973 graph.forSingleStatement(subject, relation, procedure);
\r
1977 public void forSingleType(Resource subject,
\r
1978 AsyncListener<Resource> procedure) {
\r
1979 graph.forSingleType(subject, procedure);
\r
1983 public void forSingleType(Resource subject,
\r
1984 SyncListener<Resource> procedure) {
\r
1985 graph.forSingleType(subject, procedure);
\r
1989 public void forSingleType(Resource subject, Listener<Resource> procedure) {
\r
1990 graph.forSingleType(subject, procedure);
\r
1994 public void forSingleType(Resource subject,
\r
1995 AsyncProcedure<Resource> procedure) {
\r
1996 graph.forSingleType(subject, procedure);
\r
2000 public void forSingleType(Resource subject,
\r
2001 SyncProcedure<Resource> procedure) {
\r
2002 graph.forSingleType(subject, procedure);
\r
2006 public void forSingleType(Resource subject,
\r
2007 Procedure<Resource> procedure) {
\r
2008 graph.forSingleType(subject, procedure);
\r
2012 public void forSingleType(Resource subject, Resource baseType,
\r
2013 AsyncListener<Resource> procedure) {
\r
2014 graph.forSingleType(subject, baseType, procedure);
\r
2018 public void forSingleType(Resource subject, Resource baseType,
\r
2019 SyncListener<Resource> procedure) {
\r
2020 graph.forSingleType(subject, baseType, procedure);
\r
2024 public void forSingleType(Resource subject, Resource baseType,
\r
2025 Listener<Resource> procedure) {
\r
2026 graph.forSingleType(subject, baseType, procedure);
\r
2030 public void forSingleType(Resource subject, Resource baseType,
\r
2031 AsyncProcedure<Resource> procedure) {
\r
2032 graph.forSingleType(subject, baseType, procedure);
\r
2036 public void forSingleType(Resource subject, Resource baseType,
\r
2037 SyncProcedure<Resource> procedure) {
\r
2038 graph.forSingleType(subject, baseType, procedure);
\r
2042 public void forSingleType(Resource subject, Resource baseType,
\r
2043 Procedure<Resource> procedure) {
\r
2044 graph.forSingleType(subject, baseType, procedure);
\r
2048 public <T> void forValue(Resource subject, AsyncListener<T> procedure) {
\r
2049 graph.forValue(subject, procedure);
\r
2053 public <T> void forValue(Resource subject, SyncListener<T> procedure) {
\r
2054 graph.forValue(subject, procedure);
\r
2058 public <T> void forValue(Resource subject, Listener<T> procedure) {
\r
2059 graph.forValue(subject, procedure);
\r
2063 public <T> void forValue(Resource subject, AsyncProcedure<T> procedure) {
\r
2064 graph.forValue(subject, procedure);
\r
2068 public <T> void forValue(Resource subject, SyncProcedure<T> procedure) {
\r
2069 graph.forValue(subject, procedure);
\r
2073 public <T> void forValue(Resource subject, Procedure<T> procedure) {
\r
2074 graph.forValue(subject, procedure);
\r
2078 public <T> void forValue(Resource subject, Binding binding,
\r
2079 AsyncListener<T> procedure) {
\r
2080 graph.forValue(subject, binding, procedure);
\r
2084 public <T> void forValue(Resource subject, Binding binding,
\r
2085 SyncListener<T> procedure) {
\r
2086 graph.forValue(subject, binding, procedure);
\r
2090 public <T> void forValue(Resource subject, Binding binding,
\r
2091 Listener<T> procedure) {
\r
2092 graph.forValue(subject, binding, procedure);
\r
2096 public <T> void forValue(Resource subject, Binding binding,
\r
2097 AsyncProcedure<T> procedure) {
\r
2098 graph.forValue(subject, binding, procedure);
\r
2102 public <T> void forValue(Resource subject, Binding binding,
\r
2103 SyncProcedure<T> procedure) {
\r
2104 graph.forValue(subject, binding, procedure);
\r
2108 public <T> void forValue(Resource subject, Binding binding,
\r
2109 Procedure<T> procedure) {
\r
2110 graph.forValue(subject, binding, procedure);
\r
2114 public <T> void forRelatedValue(Resource subject, Resource relation,
\r
2115 AsyncListener<T> procedure) {
\r
2116 graph.forRelatedValue(subject, relation, procedure);
\r
2120 public <T> void forRelatedValue(Resource subject, Resource relation,
\r
2121 SyncListener<T> procedure) {
\r
2122 graph.forRelatedValue(subject, relation, procedure);
\r
2126 public <T> void forRelatedValue(Resource subject, Resource relation,
\r
2127 Listener<T> procedure) {
\r
2128 graph.forRelatedValue(subject, relation, procedure);
\r
2132 public <T> void forRelatedValue(Resource subject, Resource relation,
\r
2133 AsyncProcedure<T> procedure) {
\r
2134 graph.forRelatedValue(subject, relation, procedure);
\r
2138 public <T> void forRelatedValue(Resource subject, Resource relation,
\r
2139 SyncProcedure<T> procedure) {
\r
2140 graph.forRelatedValue(subject, relation, procedure);
\r
2144 public <T> void forRelatedValue(Resource subject, Resource relation,
\r
2145 Procedure<T> procedure) {
\r
2146 graph.forRelatedValue(subject, relation, procedure);
\r
2150 public <T> void forRelatedValue(Resource subject, Resource relation,
\r
2151 Binding binding, AsyncListener<T> procedure) {
\r
2152 graph.forRelatedValue(subject, relation, binding, procedure);
\r
2156 public <T> void forRelatedValue(Resource subject, Resource relation,
\r
2157 Binding binding, SyncListener<T> procedure) {
\r
2158 graph.forRelatedValue(subject, relation, binding, procedure);
\r
2162 public <T> void forRelatedValue(Resource subject, Resource relation,
\r
2163 Binding binding, Listener<T> procedure) {
\r
2164 graph.forRelatedValue(subject, relation, binding, procedure);
\r
2168 public <T> void forRelatedValue(Resource subject, Resource relation,
\r
2169 Binding binding, AsyncProcedure<T> procedure) {
\r
2170 graph.forRelatedValue(subject, relation, binding, procedure);
\r
2174 public <T> void forRelatedValue(Resource subject, Resource relation,
\r
2175 Binding binding, SyncProcedure<T> procedure) {
\r
2176 graph.forRelatedValue(subject, relation, binding, procedure);
\r
2180 public <T> void forRelatedValue(Resource subject, Resource relation,
\r
2181 Binding binding, Procedure<T> procedure) {
\r
2182 graph.forRelatedValue(subject, relation, binding, procedure);
\r
2186 public <T> void forUniqueAdapted(Resource resource, Class<T> clazz,
\r
2187 AsyncListener<T> procedure) {
\r
2188 graph.forUniqueAdapted(resource, clazz, procedure);
\r
2192 public <T> void forUniqueAdapted(Resource resource, Class<T> clazz,
\r
2193 SyncListener<T> procedure) {
\r
2194 graph.forUniqueAdapted(resource, clazz, procedure);
\r
2198 public <T> void forUniqueAdapted(Resource resource, Class<T> clazz,
\r
2199 Listener<T> procedure) {
\r
2200 graph.forUniqueAdapted(resource, clazz, procedure);
\r
2204 public <T> void forUniqueAdapted(Resource resource, Class<T> clazz,
\r
2205 AsyncProcedure<T> procedure) {
\r
2206 graph.forUniqueAdapted(resource, clazz, procedure);
\r
2210 public <T> void forUniqueAdapted(Resource resource, Class<T> clazz,
\r
2211 SyncProcedure<T> procedure) {
\r
2212 graph.forUniqueAdapted(resource, clazz, procedure);
\r
2216 public <T> void forUniqueAdapted(Resource resource, Class<T> clazz,
\r
2217 Procedure<T> procedure) {
\r
2218 graph.forUniqueAdapted(resource, clazz, procedure);
\r
2222 public void forPossibleInverse(Resource relation,
\r
2223 AsyncListener<Resource> procedure) {
\r
2224 graph.forPossibleInverse(relation, procedure);
\r
2228 public void forPossibleInverse(Resource relation,
\r
2229 SyncListener<Resource> procedure) {
\r
2230 graph.forPossibleInverse(relation, procedure);
\r
2234 public void forPossibleInverse(Resource relation,
\r
2235 Listener<Resource> procedure) {
\r
2236 graph.forPossibleInverse(relation, procedure);
\r
2240 public void forPossibleInverse(Resource relation,
\r
2241 AsyncProcedure<Resource> procedure) {
\r
2242 graph.forPossibleInverse(relation, procedure);
\r
2246 public void forPossibleInverse(Resource relation,
\r
2247 SyncProcedure<Resource> procedure) {
\r
2248 graph.forPossibleInverse(relation, procedure);
\r
2252 public void forPossibleInverse(Resource relation,
\r
2253 Procedure<Resource> procedure) {
\r
2254 graph.forPossibleInverse(relation, procedure);
\r
2258 public void forPossibleObject(Resource subject, Resource relation,
\r
2259 AsyncListener<Resource> procedure) {
\r
2260 graph.forPossibleObject(subject, relation, procedure);
\r
2264 public void forPossibleObject(Resource subject, Resource relation,
\r
2265 SyncListener<Resource> procedure) {
\r
2266 graph.forPossibleObject(subject, relation, procedure);
\r
2270 public void forPossibleObject(Resource subject, Resource relation,
\r
2271 Listener<Resource> procedure) {
\r
2272 graph.forPossibleObject(subject, relation, procedure);
\r
2276 public void forPossibleObject(Resource subject, Resource relation,
\r
2277 AsyncProcedure<Resource> procedure) {
\r
2278 graph.forPossibleObject(subject, relation, procedure);
\r
2282 public void forPossibleObject(Resource subject, Resource relation,
\r
2283 SyncProcedure<Resource> procedure) {
\r
2284 graph.forPossibleObject(subject, relation, procedure);
\r
2288 public void forPossibleObject(Resource subject, Resource relation,
\r
2289 Procedure<Resource> procedure) {
\r
2290 graph.forPossibleObject(subject, relation, procedure);
\r
2294 public void forPossibleStatement(Resource subject, Resource relation,
\r
2295 AsyncListener<Statement> procedure) {
\r
2296 graph.forPossibleStatement(subject, relation, procedure);
\r
2300 public void forPossibleStatement(Resource subject, Resource relation,
\r
2301 SyncListener<Statement> procedure) {
\r
2302 graph.forPossibleStatement(subject, relation, procedure);
\r
2306 public void forPossibleStatement(Resource subject, Resource relation,
\r
2307 Listener<Statement> procedure) {
\r
2308 graph.forPossibleStatement(subject, relation, procedure);
\r
2312 public void forPossibleStatement(Resource subject, Resource relation,
\r
2313 AsyncProcedure<Statement> procedure) {
\r
2314 graph.forPossibleStatement(subject, relation, procedure);
\r
2318 public void forPossibleStatement(Resource subject, Resource relation,
\r
2319 SyncProcedure<Statement> procedure) {
\r
2320 graph.forPossibleStatement(subject, relation, procedure);
\r
2324 public void forPossibleStatement(Resource subject, Resource relation,
\r
2325 Procedure<Statement> procedure) {
\r
2326 graph.forPossibleStatement(subject, relation, procedure);
\r
2330 public void forPossibleType(Resource subject, Resource baseType,
\r
2331 AsyncListener<Resource> procedure) {
\r
2332 graph.forPossibleType(subject, baseType, procedure);
\r
2336 public void forPossibleType(Resource subject, Resource baseType,
\r
2337 SyncListener<Resource> procedure) {
\r
2338 graph.forPossibleType(subject, baseType, procedure);
\r
2342 public void forPossibleType(Resource subject, Resource baseType,
\r
2343 Listener<Resource> procedure) {
\r
2344 graph.forPossibleType(subject, baseType, procedure);
\r
2348 public void forPossibleType(Resource subject, Resource baseType,
\r
2349 AsyncProcedure<Resource> procedure) {
\r
2350 graph.forPossibleType(subject, baseType, procedure);
\r
2354 public void forPossibleType(Resource subject, Resource baseType,
\r
2355 SyncProcedure<Resource> procedure) {
\r
2356 graph.forPossibleType(subject, baseType, procedure);
\r
2360 public void forPossibleType(Resource subject, Resource baseType,
\r
2361 Procedure<Resource> procedure) {
\r
2362 graph.forPossibleType(subject, baseType, procedure);
\r
2366 public <T> void forPossibleValue(Resource subject,
\r
2367 AsyncListener<T> procedure) {
\r
2368 graph.forPossibleValue(subject, procedure);
\r
2372 public <T> void forPossibleValue(Resource subject,
\r
2373 SyncListener<T> procedure) {
\r
2374 graph.forPossibleValue(subject, procedure);
\r
2378 public <T> void forPossibleValue(Resource subject, Listener<T> procedure) {
\r
2379 graph.forPossibleValue(subject, procedure);
\r
2383 public <T> void forPossibleValue(Resource subject,
\r
2384 AsyncProcedure<T> procedure) {
\r
2385 graph.forPossibleValue(subject, procedure);
\r
2389 public <T> void forPossibleValue(Resource subject,
\r
2390 SyncProcedure<T> procedure) {
\r
2391 graph.forPossibleValue(subject, procedure);
\r
2395 public <T> void forPossibleValue(Resource subject,
\r
2396 Procedure<T> procedure) {
\r
2397 graph.forPossibleValue(subject, procedure);
\r
2401 public <T> void forPossibleValue(Resource subject, Binding binding,
\r
2402 AsyncListener<T> procedure) {
\r
2403 graph.forPossibleValue(subject, procedure);
\r
2407 public <T> void forPossibleValue(Resource subject, Binding binding,
\r
2408 SyncListener<T> procedure) {
\r
2409 graph.forPossibleValue(subject, procedure);
\r
2413 public <T> void forPossibleValue(Resource subject, Binding binding,
\r
2414 Listener<T> procedure) {
\r
2415 graph.forPossibleValue(subject, procedure);
\r
2419 public <T> void forPossibleValue(Resource subject, Binding binding,
\r
2420 AsyncProcedure<T> procedure) {
\r
2421 graph.forPossibleValue(subject, procedure);
\r
2425 public <T> void forPossibleValue(Resource subject, Binding binding,
\r
2426 SyncProcedure<T> procedure) {
\r
2427 graph.forPossibleValue(subject, procedure);
\r
2431 public <T> void forPossibleValue(Resource subject, Binding binding,
\r
2432 Procedure<T> procedure) {
\r
2433 graph.forPossibleValue(subject, procedure);
\r
2437 public <T> void forPossibleRelatedValue(Resource subject,
\r
2438 Resource relation, AsyncListener<T> procedure) {
\r
2439 graph.forPossibleRelatedValue(subject, relation, procedure);
\r
2443 public <T> void forPossibleRelatedValue(Resource subject,
\r
2444 Resource relation, SyncListener<T> procedure) {
\r
2445 graph.forPossibleRelatedValue(subject, relation, procedure);
\r
2449 public <T> void forPossibleRelatedValue(Resource subject,
\r
2450 Resource relation, Listener<T> procedure) {
\r
2451 graph.forPossibleRelatedValue(subject, relation, procedure);
\r
2455 public <T> void forPossibleRelatedValue(Resource subject,
\r
2456 Resource relation, AsyncProcedure<T> procedure) {
\r
2457 graph.forPossibleRelatedValue(subject, relation, procedure);
\r
2461 public <T> void forPossibleRelatedValue(Resource subject,
\r
2462 Resource relation, SyncProcedure<T> procedure) {
\r
2463 graph.forPossibleRelatedValue(subject, relation, procedure);
\r
2467 public <T> void forPossibleRelatedValue(Resource subject,
\r
2468 Resource relation, Procedure<T> procedure) {
\r
2469 graph.forPossibleRelatedValue(subject, relation, procedure);
\r
2473 public <T> void forPossibleRelatedValue(Resource subject,
\r
2474 Resource relation, Binding binding, AsyncListener<T> procedure) {
\r
2475 graph.forPossibleRelatedValue(subject, relation, binding, procedure);
\r
2479 public <T> void forPossibleRelatedValue(Resource subject,
\r
2480 Resource relation, Binding binding, SyncListener<T> procedure) {
\r
2481 graph.forPossibleRelatedValue(subject, relation, procedure);
\r
2485 public <T> void forPossibleRelatedValue(Resource subject,
\r
2486 Resource relation, Binding binding, Listener<T> procedure) {
\r
2487 graph.forPossibleRelatedValue(subject, relation, binding, procedure);
\r
2491 public <T> void forPossibleRelatedValue(Resource subject,
\r
2492 Resource relation, Binding binding, AsyncProcedure<T> procedure) {
\r
2493 graph.forPossibleRelatedValue(subject, relation, binding, procedure);
\r
2497 public <T> void forPossibleRelatedValue(Resource subject,
\r
2498 Resource relation, Binding binding, SyncProcedure<T> procedure) {
\r
2499 graph.forPossibleRelatedValue(subject, relation, binding, procedure);
\r
2503 public <T> void forPossibleRelatedValue(Resource subject,
\r
2504 Resource relation, Binding binding, Procedure<T> procedure) {
\r
2505 graph.forPossibleRelatedValue(subject, relation, binding, procedure);
\r
2509 public <T> void forPossibleAdapted(Resource resource, Class<T> clazz,
\r
2510 AsyncListener<T> procedure) {
\r
2511 graph.forPossibleAdapted(resource, clazz, procedure);
\r
2515 public <T> void forPossibleAdapted(Resource resource, Class<T> clazz,
\r
2516 SyncListener<T> procedure) {
\r
2517 graph.forPossibleAdapted(resource, clazz, procedure);
\r
2521 public <T> void forPossibleAdapted(Resource resource, Class<T> clazz,
\r
2522 Listener<T> procedure) {
\r
2523 graph.forPossibleAdapted(resource, clazz, procedure);
\r
2527 public <T> void forPossibleAdapted(Resource resource, Class<T> clazz,
\r
2528 AsyncProcedure<T> procedure) {
\r
2529 graph.forPossibleAdapted(resource, clazz, procedure);
\r
2533 public <T> void forPossibleAdapted(Resource resource, Class<T> clazz,
\r
2534 SyncProcedure<T> procedure) {
\r
2535 graph.forPossibleAdapted(resource, clazz, procedure);
\r
2539 public <T> void forPossibleAdapted(Resource resource, Class<T> clazz,
\r
2540 Procedure<T> procedure) {
\r
2541 graph.forPossibleAdapted(resource, clazz, procedure);
\r
2545 public <T> void forPossibleUniqueAdapted(Resource resource,
\r
2546 Class<T> clazz, AsyncListener<T> procedure) {
\r
2547 graph.forPossibleUniqueAdapted(resource, clazz, procedure);
\r
2551 public <T> void forPossibleUniqueAdapted(Resource resource,
\r
2552 Class<T> clazz, SyncListener<T> procedure) {
\r
2553 graph.forPossibleUniqueAdapted(resource, clazz, procedure);
\r
2557 public <T> void forPossibleUniqueAdapted(Resource resource,
\r
2558 Class<T> clazz, Listener<T> procedure) {
\r
2559 graph.forPossibleUniqueAdapted(resource, clazz, procedure);
\r
2563 public <T> void forPossibleUniqueAdapted(Resource resource,
\r
2564 Class<T> clazz, AsyncProcedure<T> procedure) {
\r
2565 graph.forPossibleUniqueAdapted(resource, clazz, procedure);
\r
2569 public <T> void forPossibleUniqueAdapted(Resource resource,
\r
2570 Class<T> clazz, SyncProcedure<T> procedure) {
\r
2571 graph.forPossibleUniqueAdapted(resource, clazz, procedure);
\r
2575 public <T> void forPossibleUniqueAdapted(Resource resource,
\r
2576 Class<T> clazz, Procedure<T> procedure) {
\r
2577 graph.forPossibleUniqueAdapted(resource, clazz, procedure);
\r
2581 public void forIsInstanceOf(Resource resource, Resource type,
\r
2582 AsyncListener<Boolean> procedure) {
\r
2583 graph.forIsInstanceOf(resource, type, procedure);
\r
2587 public void forIsInstanceOf(Resource resource, Resource type,
\r
2588 SyncListener<Boolean> procedure) {
\r
2589 graph.forIsInstanceOf(resource, type, procedure);
\r
2593 public void forIsInstanceOf(Resource resource, Resource type,
\r
2594 Listener<Boolean> procedure) {
\r
2595 graph.forIsInstanceOf(resource, type, procedure);
\r
2599 public void forIsInstanceOf(Resource resource, Resource type,
\r
2600 AsyncProcedure<Boolean> procedure) {
\r
2601 graph.forIsInstanceOf(resource, type, procedure);
\r
2605 public void forIsInstanceOf(Resource resource, Resource type,
\r
2606 SyncProcedure<Boolean> procedure) {
\r
2607 graph.forIsInstanceOf(resource, type, procedure);
\r
2611 public void forIsInstanceOf(Resource resource, Resource type,
\r
2612 Procedure<Boolean> procedure) {
\r
2613 graph.forIsInstanceOf(resource, type, procedure);
\r
2617 public void forIsInheritedFrom(Resource resource, Resource type,
\r
2618 AsyncListener<Boolean> procedure) {
\r
2619 graph.forIsInheritedFrom(resource, type, procedure);
\r
2623 public void forIsInheritedFrom(Resource resource, Resource type,
\r
2624 SyncListener<Boolean> procedure) {
\r
2625 graph.forIsInheritedFrom(resource, type, procedure);
\r
2629 public void forIsInheritedFrom(Resource resource, Resource type,
\r
2630 Listener<Boolean> procedure) {
\r
2631 graph.forIsInheritedFrom(resource, type, procedure);
\r
2635 public void forIsInheritedFrom(Resource resource, Resource type,
\r
2636 AsyncProcedure<Boolean> procedure) {
\r
2637 graph.forIsInheritedFrom(resource, type, procedure);
\r
2641 public void forIsInheritedFrom(Resource resource, Resource type,
\r
2642 SyncProcedure<Boolean> procedure) {
\r
2643 graph.forIsInheritedFrom(resource, type, procedure);
\r
2647 public void forIsInheritedFrom(Resource resource, Resource type,
\r
2648 Procedure<Boolean> procedure) {
\r
2649 graph.forIsInheritedFrom(resource, type, procedure);
\r
2653 public void forIsSubrelationOf(Resource resource, Resource relation,
\r
2654 AsyncListener<Boolean> procedure) {
\r
2655 graph.forIsSubrelationOf(resource, relation, procedure);
\r
2659 public void forIsSubrelationOf(Resource resource, Resource relation,
\r
2660 SyncListener<Boolean> procedure) {
\r
2661 graph.forIsSubrelationOf(resource, relation, procedure);
\r
2665 public void forIsSubrelationOf(Resource resource, Resource relation,
\r
2666 Listener<Boolean> procedure) {
\r
2667 graph.forIsSubrelationOf(resource, relation, procedure);
\r
2671 public void forIsSubrelationOf(Resource resource, Resource relation,
\r
2672 AsyncProcedure<Boolean> procedure) {
\r
2673 graph.forIsSubrelationOf(resource, relation, procedure);
\r
2677 public void forIsSubrelationOf(Resource resource, Resource relation,
\r
2678 SyncProcedure<Boolean> procedure) {
\r
2679 graph.forIsSubrelationOf(resource, relation, procedure);
\r
2683 public void forIsSubrelationOf(Resource resource, Resource relation,
\r
2684 Procedure<Boolean> procedure) {
\r
2685 graph.forIsSubrelationOf(resource, relation, procedure);
\r
2689 public void forOrderedSet(Resource subject,
\r
2690 AsyncMultiListener<Resource> procedure) {
\r
2691 graph.forOrderedSet(subject, procedure);
\r
2695 public void forOrderedSet(Resource subject,
\r
2696 SyncMultiListener<Resource> procedure) {
\r
2697 graph.forOrderedSet(subject, procedure);
\r
2701 public void forOrderedSet(Resource subject,
\r
2702 MultiListener<Resource> procedure) {
\r
2703 graph.forOrderedSet(subject, procedure);
\r
2707 public void forOrderedSet(Resource subject,
\r
2708 AsyncMultiProcedure<Resource> procedure) {
\r
2709 graph.forOrderedSet(subject, procedure);
\r
2713 public void forOrderedSet(Resource subject,
\r
2714 SyncMultiProcedure<Resource> procedure) {
\r
2715 graph.forOrderedSet(subject, procedure);
\r
2719 public void forOrderedSet(Resource subject,
\r
2720 MultiProcedure<Resource> procedure) {
\r
2721 graph.forOrderedSet(subject, procedure);
\r
2725 public int thread() {
\r
2726 return graph.thread();
\r
2730 public Session getSession() {
\r
2731 return graph.getSession();
\r
2735 public Resource getBuiltin(String id) throws ResourceNotFoundException,
\r
2736 ServiceException {
\r
2737 return graph.getBuiltin(id);
\r
2741 public VirtualGraph getProvider() {
\r
2742 return graph.getProvider();
\r
2746 public boolean isImmutable(Resource resource) throws DatabaseException {
\r
2747 return graph.isImmutable(resource);
\r