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 newLiteral4RandomAccessBinary
\r
250 (Resource resource, Resource predicate, Datatype datatype, Object initialValue)
\r
251 throws DatabaseException {
\r
252 return graph.newLiteral4RandomAccessBinary(resource, predicate, datatype, initialValue);
\r
255 // public void claimFile(Resource resource, Object content, Binding binding)
\r
256 // throws DatabaseException {
\r
257 // graph.claimFile(resource, content, binding);
\r
261 // public void denyFile(Resource resource) throws DatabaseException {
\r
262 // graph.denyFile(resource);
\r
265 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
266 return graph.adaptContextual(resource, context, contextClass, clazz);
\r
269 public <T, C> T getPossibleContextualAdapter(Resource resource, C context, java.lang.Class<C> contextClass, java.lang.Class<T> clazz) throws ValidationException ,ServiceException {
\r
270 return graph.getPossibleContextualAdapter(resource, context, contextClass, clazz);
\r
274 public WriteGraphProxy(WriteGraph graph) {
\r
275 this.graph = graph;
\r
279 public Resource newResource() throws ServiceException {
\r
280 return graph.newResource();
\r
284 public Resource newResource(long clusterId) throws ServiceException {
\r
285 return graph.newResource(clusterId);
\r
289 public <T> T adapt(Resource resource, Class<T> clazz)
\r
290 throws AdaptionException, ValidationException, ServiceException {
\r
291 return graph.adapt(resource, clazz);
\r
295 public <T> T adaptUnique(Resource resource, Class<T> clazz)
\r
296 throws AdaptionException, ValidationException, ServiceException {
\r
297 return adaptUnique(resource, clazz);
\r
301 public void addLiteral(Resource resource, Resource predicate,
\r
302 Resource inverse, Object value, Binding binding)
\r
303 throws BindingException,
\r
304 ManyObjectsForFunctionalRelationException, ServiceException {
\r
305 graph.addLiteral(resource, predicate, inverse, value, binding);
\r
309 public void addLiteral(Resource resource, Resource predicate,
\r
310 Resource inverse, Resource type, Object value, Binding binding)
\r
311 throws BindingException,
\r
312 ManyObjectsForFunctionalRelationException, ServiceException {
\r
313 graph.addLiteral(resource, predicate, inverse, type, value, binding);
\r
317 public <T> void addMetadata(Metadata data) throws ServiceException {
\r
318 graph.addMetadata(data);
\r
321 @SuppressWarnings("deprecation")
\r
323 public void addValue(Resource resource, Resource predicate,
\r
324 Resource inverse, Resource type, Object value, Binding binding)
\r
325 throws BindingException,
\r
326 ManyObjectsForFunctionalRelationException, ServiceException {
\r
327 graph.addValue(resource, predicate, inverse, type, value, binding);
\r
331 public <T> void asyncRequest(AsyncMultiRead<T> request) {
\r
332 graph.asyncRequest(request);
\r
336 public <T> void asyncRequest(AsyncMultiRead<T> request,
\r
337 AsyncMultiListener<T> procedure) {
\r
338 graph.asyncRequest(request,procedure);
\r
342 public <T> void asyncRequest(AsyncMultiRead<T> request,
\r
343 AsyncMultiProcedure<T> procedure) {
\r
344 graph.asyncRequest(request,procedure);
\r
348 public <T> void asyncRequest(AsyncMultiRead<T> request,
\r
349 MultiListener<T> procedure) {
\r
350 graph.asyncRequest(request,procedure);
\r
354 public <T> void asyncRequest(AsyncMultiRead<T> request,
\r
355 MultiProcedure<T> procedure) {
\r
356 graph.asyncRequest(request,procedure);
\r
360 public <T> void asyncRequest(AsyncMultiRead<T> request,
\r
361 SyncMultiListener<T> procedure) {
\r
362 graph.asyncRequest(request,procedure);
\r
366 public <T> void asyncRequest(AsyncMultiRead<T> request,
\r
367 SyncMultiProcedure<T> procedure) {
\r
368 graph.asyncRequest(request,procedure);
\r
372 public <T> void asyncRequest(AsyncRead<T> request) {
\r
373 graph.asyncRequest(request);
\r
377 public <T> void asyncRequest(AsyncRead<T> request,
\r
378 AsyncListener<T> procedure) {
\r
379 graph.asyncRequest(request,procedure);
\r
383 public <T> void asyncRequest(AsyncRead<T> request,
\r
384 AsyncProcedure<T> procedure) {
\r
385 graph.asyncRequest(request,procedure);
\r
389 public <T> void asyncRequest(AsyncRead<T> request, Listener<T> procedure) {
\r
390 graph.asyncRequest(request,procedure);
\r
394 public <T> void asyncRequest(AsyncRead<T> request,
\r
395 Procedure<T> procedure) {
\r
396 graph.asyncRequest(request,procedure);
\r
400 public <T> void asyncRequest(AsyncRead<T> request,
\r
401 SyncListener<T> procedure) {
\r
402 graph.asyncRequest(request,procedure);
\r
406 public <T> void asyncRequest(AsyncRead<T> request,
\r
407 SyncProcedure<T> procedure) {
\r
408 graph.asyncRequest(request,procedure);
\r
412 public void asyncRequest(DelayedWrite request) {
\r
413 graph.asyncRequest(request);
\r
417 public void asyncRequest(DelayedWrite request,
\r
418 Callback<DatabaseException> callback) {
\r
419 graph.asyncRequest(request,callback);
\r
423 public <T> void asyncRequest(DelayedWriteResult<T> r,
\r
424 Procedure<T> procedure) {
\r
425 graph.asyncRequest(r,procedure);
\r
429 public <T> void asyncRequest(ExternalRead<T> request) {
\r
430 graph.asyncRequest(request);
\r
434 public <T> void asyncRequest(ExternalRead<T> request,
\r
435 Listener<T> procedure) {
\r
436 graph.asyncRequest(request,procedure);
\r
440 public <T> void asyncRequest(ExternalRead<T> request,
\r
441 Procedure<T> procedure) {
\r
442 graph.asyncRequest(request,procedure);
\r
446 public <T> void asyncRequest(MultiRead<T> request) {
\r
447 graph.asyncRequest(request);
\r
451 public <T> void asyncRequest(MultiRead<T> request,
\r
452 AsyncMultiListener<T> procedure) {
\r
453 graph.asyncRequest(request,procedure);
\r
457 public <T> void asyncRequest(MultiRead<T> request,
\r
458 AsyncMultiProcedure<T> procedure) {
\r
459 graph.asyncRequest(request,procedure);
\r
463 public <T> void asyncRequest(MultiRead<T> request,
\r
464 MultiListener<T> procedure) {
\r
465 graph.asyncRequest(request,procedure);
\r
469 public <T> void asyncRequest(MultiRead<T> request,
\r
470 MultiProcedure<T> procedure) {
\r
471 graph.asyncRequest(request,procedure);
\r
475 public <T> void asyncRequest(MultiRead<T> request,
\r
476 SyncMultiListener<T> procedure) {
\r
477 graph.asyncRequest(request,procedure);
\r
481 public <T> void asyncRequest(MultiRead<T> request,
\r
482 SyncMultiProcedure<T> procedure) {
\r
483 graph.asyncRequest(request,procedure);
\r
487 public <T> void asyncRequest(Read<T> request) {
\r
488 graph.asyncRequest(request);
\r
492 public <T> void asyncRequest(Read<T> request, AsyncListener<T> procedure) {
\r
493 graph.asyncRequest(request,procedure);
\r
497 public <T> void asyncRequest(Read<T> request,
\r
498 AsyncProcedure<T> procedure) {
\r
499 graph.asyncRequest(request,procedure);
\r
503 public <T> void asyncRequest(Read<T> request, Listener<T> procedure) {
\r
504 graph.asyncRequest(request,procedure);
\r
508 public <T> void asyncRequest(Read<T> request, Procedure<T> procedure) {
\r
509 graph.asyncRequest(request,procedure);
\r
513 public <T> void asyncRequest(Read<T> request, SyncListener<T> procedure) {
\r
514 graph.asyncRequest(request,procedure);
\r
518 public <T> void asyncRequest(Read<T> request, SyncProcedure<T> procedure) {
\r
519 graph.asyncRequest(request,procedure);
\r
523 public void asyncRequest(Write request) {
\r
524 graph.asyncRequest(request);
\r
528 public void asyncRequest(Write request,
\r
529 Callback<DatabaseException> callback) {
\r
530 graph.asyncRequest(request, callback);
\r
534 public void asyncRequest(WriteOnly r) {
\r
535 graph.asyncRequest(r);
\r
539 public void asyncRequest(WriteOnly r,
\r
540 Callback<DatabaseException> callback) {
\r
541 graph.asyncRequest(r,callback);
\r
545 public <T> void asyncRequest(WriteOnlyResult<T> r,
\r
546 Procedure<T> procedure) {
\r
547 graph.asyncRequest(r,procedure);
\r
551 public <T> void asyncRequest(WriteResult<T> r, Procedure<T> procedure) {
\r
552 graph.asyncRequest(r,procedure);
\r
558 public void claim(Resource subject, Resource predicate,
\r
559 Resource inverse, Resource object) throws ServiceException {
\r
560 graph.claim(subject, predicate, inverse, object);
\r
564 public void claim(Resource subject, Resource predicate, Resource object)
\r
565 throws ServiceException {
\r
566 graph.claim(subject, predicate, object);
\r
571 public void claimLiteral(Resource resource, Resource predicate,
\r
572 Object value) throws ManyObjectsForFunctionalRelationException,
\r
574 graph.claimLiteral(resource, predicate, value);
\r
578 public void claimLiteral(Resource resource, Resource predicate,
\r
579 Object value, Binding binding) throws BindingException,
\r
580 ManyObjectsForFunctionalRelationException, ServiceException {
\r
581 graph.claimLiteral(resource, predicate, value, binding);
\r
585 public void claimLiteral(Resource resource, Resource predicate,
\r
586 Resource inverse, Resource type, Object value)
\r
587 throws BindingException,
\r
588 ManyObjectsForFunctionalRelationException, ServiceException {
\r
589 graph.claimLiteral(resource, predicate, inverse, type, value);
\r
593 public void claimLiteral(Resource resource, Resource predicate,
\r
594 Resource inverse, Resource type, Object value, Binding binding)
\r
595 throws BindingException,
\r
596 ManyObjectsForFunctionalRelationException, ServiceException {
\r
597 graph.claimLiteral(resource, predicate, inverse, type, value, binding);
\r
601 public void claimLiteral(Resource resource, Resource predicate,
\r
602 Resource type, Object value) throws BindingException,
\r
603 ManyObjectsForFunctionalRelationException, ServiceException {
\r
604 graph.claimLiteral(resource, predicate, type, value);
\r
608 public void claimLiteral(Resource resource, Resource predicate,
\r
609 Resource type, Object value, Binding binding)
\r
610 throws BindingException,
\r
611 ManyObjectsForFunctionalRelationException, ServiceException {
\r
612 graph.claimLiteral(resource, predicate, type, value, binding);
\r
616 public void claimValue(Resource resource, Object value)
\r
617 throws ServiceException {
\r
618 graph.claimValue(resource, value);
\r
622 public void claimValue(Resource resource, Object value, Binding binding)
\r
623 throws ServiceException {
\r
624 graph.claimValue(resource, value, binding);
\r
627 @SuppressWarnings("deprecation")
\r
629 public void claimValue(Resource resource, Resource predicate,
\r
630 Object value) throws ManyObjectsForFunctionalRelationException,
\r
632 graph.claimValue(resource, predicate, value);
\r
635 @SuppressWarnings("deprecation")
\r
637 public void claimValue(Resource resource, Resource predicate,
\r
638 Object value, Binding binding) throws BindingException,
\r
639 ManyObjectsForFunctionalRelationException, ServiceException {
\r
640 graph.claimValue(resource, predicate, value, binding);
\r
643 @SuppressWarnings("deprecation")
\r
645 public void claimValue(Resource resource, Resource predicate,
\r
646 Resource inverse, Resource type, Object value, Binding binding)
\r
647 throws BindingException,
\r
648 ManyObjectsForFunctionalRelationException, ServiceException {
\r
649 graph.claimValue(resource, predicate, inverse, type, value, binding);
\r
653 public void deny(Resource subject) throws ServiceException {
\r
654 graph.deny(subject);
\r
658 public void deny(Resource subject, Resource predicate)
\r
659 throws ServiceException {
\r
660 graph.deny(subject, predicate);
\r
664 public void deny(Resource subject, Resource predicate,
\r
665 Resource inverse, Resource object) throws ServiceException {
\r
666 graph.deny(subject, predicate, inverse, object);
\r
670 public void deny(Resource subject, Resource predicate, Resource object)
\r
671 throws ServiceException {
\r
672 graph.deny(subject, predicate, object);
\r
676 public void deny(Statement statement) throws ServiceException {
\r
677 graph.deny(statement);
\r
682 public void denyStatement(Resource subject, Resource predicate,
\r
683 Resource object) throws ServiceException {
\r
684 graph.denyStatement(subject, predicate, object);
\r
688 public void denyValue(Resource resource) throws ServiceException {
\r
689 graph.denyValue(resource);
\r
693 public void denyValue(Resource resource, Resource predicate)
\r
694 throws ManyObjectsForFunctionalRelationException,
\r
696 graph.denyValue(resource, predicate);
\r
700 public void flushCluster() throws ServiceException {
\r
701 graph.flushCluster();
\r
705 public void flushCluster(Resource r) throws ServiceException {
\r
706 graph.flushCluster(r);
\r
710 public <T> void forAdapted(Resource resource, Class<T> clazz,
\r
711 AsyncListener<T> procedure) {
\r
712 graph.forAdapted(resource, clazz, procedure);
\r
716 public <T> void forAdapted(Resource resource, Class<T> clazz,
\r
717 AsyncProcedure<T> procedure) {
\r
718 graph.forAdapted(resource, clazz, procedure);
\r
722 public <T> void forAdapted(Resource resource, Class<T> clazz,
\r
723 Listener<T> procedure) {
\r
724 graph.forAdapted(resource, clazz, procedure);
\r
728 public <T> void forAdapted(Resource resource, Class<T> clazz,
\r
729 Procedure<T> procedure) {
\r
730 graph.forAdapted(resource, clazz, procedure);
\r
734 public <T> void forAdapted(Resource resource, Class<T> clazz,
\r
735 SyncListener<T> procedure) {
\r
736 graph.forAdapted(resource, clazz, procedure);
\r
740 public <T> void forAdapted(Resource resource, Class<T> clazz,
\r
741 SyncProcedure<T> procedure) {
\r
742 graph.forAdapted(resource, clazz, procedure);
\r
746 public void forAssertedObjectSet(Resource subject, Resource relation,
\r
747 AsyncSetListener<Resource> procedure) {
\r
748 graph.forAssertedObjectSet(subject, relation, procedure);
\r
752 public void forAssertedObjectSet(Resource subject, Resource relation,
\r
753 SetListener<Resource> procedure) {
\r
754 graph.forAssertedObjectSet(subject, relation, procedure);
\r
758 public void forAssertedObjectSet(Resource subject, Resource relation,
\r
759 SyncSetListener<Resource> procedure) {
\r
760 graph.forAssertedObjectSet(subject, relation, procedure);
\r
764 public void forAssertedStatementSet(Resource subject,
\r
765 Resource relation, AsyncSetListener<Statement> procedure) {
\r
766 graph.forAssertedStatementSet(subject, relation, procedure);
\r
770 public void forAssertedStatementSet(Resource subject,
\r
771 Resource relation, SetListener<Statement> procedure) {
\r
772 graph.forAssertedStatementSet(subject, relation, procedure);
\r
776 public void forAssertedStatementSet(Resource subject,
\r
777 Resource relation, SyncSetListener<Statement> procedure) {
\r
778 graph.forAssertedStatementSet(subject, relation, procedure);
\r
782 public void forBuiltin(String id, AsyncListener<Resource> procedure) {
\r
783 graph.forBuiltin(id, procedure);
\r
787 public void forBuiltin(String id, Listener<Resource> procedure) {
\r
788 graph.forBuiltin(id, procedure);
\r
792 public void forBuiltin(String id, AsyncProcedure<Resource> procedure) {
\r
793 graph.forBuiltin(id, procedure);
\r
797 public void forBuiltin(String id, Procedure<Resource> procedure) {
\r
798 graph.forBuiltin(id, procedure);
\r
802 public void forBuiltin(String id, SyncListener<Resource> procedure) {
\r
803 graph.forBuiltin(id, procedure);
\r
807 public void forBuiltin(String id, SyncProcedure<Resource> procedure) {
\r
808 graph.forBuiltin(id, procedure);
\r
812 public void forDirectSuperrelations(Resource subject,
\r
813 AsyncMultiProcedure<Resource> procedure) {
\r
814 graph.forDirectSuperrelations(subject, procedure);
\r
818 public void forEachAssertedObject(Resource subject, Resource relation,
\r
819 AsyncMultiProcedure<Resource> procedure) {
\r
820 graph.forEachAssertedObject(subject, relation, procedure);
\r
824 public void forEachAssertedObject(Resource subject, Resource relation,
\r
825 MultiProcedure<Resource> procedure) {
\r
826 graph.forEachAssertedObject(subject, relation, procedure);
\r
830 public void forEachAssertedObject(Resource subject, Resource relation,
\r
831 SyncMultiProcedure<Resource> procedure) {
\r
832 graph.forEachAssertedObject(subject, relation, procedure);
\r
836 public void forEachAssertedStatement(Resource subject,
\r
837 Resource relation, AsyncMultiProcedure<Statement> procedure) {
\r
838 graph.forEachAssertedStatement(subject, relation, procedure);
\r
842 public void forEachAssertedStatement(Resource subject,
\r
843 Resource relation, MultiProcedure<Statement> procedure) {
\r
844 graph.forEachAssertedStatement(subject, relation, procedure);
\r
848 public void forEachAssertedStatement(Resource subject,
\r
849 Resource relation, SyncMultiProcedure<Statement> procedure) {
\r
850 graph.forEachAssertedStatement(subject, relation, procedure);
\r
854 // public void forEachDirectObject(Resource subject, Resource relation,
\r
855 // AsyncMultiProcedure<Resource> procedure) {
\r
856 // graph.forEachDirectObject(subject, relation, procedure);
\r
860 // public void forEachDirectObject(Resource subject, Resource relation,
\r
861 // MultiProcedure<Resource> procedure) {
\r
862 // graph.forEachDirectObject(subject, relation, procedure);
\r
866 // public void forEachDirectObject(Resource subject, Resource relation,
\r
867 // SyncMultiProcedure<Resource> procedure) {
\r
868 // graph.forEachDirectObject(subject, relation, procedure);
\r
872 public void forEachDirectPredicate(Resource subject,
\r
873 AsyncMultiProcedure<Resource> procedure) {
\r
874 graph.forEachDirectPredicate(subject, procedure);
\r
878 public void forEachDirectPredicate(Resource subject,
\r
879 MultiProcedure<Resource> procedure) {
\r
880 graph.forEachDirectPredicate(subject, procedure);
\r
884 public void forEachDirectPredicate(Resource subject,
\r
885 SyncMultiProcedure<Resource> procedure) {
\r
886 graph.forEachDirectPredicate(subject, procedure);
\r
890 public void forEachObject(Resource subject, Resource relation,
\r
891 AsyncMultiProcedure<Resource> procedure) {
\r
892 graph.forEachObject(subject, relation, procedure);
\r
896 public void forEachObject(Resource subject, Resource relation,
\r
897 MultiProcedure<Resource> procedure) {
\r
898 graph.forEachObject(subject, relation, procedure);
\r
902 public void forEachObject(Resource subject, Resource relation,
\r
903 SyncMultiProcedure<Resource> procedure) {
\r
904 graph.forEachObject(subject, relation, procedure);
\r
908 public void forEachPredicate(Resource subject,
\r
909 AsyncMultiProcedure<Resource> procedure) {
\r
910 graph.forEachPredicate(subject, procedure);
\r
914 public void forEachPredicate(Resource subject,
\r
915 MultiProcedure<Resource> procedure) {
\r
916 graph.forEachPredicate(subject, procedure);
\r
920 public void forEachPredicate(Resource subject,
\r
921 SyncMultiProcedure<Resource> procedure) {
\r
922 graph.forEachPredicate(subject, procedure);
\r
926 public void forEachPrincipalType(Resource subject,
\r
927 AsyncMultiProcedure<Resource> procedure) {
\r
928 graph.forEachPrincipalType(subject, procedure);
\r
932 public void forEachPrincipalType(Resource subject,
\r
933 MultiProcedure<Resource> procedure) {
\r
934 graph.forEachPrincipalType(subject, procedure);
\r
938 public void forEachPrincipalType(Resource subject,
\r
939 SyncMultiProcedure<Resource> procedure) {
\r
940 graph.forEachPrincipalType(subject, procedure);
\r
944 public void forEachStatement(Resource subject, Resource relation,
\r
945 AsyncMultiProcedure<Statement> procedure) {
\r
946 graph.forEachStatement(subject, relation, procedure);
\r
950 public void forEachStatement(Resource subject, Resource relation,
\r
951 MultiProcedure<Statement> procedure) {
\r
952 graph.forEachStatement(subject, relation, procedure);
\r
956 public void forEachStatement(Resource subject, Resource relation,
\r
957 SyncMultiProcedure<Statement> procedure) {
\r
958 graph.forEachStatement(subject, relation, procedure);
\r
962 public void forHasStatement(Resource subject,
\r
963 AsyncListener<Boolean> procedure) {
\r
964 graph.forHasStatement(subject, procedure);
\r
968 public void forHasStatement(Resource subject,
\r
969 AsyncProcedure<Boolean> procedure) {
\r
970 graph.forHasStatement(subject, procedure);
\r
974 public void forHasStatement(Resource subject,
\r
975 Listener<Boolean> procedure) {
\r
976 graph.forHasStatement(subject, procedure);
\r
980 public void forHasStatement(Resource subject,
\r
981 Procedure<Boolean> procedure) {
\r
982 graph.forHasStatement(subject, procedure);
\r
986 public void forHasStatement(Resource subject, Resource relation,
\r
987 AsyncListener<Boolean> procedure) {
\r
988 graph.forHasStatement(subject, relation, procedure);
\r
992 public void forHasStatement(Resource subject, Resource relation,
\r
993 AsyncProcedure<Boolean> procedure) {
\r
994 graph.forHasStatement(subject, relation, procedure);
\r
998 public void forHasStatement(Resource subject, Resource relation,
\r
999 Listener<Boolean> procedure) {
\r
1000 graph.forHasStatement(subject, relation, procedure);
\r
1004 public void forHasStatement(Resource subject, Resource relation,
\r
1005 Procedure<Boolean> procedure) {
\r
1006 graph.forHasStatement(subject, relation, procedure);
\r
1010 public void forHasStatement(Resource subject, Resource relation,
\r
1011 Resource object, AsyncListener<Boolean> procedure) {
\r
1012 graph.forHasStatement(subject, relation, object, procedure);
\r
1016 public void forHasStatement(Resource subject, Resource relation,
\r
1017 Resource object, AsyncProcedure<Boolean> procedure) {
\r
1018 graph.forHasStatement(subject, relation, object, procedure);
\r
1022 public void forHasStatement(Resource subject, Resource relation,
\r
1023 Resource object, Listener<Boolean> procedure) {
\r
1024 graph.forHasStatement(subject, relation, object, procedure);
\r
1028 public void forHasStatement(Resource subject, Resource relation,
\r
1029 Resource object, Procedure<Boolean> procedure) {
\r
1030 graph.forHasStatement(subject, relation, object, procedure);
\r
1034 public void forHasStatement(Resource subject, Resource relation,
\r
1035 Resource object, SyncListener<Boolean> procedure) {
\r
1036 graph.forHasStatement(subject, relation, object, procedure);
\r
1040 public void forHasStatement(Resource subject, Resource relation,
\r
1041 Resource object, SyncProcedure<Boolean> procedure) {
\r
1042 graph.forHasStatement(subject, relation, object, procedure);
\r
1046 public void forHasStatement(Resource subject, Resource relation,
\r
1047 SyncListener<Boolean> procedure) {
\r
1048 graph.forHasStatement(subject, relation, procedure);
\r
1052 public void forHasStatement(Resource subject, Resource relation,
\r
1053 SyncProcedure<Boolean> procedure) {
\r
1054 graph.forHasStatement(subject, relation, procedure);
\r
1058 public void forHasStatement(Resource subject,
\r
1059 SyncListener<Boolean> procedure) {
\r
1060 graph.forHasStatement(subject, procedure);
\r
1064 public void forHasStatement(Resource subject,
\r
1065 SyncProcedure<Boolean> procedure) {
\r
1066 graph.forHasStatement(subject, procedure);
\r
1070 public void forHasValue(Resource subject,
\r
1071 AsyncListener<Boolean> procedure) {
\r
1072 graph.forHasValue(subject, procedure);
\r
1076 public void forHasValue(Resource subject,
\r
1077 AsyncProcedure<Boolean> procedure) {
\r
1078 graph.forHasValue(subject, procedure);
\r
1082 public void forHasValue(Resource subject, Listener<Boolean> procedure) {
\r
1083 graph.forHasValue(subject, procedure);
\r
1087 public void forHasValue(Resource subject, Procedure<Boolean> procedure) {
\r
1088 graph.forHasValue(subject, procedure);
\r
1092 public void forHasValue(Resource subject,
\r
1093 SyncListener<Boolean> procedure) {
\r
1094 graph.forHasValue(subject, procedure);
\r
1098 public void forHasValue(Resource subject,
\r
1099 SyncProcedure<Boolean> procedure) {
\r
1100 graph.forHasValue(subject, procedure);
\r
1104 public void forInverse(Resource relation,
\r
1105 AsyncListener<Resource> procedure) {
\r
1106 graph.forInverse(relation, procedure);
\r
1110 public <T> T getService(Class<T> api) throws ServiceNotFoundException {
\r
1111 return graph.getService(api);
\r
1115 public <T> T peekService(Class<T> api) {
\r
1116 return graph.peekService(api);
\r
1120 public boolean hasService(Class<?> api) {
\r
1121 return graph.hasService(api);
\r
1125 public <T> void registerService(Class<T> api, T service) {
\r
1126 graph.registerService(api, service);
\r
1130 public String getURI(Resource resource)
\r
1131 throws ValidationException,
\r
1132 ServiceException, AssumptionException {
\r
1133 return graph.getURI(resource);
\r
1137 public String getPossibleURI(Resource resource)
\r
1138 throws ValidationException,
\r
1139 ServiceException {
\r
1140 return graph.getPossibleURI(resource);
\r
1144 public Resource getResource(String uri)
\r
1145 throws ResourceNotFoundException, ValidationException,
\r
1146 ServiceException {
\r
1147 return graph.getResource(uri);
\r
1151 public Resource getPossibleResource(String uri)
\r
1152 throws ResourceNotFoundException, ValidationException,
\r
1153 ServiceException {
\r
1154 return graph.getPossibleResource(uri);
\r
1158 public Collection<Statement> getStatements(Resource subject,
\r
1159 Resource relation)
\r
1160 throws ManyObjectsForFunctionalRelationException,
\r
1161 ServiceException {
\r
1162 return graph.getStatements(subject, relation);
\r
1166 public Collection<Statement> getAssertedStatements(Resource subject,
\r
1167 Resource relation)
\r
1168 throws ManyObjectsForFunctionalRelationException,
\r
1169 ServiceException {
\r
1170 return graph.getAssertedStatements(subject, relation);
\r
1174 public Collection<Resource> getPredicates(Resource subject)
\r
1175 throws ServiceException {
\r
1176 return graph.getPredicates(subject);
\r
1180 public Collection<Resource> getPrincipalTypes(Resource subject)
\r
1181 throws ServiceException {
\r
1182 return graph.getPrincipalTypes(subject);
\r
1186 public Set<Resource> getTypes(Resource subject) throws ServiceException {
\r
1187 return graph.getTypes(subject);
\r
1191 public Set<Resource> getSupertypes(Resource subject)
\r
1192 throws ServiceException {
\r
1193 return graph.getSupertypes(subject);
\r
1197 public Set<Resource> getSuperrelations(Resource subject)
\r
1198 throws ServiceException {
\r
1199 return graph.getSuperrelations(subject);
\r
1203 // public Collection<Resource> getObjects(Resource subject,
\r
1204 // Resource relation)
\r
1205 // throws ManyObjectsForFunctionalRelationException,
\r
1206 // ServiceException {
\r
1207 // return graph.getObjects(subject, relation);
\r
1211 public Collection<Resource> getAssertedObjects(Resource subject,
\r
1212 Resource relation)
\r
1213 throws ManyObjectsForFunctionalRelationException,
\r
1214 ServiceException {
\r
1215 return graph.getAssertedObjects(subject, relation);
\r
1219 public Resource getInverse(Resource relation)
\r
1220 throws NoInverseException,
\r
1221 ManyObjectsForFunctionalRelationException, ServiceException {
\r
1222 return graph.getInverse(relation);
\r
1226 public Resource getSingleObject(Resource subject, Resource relation)
\r
1227 throws NoSingleResultException,
\r
1228 ManyObjectsForFunctionalRelationException, ServiceException {
\r
1229 return graph.getSingleObject(subject, relation);
\r
1233 public Statement getSingleStatement(Resource subject, Resource relation)
\r
1234 throws NoSingleResultException,
\r
1235 ManyObjectsForFunctionalRelationException, ServiceException {
\r
1236 return graph.getSingleStatement(subject, relation);
\r
1240 public Resource getSingleType(Resource subject)
\r
1241 throws NoSingleResultException, ServiceException {
\r
1242 return graph.getSingleType(subject);
\r
1246 public Resource getSingleType(Resource subject, Resource baseType)
\r
1247 throws NoSingleResultException, ServiceException {
\r
1248 return graph.getSingleType(subject, baseType);
\r
1252 public <T> T getValue(Resource subject)
\r
1253 throws DoesNotContainValueException, ServiceException {
\r
1254 return graph.getValue(subject);
\r
1258 public <T> T getValue(Resource subject, Binding binding)
\r
1259 throws DoesNotContainValueException, BindingException,
\r
1260 ServiceException {
\r
1261 return graph.getValue(subject, binding);
\r
1265 public <T> T getRelatedValue(Resource subject, Resource relation)
\r
1266 throws NoSingleResultException, DoesNotContainValueException,
\r
1267 ServiceException {
\r
1268 return graph.getRelatedValue(subject, relation);
\r
1272 public <T> T getRelatedValue(Resource subject, Resource relation,
\r
1273 Binding binding) throws NoSingleResultException,
\r
1274 DoesNotContainValueException, BindingException,
\r
1275 ServiceException {
\r
1276 return graph.getRelatedValue(subject, relation, binding);
\r
1280 public Resource getPossibleInverse(Resource relation)
\r
1281 throws ManyObjectsForFunctionalRelationException,
\r
1282 ServiceException {
\r
1283 return graph.getPossibleInverse(relation);
\r
1287 public Resource getPossibleObject(Resource subject, Resource relation)
\r
1288 throws ManyObjectsForFunctionalRelationException,
\r
1289 ServiceException {
\r
1290 return graph.getPossibleObject(subject, relation);
\r
1294 public Statement getPossibleStatement(Resource subject,
\r
1295 Resource relation)
\r
1296 throws ManyObjectsForFunctionalRelationException,
\r
1297 ServiceException {
\r
1298 return graph.getPossibleStatement(subject, relation);
\r
1302 public Resource getPossibleType(Resource subject, Resource baseType)
\r
1303 throws ServiceException {
\r
1304 return graph.getPossibleType(subject, baseType);
\r
1308 public <T> T getPossibleValue(Resource subject) throws ServiceException {
\r
1309 return graph.getPossibleValue(subject);
\r
1313 public <T> T getPossibleValue(Resource subject, Binding binding)
\r
1314 throws BindingException, ServiceException {
\r
1315 return graph.getPossibleValue(subject, binding);
\r
1319 public <T> T getPossibleRelatedValue(Resource subject, Resource relation)
\r
1320 throws ManyObjectsForFunctionalRelationException,
\r
1321 ServiceException {
\r
1322 return graph.getPossibleRelatedValue(subject, relation);
\r
1326 public <T> T getPossibleRelatedValue(Resource subject,
\r
1327 Resource relation, Binding binding)
\r
1328 throws ManyObjectsForFunctionalRelationException,
\r
1329 BindingException, ServiceException {
\r
1330 return graph.getPossibleRelatedValue(subject, relation, binding);
\r
1334 public <T> T getPossibleAdapter(Resource resource, Class<T> clazz)
\r
1335 throws ValidationException, ServiceException {
\r
1336 return graph.getPossibleAdapter(resource, clazz);
\r
1340 public <T> T getPossibleUniqueAdapter(Resource resource, Class<T> clazz)
\r
1341 throws ValidationException, ServiceException {
\r
1342 return graph.getPossibleUniqueAdapter(resource, clazz);
\r
1346 public boolean isInstanceOf(Resource resource, Resource type)
\r
1347 throws ServiceException {
\r
1348 return graph.isInstanceOf(resource, type);
\r
1352 public boolean isInheritedFrom(Resource resource, Resource type)
\r
1353 throws ServiceException {
\r
1354 return graph.isInheritedFrom(resource, type);
\r
1358 public boolean isSubrelationOf(Resource resource, Resource relation)
\r
1359 throws ServiceException {
\r
1360 return graph.isSubrelationOf(resource, relation);
\r
1364 public boolean hasStatement(Resource subject) throws ServiceException {
\r
1365 return graph.hasStatement(subject);
\r
1369 public boolean hasStatement(Resource subject, Resource relation)
\r
1370 throws ServiceException {
\r
1371 return graph.hasStatement(subject, relation);
\r
1375 public boolean hasStatement(Resource subject, Resource relation,
\r
1376 Resource object) throws ServiceException {
\r
1377 return graph.hasStatement(subject, relation, object);
\r
1381 public boolean hasValue(Resource subject) throws ServiceException {
\r
1382 return graph.hasValue(subject);
\r
1386 public Datatype getDataType(Resource subject) throws DatabaseException {
\r
1387 return graph.getDataType(subject);
\r
1391 public <T extends Accessor> T getAccessor(Resource subject)
\r
1392 throws DatabaseException {
\r
1393 return graph.getAccessor(subject);
\r
1397 public RandomAccessBinary getRandomAccessBinary(Resource subject)
\r
1398 throws DatabaseException {
\r
1399 return graph.getRandomAccessBinary(subject);
\r
1403 public <T> T syncRequest(Read<T> request) throws DatabaseException {
\r
1404 return graph.syncRequest(request);
\r
1408 public <T> T syncRequest(Read<T> request, AsyncListener<T> procedure)
\r
1409 throws DatabaseException {
\r
1410 return graph.syncRequest(request, procedure);
\r
1414 public <T> T syncRequest(Read<T> request, SyncListener<T> procedure)
\r
1415 throws DatabaseException {
\r
1416 return graph.syncRequest(request, procedure);
\r
1420 public <T> T syncRequest(Read<T> request, Listener<T> procedure)
\r
1421 throws DatabaseException {
\r
1422 return graph.syncRequest(request, procedure);
\r
1426 public <T> T syncRequest(Read<T> request, AsyncProcedure<T> procedure)
\r
1427 throws DatabaseException {
\r
1428 return graph.syncRequest(request, procedure);
\r
1432 public <T> T syncRequest(Read<T> request, SyncProcedure<T> procedure)
\r
1433 throws DatabaseException {
\r
1434 return graph.syncRequest(request, procedure);
\r
1438 public <T> T syncRequest(Read<T> request, Procedure<T> procedure)
\r
1439 throws DatabaseException {
\r
1440 return graph.syncRequest(request, procedure);
\r
1444 public <T> T syncRequest(AsyncRead<T> request) throws DatabaseException {
\r
1445 return graph.syncRequest(request);
\r
1449 public <T> T syncRequest(AsyncRead<T> request,
\r
1450 AsyncListener<T> procedure) throws DatabaseException {
\r
1451 return graph.syncRequest(request, procedure);
\r
1455 public <T> T syncRequest(AsyncRead<T> request, SyncListener<T> procedure)
\r
1456 throws DatabaseException {
\r
1457 return graph.syncRequest(request, procedure);
\r
1461 public <T> T syncRequest(AsyncRead<T> request, Listener<T> procedure)
\r
1462 throws DatabaseException {
\r
1463 return graph.syncRequest(request, procedure);
\r
1467 public <T> T syncRequest(AsyncRead<T> request,
\r
1468 AsyncProcedure<T> procedure) throws DatabaseException {
\r
1469 return graph.syncRequest(request, procedure);
\r
1473 public <T> T syncRequest(AsyncRead<T> request,
\r
1474 SyncProcedure<T> procedure) throws DatabaseException {
\r
1475 return graph.syncRequest(request, procedure);
\r
1479 public <T> T syncRequest(AsyncRead<T> request, Procedure<T> procedure)
\r
1480 throws DatabaseException {
\r
1481 return graph.syncRequest(request, procedure);
\r
1485 public <T> Collection<T> syncRequest(MultiRead<T> request)
\r
1486 throws DatabaseException {
\r
1487 return graph.syncRequest(request);
\r
1491 public <T> Collection<T> syncRequest(MultiRead<T> request,
\r
1492 AsyncMultiListener<T> procedure) throws DatabaseException {
\r
1493 return graph.syncRequest(request, procedure);
\r
1497 public <T> Collection<T> syncRequest(MultiRead<T> request,
\r
1498 SyncMultiListener<T> procedure) throws DatabaseException {
\r
1499 return graph.syncRequest(request, procedure);
\r
1503 public <T> Collection<T> syncRequest(MultiRead<T> request,
\r
1504 MultiListener<T> procedure) throws DatabaseException {
\r
1505 return graph.syncRequest(request, procedure);
\r
1509 public <T> Collection<T> syncRequest(MultiRead<T> request,
\r
1510 AsyncMultiProcedure<T> procedure) throws DatabaseException {
\r
1511 return graph.syncRequest(request, procedure);
\r
1515 public <T> Collection<T> syncRequest(MultiRead<T> request,
\r
1516 SyncMultiProcedure<T> procedure) throws DatabaseException {
\r
1517 return graph.syncRequest(request, procedure);
\r
1521 public <T> Collection<T> syncRequest(MultiRead<T> request,
\r
1522 MultiProcedure<T> procedure) throws DatabaseException {
\r
1523 return graph.syncRequest(request, procedure);
\r
1527 public <T> Collection<T> syncRequest(AsyncMultiRead<T> request)
\r
1528 throws DatabaseException {
\r
1529 return graph.syncRequest(request);
\r
1533 public <T> Collection<T> syncRequest(AsyncMultiRead<T> request,
\r
1534 AsyncMultiListener<T> procedure) throws DatabaseException {
\r
1535 return graph.syncRequest(request, procedure);
\r
1539 public <T> Collection<T> syncRequest(AsyncMultiRead<T> request,
\r
1540 SyncMultiListener<T> procedure) throws DatabaseException {
\r
1541 return graph.syncRequest(request, procedure);
\r
1545 public <T> Collection<T> syncRequest(AsyncMultiRead<T> request,
\r
1546 MultiListener<T> procedure) throws DatabaseException {
\r
1547 return graph.syncRequest(request, procedure);
\r
1551 public <T> Collection<T> syncRequest(AsyncMultiRead<T> request,
\r
1552 AsyncMultiProcedure<T> procedure) throws DatabaseException {
\r
1553 return graph.syncRequest(request, procedure);
\r
1557 public <T> Collection<T> syncRequest(AsyncMultiRead<T> request,
\r
1558 SyncMultiProcedure<T> procedure) throws DatabaseException {
\r
1559 return graph.syncRequest(request, procedure);
\r
1563 public <T> Collection<T> syncRequest(AsyncMultiRead<T> request,
\r
1564 MultiProcedure<T> procedure) throws DatabaseException {
\r
1565 return graph.syncRequest(request, procedure);
\r
1569 public <T> T syncRequest(ExternalRead<T> request)
\r
1570 throws DatabaseException {
\r
1571 return graph.syncRequest(request);
\r
1575 public <T> T syncRequest(ExternalRead<T> request, Listener<T> procedure)
\r
1576 throws DatabaseException {
\r
1577 return graph.syncRequest(request, procedure);
\r
1581 public <T> T syncRequest(ExternalRead<T> request, Procedure<T> procedure)
\r
1582 throws DatabaseException {
\r
1583 return graph.syncRequest(request, procedure);
\r
1587 public void syncRequest(Write request) throws DatabaseException {
\r
1588 graph.syncRequest(request);
\r
1592 public void syncRequest(DelayedWrite request) throws DatabaseException {
\r
1593 graph.syncRequest(request);
\r
1597 public void syncRequest(WriteOnly r) throws DatabaseException {
\r
1598 graph.syncRequest(r);
\r
1602 public <T> T syncRequest(WriteResult<T> request)
\r
1603 throws DatabaseException {
\r
1604 return graph.syncRequest(request);
\r
1608 public <T> T syncRequest(DelayedWriteResult<T> request)
\r
1609 throws DatabaseException {
\r
1610 return graph.syncRequest(request);
\r
1614 public <T> T syncRequest(WriteOnlyResult<T> r) throws DatabaseException {
\r
1615 return graph.syncRequest(r);
\r
1619 public void forURI(Resource resource, AsyncListener<String> procedure) {
\r
1620 graph.forURI(resource, procedure);
\r
1624 public void forURI(Resource resource, SyncListener<String> procedure) {
\r
1625 graph.forURI(resource, procedure);
\r
1629 public void forURI(Resource resource, Listener<String> procedure) {
\r
1630 graph.forURI(resource, procedure);
\r
1634 public void forURI(Resource resource, AsyncProcedure<String> procedure) {
\r
1635 graph.forURI(resource, procedure);
\r
1639 public void forURI(Resource resource, SyncProcedure<String> procedure) {
\r
1640 graph.forURI(resource, procedure);
\r
1644 public void forURI(Resource resource, Procedure<String> procedure) {
\r
1645 graph.forURI(resource, procedure);
\r
1649 public void forResource(String id, AsyncListener<Resource> procedure) {
\r
1650 graph.forResource(id, procedure);
\r
1654 public void forResource(String id, SyncListener<Resource> procedure) {
\r
1655 graph.forResource(id, procedure);
\r
1659 public void forResource(String id, Listener<Resource> procedure) {
\r
1660 graph.forResource(id, procedure);
\r
1664 public void forResource(String id, AsyncProcedure<Resource> procedure) {
\r
1665 graph.forResource(id, procedure);
\r
1669 public void forResource(String id, SyncProcedure<Resource> procedure) {
\r
1670 graph.forResource(id, procedure);
\r
1674 public void forResource(String id, Procedure<Resource> procedure) {
\r
1675 graph.forResource(id, procedure);
\r
1679 public void forStatementSet(Resource subject, Resource relation,
\r
1680 AsyncSetListener<Statement> procedure) {
\r
1681 graph.forStatementSet(subject, relation, procedure);
\r
1685 public void forStatementSet(Resource subject, Resource relation,
\r
1686 SyncSetListener<Statement> procedure) {
\r
1687 graph.forStatementSet(subject, relation, procedure);
\r
1691 public void forStatementSet(Resource subject, Resource relation,
\r
1692 SetListener<Statement> procedure) {
\r
1693 graph.forStatementSet(subject, relation, procedure);
\r
1697 public void forPredicateSet(Resource subject,
\r
1698 AsyncSetListener<Resource> procedure) {
\r
1699 graph.forPredicateSet(subject, procedure);
\r
1703 public void forPredicateSet(Resource subject,
\r
1704 SyncSetListener<Resource> procedure) {
\r
1705 graph.forPredicateSet(subject, procedure);
\r
1709 public void forPredicateSet(Resource subject,
\r
1710 SetListener<Resource> procedure) {
\r
1711 graph.forPredicateSet(subject, procedure);
\r
1715 public void forPrincipalTypeSet(Resource subject,
\r
1716 AsyncSetListener<Resource> procedure) {
\r
1717 graph.forPrincipalTypeSet(subject, procedure);
\r
1721 public void forPrincipalTypeSet(Resource subject,
\r
1722 SyncSetListener<Resource> procedure) {
\r
1723 graph.forPrincipalTypeSet(subject, procedure);
\r
1727 public void forPrincipalTypeSet(Resource subject,
\r
1728 SetListener<Resource> procedure) {
\r
1729 graph.forPrincipalTypeSet(subject, procedure);
\r
1733 public void forTypes(Resource subject,
\r
1734 AsyncListener<Set<Resource>> procedure) {
\r
1735 graph.forTypes(subject, procedure);
\r
1739 public void forTypes(Resource subject,
\r
1740 SyncListener<Set<Resource>> procedure) {
\r
1741 graph.forTypes(subject, procedure);
\r
1745 public void forTypes(Resource subject, Listener<Set<Resource>> procedure) {
\r
1746 graph.forTypes(subject, procedure);
\r
1750 public void forTypes(Resource subject,
\r
1751 AsyncProcedure<Set<Resource>> procedure) {
\r
1752 graph.forTypes(subject, procedure);
\r
1756 public void forTypes(Resource subject,
\r
1757 SyncProcedure<Set<Resource>> procedure) {
\r
1758 graph.forTypes(subject, procedure);
\r
1762 public void forTypes(Resource subject,
\r
1763 Procedure<Set<Resource>> procedure) {
\r
1764 graph.forTypes(subject, procedure);
\r
1768 public void forSupertypes(Resource subject,
\r
1769 AsyncListener<Set<Resource>> procedure) {
\r
1770 graph.forSupertypes(subject, procedure);
\r
1774 public void forSupertypes(Resource subject,
\r
1775 SyncListener<Set<Resource>> procedure) {
\r
1776 graph.forSupertypes(subject, procedure);
\r
1780 public void forSupertypes(Resource subject,
\r
1781 Listener<Set<Resource>> procedure) {
\r
1782 graph.forSupertypes(subject, procedure);
\r
1786 public void forSupertypes(Resource subject,
\r
1787 AsyncProcedure<Set<Resource>> procedure) {
\r
1788 graph.forSupertypes(subject, procedure);
\r
1792 public void forSupertypes(Resource subject,
\r
1793 SyncProcedure<Set<Resource>> procedure) {
\r
1794 graph.forSupertypes(subject, procedure);
\r
1798 public void forSupertypes(Resource subject,
\r
1799 Procedure<Set<Resource>> procedure) {
\r
1800 graph.forSupertypes(subject, procedure);
\r
1804 public void forPossibleSuperrelation(Resource subject,
\r
1805 AsyncProcedure<Resource> procedure) {
\r
1806 graph.forPossibleSuperrelation(subject, procedure);
\r
1810 public void forSuperrelations(Resource subject,
\r
1811 AsyncListener<Set<Resource>> procedure) {
\r
1812 graph.forSuperrelations(subject, procedure);
\r
1816 public void forSuperrelations(Resource subject,
\r
1817 SyncListener<Set<Resource>> procedure) {
\r
1818 graph.forSuperrelations(subject, procedure);
\r
1822 public void forSuperrelations(Resource subject,
\r
1823 Listener<Set<Resource>> procedure) {
\r
1824 graph.forSuperrelations(subject, procedure);
\r
1828 public void forSuperrelations(Resource subject,
\r
1829 AsyncProcedure<Set<Resource>> procedure) {
\r
1830 graph.forSuperrelations(subject, procedure);
\r
1834 public void forSuperrelations(Resource subject,
\r
1835 SyncProcedure<Set<Resource>> procedure) {
\r
1836 graph.forSuperrelations(subject, procedure);
\r
1840 public void forSuperrelations(Resource subject,
\r
1841 Procedure<Set<Resource>> procedure) {
\r
1842 graph.forSuperrelations(subject, procedure);
\r
1846 public void forObjectSet(Resource subject, Resource relation,
\r
1847 AsyncSetListener<Resource> procedure) {
\r
1848 graph.forObjectSet(subject, relation, procedure);
\r
1852 public void forObjectSet(Resource subject, Resource relation,
\r
1853 SyncSetListener<Resource> procedure) {
\r
1854 graph.forObjectSet(subject, relation, procedure);
\r
1858 public void forObjectSet(Resource subject, Resource relation,
\r
1859 SetListener<Resource> procedure) {
\r
1860 graph.forObjectSet(subject, relation, procedure);
\r
1864 public void forInverse(Resource relation,
\r
1865 SyncListener<Resource> procedure) {
\r
1866 graph.forInverse(relation, procedure);
\r
1870 public void forInverse(Resource relation, Listener<Resource> procedure) {
\r
1871 graph.forInverse(relation, procedure);
\r
1875 public void forInverse(Resource relation,
\r
1876 AsyncProcedure<Resource> procedure) {
\r
1877 graph.forInverse(relation, procedure);
\r
1881 public void forInverse(Resource relation,
\r
1882 SyncProcedure<Resource> procedure) {
\r
1883 graph.forInverse(relation, procedure);
\r
1887 public void forInverse(Resource relation, Procedure<Resource> procedure) {
\r
1888 graph.forInverse(relation, procedure);
\r
1892 public void forSingleObject(Resource subject, Resource relation,
\r
1893 AsyncListener<Resource> procedure) {
\r
1894 graph.forSingleObject(subject, relation, procedure);
\r
1898 public void forSingleObject(Resource subject, Resource relation,
\r
1899 SyncListener<Resource> procedure) {
\r
1900 graph.forSingleObject(subject, relation, procedure);
\r
1904 public void forSingleObject(Resource subject, Resource relation,
\r
1905 Listener<Resource> procedure) {
\r
1906 graph.forSingleObject(subject, relation, procedure);
\r
1910 public void forSingleObject(Resource subject, Resource relation,
\r
1911 AsyncProcedure<Resource> procedure) {
\r
1912 graph.forSingleObject(subject, relation, procedure);
\r
1916 public void forSingleObject(Resource subject, Resource relation,
\r
1917 SyncProcedure<Resource> procedure) {
\r
1918 graph.forSingleObject(subject, relation, procedure);
\r
1922 public void forSingleObject(Resource subject, Resource relation,
\r
1923 Procedure<Resource> procedure) {
\r
1924 graph.forSingleObject(subject, relation, procedure);
\r
1928 public void forSingleStatement(Resource subject, Resource relation,
\r
1929 AsyncListener<Statement> procedure) {
\r
1930 graph.forSingleStatement(subject, relation, procedure);
\r
1934 public void forSingleStatement(Resource subject, Resource relation,
\r
1935 SyncListener<Statement> procedure) {
\r
1936 graph.forSingleStatement(subject, relation, procedure);
\r
1940 public void forSingleStatement(Resource subject, Resource relation,
\r
1941 Listener<Statement> procedure) {
\r
1942 graph.forSingleStatement(subject, relation, procedure);
\r
1946 public void forSingleStatement(Resource subject, Resource relation,
\r
1947 AsyncProcedure<Statement> procedure) {
\r
1948 graph.forSingleStatement(subject, relation, procedure);
\r
1952 public void forSingleStatement(Resource subject, Resource relation,
\r
1953 SyncProcedure<Statement> procedure) {
\r
1954 graph.forSingleStatement(subject, relation, procedure);
\r
1958 public void forSingleStatement(Resource subject, Resource relation,
\r
1959 Procedure<Statement> procedure) {
\r
1960 graph.forSingleStatement(subject, relation, procedure);
\r
1964 public void forSingleType(Resource subject,
\r
1965 AsyncListener<Resource> procedure) {
\r
1966 graph.forSingleType(subject, procedure);
\r
1970 public void forSingleType(Resource subject,
\r
1971 SyncListener<Resource> procedure) {
\r
1972 graph.forSingleType(subject, procedure);
\r
1976 public void forSingleType(Resource subject, Listener<Resource> procedure) {
\r
1977 graph.forSingleType(subject, procedure);
\r
1981 public void forSingleType(Resource subject,
\r
1982 AsyncProcedure<Resource> procedure) {
\r
1983 graph.forSingleType(subject, procedure);
\r
1987 public void forSingleType(Resource subject,
\r
1988 SyncProcedure<Resource> procedure) {
\r
1989 graph.forSingleType(subject, procedure);
\r
1993 public void forSingleType(Resource subject,
\r
1994 Procedure<Resource> procedure) {
\r
1995 graph.forSingleType(subject, procedure);
\r
1999 public void forSingleType(Resource subject, Resource baseType,
\r
2000 AsyncListener<Resource> procedure) {
\r
2001 graph.forSingleType(subject, baseType, procedure);
\r
2005 public void forSingleType(Resource subject, Resource baseType,
\r
2006 SyncListener<Resource> procedure) {
\r
2007 graph.forSingleType(subject, baseType, procedure);
\r
2011 public void forSingleType(Resource subject, Resource baseType,
\r
2012 Listener<Resource> procedure) {
\r
2013 graph.forSingleType(subject, baseType, procedure);
\r
2017 public void forSingleType(Resource subject, Resource baseType,
\r
2018 AsyncProcedure<Resource> procedure) {
\r
2019 graph.forSingleType(subject, baseType, procedure);
\r
2023 public void forSingleType(Resource subject, Resource baseType,
\r
2024 SyncProcedure<Resource> procedure) {
\r
2025 graph.forSingleType(subject, baseType, procedure);
\r
2029 public void forSingleType(Resource subject, Resource baseType,
\r
2030 Procedure<Resource> procedure) {
\r
2031 graph.forSingleType(subject, baseType, procedure);
\r
2035 public <T> void forValue(Resource subject, AsyncListener<T> procedure) {
\r
2036 graph.forValue(subject, procedure);
\r
2040 public <T> void forValue(Resource subject, SyncListener<T> procedure) {
\r
2041 graph.forValue(subject, procedure);
\r
2045 public <T> void forValue(Resource subject, Listener<T> procedure) {
\r
2046 graph.forValue(subject, procedure);
\r
2050 public <T> void forValue(Resource subject, AsyncProcedure<T> procedure) {
\r
2051 graph.forValue(subject, procedure);
\r
2055 public <T> void forValue(Resource subject, SyncProcedure<T> procedure) {
\r
2056 graph.forValue(subject, procedure);
\r
2060 public <T> void forValue(Resource subject, Procedure<T> procedure) {
\r
2061 graph.forValue(subject, procedure);
\r
2065 public <T> void forValue(Resource subject, Binding binding,
\r
2066 AsyncListener<T> procedure) {
\r
2067 graph.forValue(subject, binding, procedure);
\r
2071 public <T> void forValue(Resource subject, Binding binding,
\r
2072 SyncListener<T> procedure) {
\r
2073 graph.forValue(subject, binding, procedure);
\r
2077 public <T> void forValue(Resource subject, Binding binding,
\r
2078 Listener<T> procedure) {
\r
2079 graph.forValue(subject, binding, procedure);
\r
2083 public <T> void forValue(Resource subject, Binding binding,
\r
2084 AsyncProcedure<T> procedure) {
\r
2085 graph.forValue(subject, binding, procedure);
\r
2089 public <T> void forValue(Resource subject, Binding binding,
\r
2090 SyncProcedure<T> procedure) {
\r
2091 graph.forValue(subject, binding, procedure);
\r
2095 public <T> void forValue(Resource subject, Binding binding,
\r
2096 Procedure<T> procedure) {
\r
2097 graph.forValue(subject, binding, procedure);
\r
2101 public <T> void forRelatedValue(Resource subject, Resource relation,
\r
2102 AsyncListener<T> procedure) {
\r
2103 graph.forRelatedValue(subject, relation, procedure);
\r
2107 public <T> void forRelatedValue(Resource subject, Resource relation,
\r
2108 SyncListener<T> procedure) {
\r
2109 graph.forRelatedValue(subject, relation, procedure);
\r
2113 public <T> void forRelatedValue(Resource subject, Resource relation,
\r
2114 Listener<T> procedure) {
\r
2115 graph.forRelatedValue(subject, relation, procedure);
\r
2119 public <T> void forRelatedValue(Resource subject, Resource relation,
\r
2120 AsyncProcedure<T> procedure) {
\r
2121 graph.forRelatedValue(subject, relation, procedure);
\r
2125 public <T> void forRelatedValue(Resource subject, Resource relation,
\r
2126 SyncProcedure<T> procedure) {
\r
2127 graph.forRelatedValue(subject, relation, procedure);
\r
2131 public <T> void forRelatedValue(Resource subject, Resource relation,
\r
2132 Procedure<T> procedure) {
\r
2133 graph.forRelatedValue(subject, relation, procedure);
\r
2137 public <T> void forRelatedValue(Resource subject, Resource relation,
\r
2138 Binding binding, AsyncListener<T> procedure) {
\r
2139 graph.forRelatedValue(subject, relation, binding, procedure);
\r
2143 public <T> void forRelatedValue(Resource subject, Resource relation,
\r
2144 Binding binding, SyncListener<T> procedure) {
\r
2145 graph.forRelatedValue(subject, relation, binding, procedure);
\r
2149 public <T> void forRelatedValue(Resource subject, Resource relation,
\r
2150 Binding binding, Listener<T> procedure) {
\r
2151 graph.forRelatedValue(subject, relation, binding, procedure);
\r
2155 public <T> void forRelatedValue(Resource subject, Resource relation,
\r
2156 Binding binding, AsyncProcedure<T> procedure) {
\r
2157 graph.forRelatedValue(subject, relation, binding, procedure);
\r
2161 public <T> void forRelatedValue(Resource subject, Resource relation,
\r
2162 Binding binding, SyncProcedure<T> procedure) {
\r
2163 graph.forRelatedValue(subject, relation, binding, procedure);
\r
2167 public <T> void forRelatedValue(Resource subject, Resource relation,
\r
2168 Binding binding, Procedure<T> procedure) {
\r
2169 graph.forRelatedValue(subject, relation, binding, procedure);
\r
2173 public <T> void forUniqueAdapted(Resource resource, Class<T> clazz,
\r
2174 AsyncListener<T> procedure) {
\r
2175 graph.forUniqueAdapted(resource, clazz, procedure);
\r
2179 public <T> void forUniqueAdapted(Resource resource, Class<T> clazz,
\r
2180 SyncListener<T> procedure) {
\r
2181 graph.forUniqueAdapted(resource, clazz, procedure);
\r
2185 public <T> void forUniqueAdapted(Resource resource, Class<T> clazz,
\r
2186 Listener<T> procedure) {
\r
2187 graph.forUniqueAdapted(resource, clazz, procedure);
\r
2191 public <T> void forUniqueAdapted(Resource resource, Class<T> clazz,
\r
2192 AsyncProcedure<T> procedure) {
\r
2193 graph.forUniqueAdapted(resource, clazz, procedure);
\r
2197 public <T> void forUniqueAdapted(Resource resource, Class<T> clazz,
\r
2198 SyncProcedure<T> procedure) {
\r
2199 graph.forUniqueAdapted(resource, clazz, procedure);
\r
2203 public <T> void forUniqueAdapted(Resource resource, Class<T> clazz,
\r
2204 Procedure<T> procedure) {
\r
2205 graph.forUniqueAdapted(resource, clazz, procedure);
\r
2209 public void forPossibleInverse(Resource relation,
\r
2210 AsyncListener<Resource> procedure) {
\r
2211 graph.forPossibleInverse(relation, procedure);
\r
2215 public void forPossibleInverse(Resource relation,
\r
2216 SyncListener<Resource> procedure) {
\r
2217 graph.forPossibleInverse(relation, procedure);
\r
2221 public void forPossibleInverse(Resource relation,
\r
2222 Listener<Resource> procedure) {
\r
2223 graph.forPossibleInverse(relation, procedure);
\r
2227 public void forPossibleInverse(Resource relation,
\r
2228 AsyncProcedure<Resource> procedure) {
\r
2229 graph.forPossibleInverse(relation, procedure);
\r
2233 public void forPossibleInverse(Resource relation,
\r
2234 SyncProcedure<Resource> procedure) {
\r
2235 graph.forPossibleInverse(relation, procedure);
\r
2239 public void forPossibleInverse(Resource relation,
\r
2240 Procedure<Resource> procedure) {
\r
2241 graph.forPossibleInverse(relation, procedure);
\r
2245 public void forPossibleObject(Resource subject, Resource relation,
\r
2246 AsyncListener<Resource> procedure) {
\r
2247 graph.forPossibleObject(subject, relation, procedure);
\r
2251 public void forPossibleObject(Resource subject, Resource relation,
\r
2252 SyncListener<Resource> procedure) {
\r
2253 graph.forPossibleObject(subject, relation, procedure);
\r
2257 public void forPossibleObject(Resource subject, Resource relation,
\r
2258 Listener<Resource> procedure) {
\r
2259 graph.forPossibleObject(subject, relation, procedure);
\r
2263 public void forPossibleObject(Resource subject, Resource relation,
\r
2264 AsyncProcedure<Resource> procedure) {
\r
2265 graph.forPossibleObject(subject, relation, procedure);
\r
2269 public void forPossibleObject(Resource subject, Resource relation,
\r
2270 SyncProcedure<Resource> procedure) {
\r
2271 graph.forPossibleObject(subject, relation, procedure);
\r
2275 public void forPossibleObject(Resource subject, Resource relation,
\r
2276 Procedure<Resource> procedure) {
\r
2277 graph.forPossibleObject(subject, relation, procedure);
\r
2281 public void forPossibleStatement(Resource subject, Resource relation,
\r
2282 AsyncListener<Statement> procedure) {
\r
2283 graph.forPossibleStatement(subject, relation, procedure);
\r
2287 public void forPossibleStatement(Resource subject, Resource relation,
\r
2288 SyncListener<Statement> procedure) {
\r
2289 graph.forPossibleStatement(subject, relation, procedure);
\r
2293 public void forPossibleStatement(Resource subject, Resource relation,
\r
2294 Listener<Statement> procedure) {
\r
2295 graph.forPossibleStatement(subject, relation, procedure);
\r
2299 public void forPossibleStatement(Resource subject, Resource relation,
\r
2300 AsyncProcedure<Statement> procedure) {
\r
2301 graph.forPossibleStatement(subject, relation, procedure);
\r
2305 public void forPossibleStatement(Resource subject, Resource relation,
\r
2306 SyncProcedure<Statement> procedure) {
\r
2307 graph.forPossibleStatement(subject, relation, procedure);
\r
2311 public void forPossibleStatement(Resource subject, Resource relation,
\r
2312 Procedure<Statement> procedure) {
\r
2313 graph.forPossibleStatement(subject, relation, procedure);
\r
2317 public void forPossibleType(Resource subject, Resource baseType,
\r
2318 AsyncListener<Resource> procedure) {
\r
2319 graph.forPossibleType(subject, baseType, procedure);
\r
2323 public void forPossibleType(Resource subject, Resource baseType,
\r
2324 SyncListener<Resource> procedure) {
\r
2325 graph.forPossibleType(subject, baseType, procedure);
\r
2329 public void forPossibleType(Resource subject, Resource baseType,
\r
2330 Listener<Resource> procedure) {
\r
2331 graph.forPossibleType(subject, baseType, procedure);
\r
2335 public void forPossibleType(Resource subject, Resource baseType,
\r
2336 AsyncProcedure<Resource> procedure) {
\r
2337 graph.forPossibleType(subject, baseType, procedure);
\r
2341 public void forPossibleType(Resource subject, Resource baseType,
\r
2342 SyncProcedure<Resource> procedure) {
\r
2343 graph.forPossibleType(subject, baseType, procedure);
\r
2347 public void forPossibleType(Resource subject, Resource baseType,
\r
2348 Procedure<Resource> procedure) {
\r
2349 graph.forPossibleType(subject, baseType, procedure);
\r
2353 public <T> void forPossibleValue(Resource subject,
\r
2354 AsyncListener<T> procedure) {
\r
2355 graph.forPossibleValue(subject, procedure);
\r
2359 public <T> void forPossibleValue(Resource subject,
\r
2360 SyncListener<T> procedure) {
\r
2361 graph.forPossibleValue(subject, procedure);
\r
2365 public <T> void forPossibleValue(Resource subject, Listener<T> procedure) {
\r
2366 graph.forPossibleValue(subject, procedure);
\r
2370 public <T> void forPossibleValue(Resource subject,
\r
2371 AsyncProcedure<T> procedure) {
\r
2372 graph.forPossibleValue(subject, procedure);
\r
2376 public <T> void forPossibleValue(Resource subject,
\r
2377 SyncProcedure<T> procedure) {
\r
2378 graph.forPossibleValue(subject, procedure);
\r
2382 public <T> void forPossibleValue(Resource subject,
\r
2383 Procedure<T> procedure) {
\r
2384 graph.forPossibleValue(subject, procedure);
\r
2388 public <T> void forPossibleValue(Resource subject, Binding binding,
\r
2389 AsyncListener<T> procedure) {
\r
2390 graph.forPossibleValue(subject, procedure);
\r
2394 public <T> void forPossibleValue(Resource subject, Binding binding,
\r
2395 SyncListener<T> procedure) {
\r
2396 graph.forPossibleValue(subject, procedure);
\r
2400 public <T> void forPossibleValue(Resource subject, Binding binding,
\r
2401 Listener<T> procedure) {
\r
2402 graph.forPossibleValue(subject, procedure);
\r
2406 public <T> void forPossibleValue(Resource subject, Binding binding,
\r
2407 AsyncProcedure<T> procedure) {
\r
2408 graph.forPossibleValue(subject, procedure);
\r
2412 public <T> void forPossibleValue(Resource subject, Binding binding,
\r
2413 SyncProcedure<T> procedure) {
\r
2414 graph.forPossibleValue(subject, procedure);
\r
2418 public <T> void forPossibleValue(Resource subject, Binding binding,
\r
2419 Procedure<T> procedure) {
\r
2420 graph.forPossibleValue(subject, procedure);
\r
2424 public <T> void forPossibleRelatedValue(Resource subject,
\r
2425 Resource relation, AsyncListener<T> procedure) {
\r
2426 graph.forPossibleRelatedValue(subject, relation, procedure);
\r
2430 public <T> void forPossibleRelatedValue(Resource subject,
\r
2431 Resource relation, SyncListener<T> procedure) {
\r
2432 graph.forPossibleRelatedValue(subject, relation, procedure);
\r
2436 public <T> void forPossibleRelatedValue(Resource subject,
\r
2437 Resource relation, Listener<T> procedure) {
\r
2438 graph.forPossibleRelatedValue(subject, relation, procedure);
\r
2442 public <T> void forPossibleRelatedValue(Resource subject,
\r
2443 Resource relation, AsyncProcedure<T> procedure) {
\r
2444 graph.forPossibleRelatedValue(subject, relation, procedure);
\r
2448 public <T> void forPossibleRelatedValue(Resource subject,
\r
2449 Resource relation, SyncProcedure<T> procedure) {
\r
2450 graph.forPossibleRelatedValue(subject, relation, procedure);
\r
2454 public <T> void forPossibleRelatedValue(Resource subject,
\r
2455 Resource relation, Procedure<T> procedure) {
\r
2456 graph.forPossibleRelatedValue(subject, relation, procedure);
\r
2460 public <T> void forPossibleRelatedValue(Resource subject,
\r
2461 Resource relation, Binding binding, AsyncListener<T> procedure) {
\r
2462 graph.forPossibleRelatedValue(subject, relation, binding, procedure);
\r
2466 public <T> void forPossibleRelatedValue(Resource subject,
\r
2467 Resource relation, Binding binding, SyncListener<T> procedure) {
\r
2468 graph.forPossibleRelatedValue(subject, relation, procedure);
\r
2472 public <T> void forPossibleRelatedValue(Resource subject,
\r
2473 Resource relation, Binding binding, Listener<T> procedure) {
\r
2474 graph.forPossibleRelatedValue(subject, relation, binding, procedure);
\r
2478 public <T> void forPossibleRelatedValue(Resource subject,
\r
2479 Resource relation, Binding binding, AsyncProcedure<T> procedure) {
\r
2480 graph.forPossibleRelatedValue(subject, relation, binding, procedure);
\r
2484 public <T> void forPossibleRelatedValue(Resource subject,
\r
2485 Resource relation, Binding binding, SyncProcedure<T> procedure) {
\r
2486 graph.forPossibleRelatedValue(subject, relation, binding, procedure);
\r
2490 public <T> void forPossibleRelatedValue(Resource subject,
\r
2491 Resource relation, Binding binding, Procedure<T> procedure) {
\r
2492 graph.forPossibleRelatedValue(subject, relation, binding, procedure);
\r
2496 public <T> void forPossibleAdapted(Resource resource, Class<T> clazz,
\r
2497 AsyncListener<T> procedure) {
\r
2498 graph.forPossibleAdapted(resource, clazz, procedure);
\r
2502 public <T> void forPossibleAdapted(Resource resource, Class<T> clazz,
\r
2503 SyncListener<T> procedure) {
\r
2504 graph.forPossibleAdapted(resource, clazz, procedure);
\r
2508 public <T> void forPossibleAdapted(Resource resource, Class<T> clazz,
\r
2509 Listener<T> procedure) {
\r
2510 graph.forPossibleAdapted(resource, clazz, procedure);
\r
2514 public <T> void forPossibleAdapted(Resource resource, Class<T> clazz,
\r
2515 AsyncProcedure<T> procedure) {
\r
2516 graph.forPossibleAdapted(resource, clazz, procedure);
\r
2520 public <T> void forPossibleAdapted(Resource resource, Class<T> clazz,
\r
2521 SyncProcedure<T> procedure) {
\r
2522 graph.forPossibleAdapted(resource, clazz, procedure);
\r
2526 public <T> void forPossibleAdapted(Resource resource, Class<T> clazz,
\r
2527 Procedure<T> procedure) {
\r
2528 graph.forPossibleAdapted(resource, clazz, procedure);
\r
2532 public <T> void forPossibleUniqueAdapted(Resource resource,
\r
2533 Class<T> clazz, AsyncListener<T> procedure) {
\r
2534 graph.forPossibleUniqueAdapted(resource, clazz, procedure);
\r
2538 public <T> void forPossibleUniqueAdapted(Resource resource,
\r
2539 Class<T> clazz, SyncListener<T> procedure) {
\r
2540 graph.forPossibleUniqueAdapted(resource, clazz, procedure);
\r
2544 public <T> void forPossibleUniqueAdapted(Resource resource,
\r
2545 Class<T> clazz, Listener<T> procedure) {
\r
2546 graph.forPossibleUniqueAdapted(resource, clazz, procedure);
\r
2550 public <T> void forPossibleUniqueAdapted(Resource resource,
\r
2551 Class<T> clazz, AsyncProcedure<T> procedure) {
\r
2552 graph.forPossibleUniqueAdapted(resource, clazz, procedure);
\r
2556 public <T> void forPossibleUniqueAdapted(Resource resource,
\r
2557 Class<T> clazz, SyncProcedure<T> procedure) {
\r
2558 graph.forPossibleUniqueAdapted(resource, clazz, procedure);
\r
2562 public <T> void forPossibleUniqueAdapted(Resource resource,
\r
2563 Class<T> clazz, Procedure<T> procedure) {
\r
2564 graph.forPossibleUniqueAdapted(resource, clazz, procedure);
\r
2568 public void forIsInstanceOf(Resource resource, Resource type,
\r
2569 AsyncListener<Boolean> procedure) {
\r
2570 graph.forIsInstanceOf(resource, type, procedure);
\r
2574 public void forIsInstanceOf(Resource resource, Resource type,
\r
2575 SyncListener<Boolean> procedure) {
\r
2576 graph.forIsInstanceOf(resource, type, procedure);
\r
2580 public void forIsInstanceOf(Resource resource, Resource type,
\r
2581 Listener<Boolean> procedure) {
\r
2582 graph.forIsInstanceOf(resource, type, procedure);
\r
2586 public void forIsInstanceOf(Resource resource, Resource type,
\r
2587 AsyncProcedure<Boolean> procedure) {
\r
2588 graph.forIsInstanceOf(resource, type, procedure);
\r
2592 public void forIsInstanceOf(Resource resource, Resource type,
\r
2593 SyncProcedure<Boolean> procedure) {
\r
2594 graph.forIsInstanceOf(resource, type, procedure);
\r
2598 public void forIsInstanceOf(Resource resource, Resource type,
\r
2599 Procedure<Boolean> procedure) {
\r
2600 graph.forIsInstanceOf(resource, type, procedure);
\r
2604 public void forIsInheritedFrom(Resource resource, Resource type,
\r
2605 AsyncListener<Boolean> procedure) {
\r
2606 graph.forIsInheritedFrom(resource, type, procedure);
\r
2610 public void forIsInheritedFrom(Resource resource, Resource type,
\r
2611 SyncListener<Boolean> procedure) {
\r
2612 graph.forIsInheritedFrom(resource, type, procedure);
\r
2616 public void forIsInheritedFrom(Resource resource, Resource type,
\r
2617 Listener<Boolean> procedure) {
\r
2618 graph.forIsInheritedFrom(resource, type, procedure);
\r
2622 public void forIsInheritedFrom(Resource resource, Resource type,
\r
2623 AsyncProcedure<Boolean> procedure) {
\r
2624 graph.forIsInheritedFrom(resource, type, procedure);
\r
2628 public void forIsInheritedFrom(Resource resource, Resource type,
\r
2629 SyncProcedure<Boolean> procedure) {
\r
2630 graph.forIsInheritedFrom(resource, type, procedure);
\r
2634 public void forIsInheritedFrom(Resource resource, Resource type,
\r
2635 Procedure<Boolean> procedure) {
\r
2636 graph.forIsInheritedFrom(resource, type, procedure);
\r
2640 public void forIsSubrelationOf(Resource resource, Resource relation,
\r
2641 AsyncListener<Boolean> procedure) {
\r
2642 graph.forIsSubrelationOf(resource, relation, procedure);
\r
2646 public void forIsSubrelationOf(Resource resource, Resource relation,
\r
2647 SyncListener<Boolean> procedure) {
\r
2648 graph.forIsSubrelationOf(resource, relation, procedure);
\r
2652 public void forIsSubrelationOf(Resource resource, Resource relation,
\r
2653 Listener<Boolean> procedure) {
\r
2654 graph.forIsSubrelationOf(resource, relation, procedure);
\r
2658 public void forIsSubrelationOf(Resource resource, Resource relation,
\r
2659 AsyncProcedure<Boolean> procedure) {
\r
2660 graph.forIsSubrelationOf(resource, relation, procedure);
\r
2664 public void forIsSubrelationOf(Resource resource, Resource relation,
\r
2665 SyncProcedure<Boolean> procedure) {
\r
2666 graph.forIsSubrelationOf(resource, relation, procedure);
\r
2670 public void forIsSubrelationOf(Resource resource, Resource relation,
\r
2671 Procedure<Boolean> procedure) {
\r
2672 graph.forIsSubrelationOf(resource, relation, procedure);
\r
2676 public void forOrderedSet(Resource subject,
\r
2677 AsyncMultiListener<Resource> procedure) {
\r
2678 graph.forOrderedSet(subject, procedure);
\r
2682 public void forOrderedSet(Resource subject,
\r
2683 SyncMultiListener<Resource> procedure) {
\r
2684 graph.forOrderedSet(subject, procedure);
\r
2688 public void forOrderedSet(Resource subject,
\r
2689 MultiListener<Resource> procedure) {
\r
2690 graph.forOrderedSet(subject, procedure);
\r
2694 public void forOrderedSet(Resource subject,
\r
2695 AsyncMultiProcedure<Resource> procedure) {
\r
2696 graph.forOrderedSet(subject, procedure);
\r
2700 public void forOrderedSet(Resource subject,
\r
2701 SyncMultiProcedure<Resource> procedure) {
\r
2702 graph.forOrderedSet(subject, procedure);
\r
2706 public void forOrderedSet(Resource subject,
\r
2707 MultiProcedure<Resource> procedure) {
\r
2708 graph.forOrderedSet(subject, procedure);
\r
2712 public int thread() {
\r
2713 return graph.thread();
\r
2717 public Session getSession() {
\r
2718 return graph.getSession();
\r
2722 public Resource getBuiltin(String id) throws ResourceNotFoundException,
\r
2723 ServiceException {
\r
2724 return graph.getBuiltin(id);
\r
2728 public VirtualGraph getProvider() {
\r
2729 return graph.getProvider();
\r