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.ReadGraph;
\r
13 import org.simantics.db.Resource;
\r
14 import org.simantics.db.Session;
\r
15 import org.simantics.db.Statement;
\r
16 import org.simantics.db.VirtualGraph;
\r
17 import org.simantics.db.WriteGraph;
\r
18 import org.simantics.db.common.request.ReadRequest;
\r
19 import org.simantics.db.common.request.WriteRequest;
\r
20 import org.simantics.db.common.request.WriteResultRequest;
\r
21 import org.simantics.db.exception.AdaptionException;
\r
22 import org.simantics.db.exception.AssumptionException;
\r
23 import org.simantics.db.exception.BindingException;
\r
24 import org.simantics.db.exception.DatabaseException;
\r
25 import org.simantics.db.exception.DoesNotContainValueException;
\r
26 import org.simantics.db.exception.ManyObjectsForFunctionalRelationException;
\r
27 import org.simantics.db.exception.NoInverseException;
\r
28 import org.simantics.db.exception.NoSingleResultException;
\r
29 import org.simantics.db.exception.ResourceNotFoundException;
\r
30 import org.simantics.db.exception.ServiceException;
\r
31 import org.simantics.db.exception.ServiceNotFoundException;
\r
32 import org.simantics.db.exception.ValidationException;
\r
33 import org.simantics.db.procedure.AsyncListener;
\r
34 import org.simantics.db.procedure.AsyncMultiListener;
\r
35 import org.simantics.db.procedure.AsyncMultiProcedure;
\r
36 import org.simantics.db.procedure.AsyncProcedure;
\r
37 import org.simantics.db.procedure.AsyncSetListener;
\r
38 import org.simantics.db.procedure.Listener;
\r
39 import org.simantics.db.procedure.MultiListener;
\r
40 import org.simantics.db.procedure.MultiProcedure;
\r
41 import org.simantics.db.procedure.Procedure;
\r
42 import org.simantics.db.procedure.SetListener;
\r
43 import org.simantics.db.procedure.SyncListener;
\r
44 import org.simantics.db.procedure.SyncMultiListener;
\r
45 import org.simantics.db.procedure.SyncMultiProcedure;
\r
46 import org.simantics.db.procedure.SyncProcedure;
\r
47 import org.simantics.db.procedure.SyncSetListener;
\r
48 import org.simantics.db.request.AsyncMultiRead;
\r
49 import org.simantics.db.request.AsyncRead;
\r
50 import org.simantics.db.request.DelayedWrite;
\r
51 import org.simantics.db.request.DelayedWriteResult;
\r
52 import org.simantics.db.request.ExternalRead;
\r
53 import org.simantics.db.request.MultiRead;
\r
54 import org.simantics.db.request.Read;
\r
55 import org.simantics.db.request.ReadInterface;
\r
56 import org.simantics.db.request.Write;
\r
57 import org.simantics.db.request.WriteInterface;
\r
58 import org.simantics.db.request.WriteOnly;
\r
59 import org.simantics.db.request.WriteOnlyResult;
\r
60 import org.simantics.db.request.WriteResult;
\r
61 import org.simantics.db.request.WriteTraits;
\r
62 import org.simantics.scl.types.Type;
\r
63 import org.simantics.utils.datastructures.Callback;
\r
68 * @author Marko Luukkainen <marko.luukkainen@vtt.fi>
\r
71 public class SplittingWriteGraph implements WriteGraph {
\r
73 protected Session session;
\r
77 public <T> T getRelatedValue2(final Resource subject, final Resource relation)
\r
78 throws DatabaseException {
\r
79 return session.syncRequest(new Read<T>() {
\r
81 public T perform(ReadGraph graph) throws DatabaseException {
\r
82 return graph.getRelatedValue2(subject, relation);
\r
89 public <T> T getRelatedValue2(final Resource subject, final Resource relation, final Binding binding) throws DatabaseException {
\r
90 return session.syncRequest(new Read<T>() {
\r
92 public T perform(ReadGraph graph) throws DatabaseException {
\r
93 return graph.getRelatedValue2(subject, relation, binding);
\r
99 public <T> T getRelatedValue2(final Resource subject, final Resource relation, final Object context) throws DatabaseException {
\r
100 return session.syncRequest(new Read<T>() {
\r
102 public T perform(ReadGraph graph) throws DatabaseException {
\r
103 return graph.getRelatedValue2(subject, relation, context);
\r
109 public <T> T getRelatedValue2(final Resource subject, final Resource relation, final Object context, final Binding binding) throws DatabaseException {
\r
110 return session.syncRequest(new Read<T>() {
\r
112 public T perform(ReadGraph graph) throws DatabaseException {
\r
113 return graph.getRelatedValue2(subject, relation, context, binding);
\r
119 public <T> T getPossibleRelatedValue2(final Resource subject, final Resource relation)
\r
120 throws DatabaseException {
\r
121 return session.syncRequest(new Read<T>() {
\r
123 public T perform(ReadGraph graph) throws DatabaseException {
\r
124 return graph.getPossibleRelatedValue2(subject, relation);
\r
130 public <T> T getPossibleRelatedValue2(final Resource subject, final Resource relation, final Binding binding) throws DatabaseException {
\r
131 return session.syncRequest(new Read<T>() {
\r
133 public T perform(ReadGraph graph) throws DatabaseException {
\r
134 return graph.getPossibleRelatedValue2(subject, relation, binding);
\r
140 public <T> T getPossibleRelatedValue2(final Resource subject, final Resource relation, final Object context) throws DatabaseException {
\r
141 return session.syncRequest(new Read<T>() {
\r
143 public T perform(ReadGraph graph) throws DatabaseException {
\r
144 return graph.getPossibleRelatedValue2(subject, relation, context);
\r
150 public <T> T getPossibleRelatedValue2(final Resource subject, final Resource relation, final Object context, final Binding binding) throws DatabaseException {
\r
151 return session.syncRequest(new Read<T>() {
\r
153 public T perform(ReadGraph graph) throws DatabaseException {
\r
154 return graph.getPossibleRelatedValue2(subject, relation, context, binding);
\r
160 public <T> void async(final ReadInterface<T> r, final AsyncListener<T> procedure) {
\r
161 session.async(r, procedure);
\r
166 public <T> void async(final ReadInterface<T> r, final AsyncProcedure<T> procedure) {
\r
167 session.async(r, procedure);
\r
171 public <T> void async(final ReadInterface<T> r, final Listener<T> procedure) {
\r
172 session.async(r, procedure);
\r
176 public <T> void async(final ReadInterface<T> r, final Procedure<T> procedure) {
\r
177 session.async(r, procedure);
\r
181 public <T> void async(final ReadInterface<T> r, final SyncListener<T> procedure) {
\r
182 session.async(r, procedure);
\r
186 public <T> void async(final ReadInterface<T> r, final SyncProcedure<T> procedure) {
\r
187 session.async(r, procedure);
\r
191 public <T> void async(final WriteInterface<T> r) {
\r
196 public <T> void async(final WriteInterface<T> r, final Procedure<T> procedure) {
\r
197 session.async(r, procedure);
\r
201 public <T> T sync(final ReadInterface<T> r) throws DatabaseException {
\r
202 return session.sync(r);
\r
206 public <T> T sync(final WriteInterface<T> r) throws DatabaseException {
\r
207 return session.sync(r);
\r
211 public Resource getRootLibrary() {
\r
213 return session.syncRequest(new Read<Resource>() {
\r
216 public Resource perform(ReadGraph graph) throws DatabaseException {
\r
217 return graph.getRootLibrary();
\r
220 } catch (DatabaseException e) {
\r
227 public void clearUndoList(final WriteTraits writeTraits) {
\r
228 throw new RuntimeException("Not supported.");
\r
232 public void combineWithPrevious(WriteTraits writeTraits) {
\r
233 throw new RuntimeException("Not supported.");
\r
237 public TreeMap<String, byte[]> getMetadata() {
\r
239 return session.syncRequest(new WriteResultRequest<TreeMap<String, byte[]>>() {
\r
242 public TreeMap<String, byte[]> perform(WriteGraph graph) throws DatabaseException {
\r
243 return graph.getMetadata();
\r
246 } catch (DatabaseException e) {
\r
252 public <T extends Metadata> T getMetadata(final Class<T> clazz)
\r
253 throws ServiceException {
\r
255 return session.syncRequest(new WriteResultRequest<T>() {
\r
258 public T perform(WriteGraph graph) throws DatabaseException {
\r
259 return graph.getMetadata(clazz);
\r
262 } catch (DatabaseException e) {
\r
263 throw new ServiceException(e);
\r
268 public Type getRelatedValueType(final Resource subject, final Resource relation)
\r
269 throws DatabaseException {
\r
271 return session.syncRequest(new Read<Type>() {
\r
274 public Type perform(ReadGraph graph) throws DatabaseException {
\r
275 return graph.getRelatedValueType(subject, relation);
\r
282 public void deny(final Resource subject, final Resource predicate, final Resource inverse, final Resource object, final VirtualGraph vgraph) throws ServiceException {
\r
284 session.syncRequest(new WriteRequest() {
\r
287 public void perform(WriteGraph graph) throws DatabaseException {
\r
288 graph.deny(subject, predicate, inverse, object, vgraph);
\r
292 } catch (DatabaseException e) {
\r
293 throw new ServiceException(e);
\r
301 public <T> T adaptRelated(final Resource resource, final Resource relation,
\r
302 final Class<T> clazz) throws AdaptionException, NoSingleResultException,
\r
303 ValidationException, ServiceException {
\r
305 return session.syncRequest(new Read<T>() {
\r
308 public T perform(ReadGraph graph) throws DatabaseException {
\r
309 return graph.adaptRelated(resource, relation, clazz);
\r
312 } catch (DatabaseException e) {
\r
313 throw new ServiceException(e);
\r
318 public <T> T getPossibleRelatedAdapter(final Resource resource,
\r
319 final Resource relation, final Class<T> clazz) throws ValidationException,
\r
322 return session.syncRequest(new Read<T>() {
\r
325 public T perform(ReadGraph graph) throws DatabaseException {
\r
326 return graph.getPossibleRelatedAdapter(resource, relation, clazz);
\r
329 } catch (DatabaseException e) {
\r
330 throw new ValidationException(e);
\r
335 public void inc() {
\r
336 throw new RuntimeException("Not supported.");
\r
340 public void dec() {
\r
341 throw new RuntimeException("Not supported.");
\r
345 public Collection<Resource> getObjects(final Resource subject, final Resource relation) throws ServiceException
\r
348 return session.syncRequest(new Read<Collection<Resource>>() {
\r
351 public Collection<Resource> perform(ReadGraph graph) throws DatabaseException {
\r
352 return graph.getObjects(subject, relation);
\r
355 } catch (DatabaseException e) {
\r
356 throw new ServiceException(e);
\r
362 public <T extends Accessor> T newLiteral(final Resource resource,
\r
363 final Resource predicate, final Datatype datatype, final Object initialValue)
\r
364 throws DatabaseException {
\r
365 return session.syncRequest(new WriteResultRequest<T>() {
\r
368 public T perform(WriteGraph graph) throws DatabaseException {
\r
369 return graph.newLiteral(resource, predicate, datatype, initialValue);
\r
375 public RandomAccessBinary newLiteral4RandomAccessBinary
\r
376 (final Resource resource, final Resource predicate, final Datatype datatype, final Object initialvalue)
\r
377 throws DatabaseException {
\r
378 return session.syncRequest(new WriteResultRequest<RandomAccessBinary>() {
\r
380 public RandomAccessBinary perform(WriteGraph graph) throws DatabaseException {
\r
381 return graph.newLiteral4RandomAccessBinary(resource, predicate, datatype, initialvalue);
\r
386 public <T, C> T adaptContextual(final Resource resource, final C context, final java.lang.Class<C> contextClass, final java.lang.Class<T> clazz) throws AdaptionException ,NoSingleResultException ,ValidationException ,ServiceException {
\r
388 return session.syncRequest(new Read<T>() {
\r
391 public T perform(ReadGraph graph) throws DatabaseException {
\r
392 return graph.adaptContextual(resource, context, contextClass, clazz);
\r
395 } catch (DatabaseException e) {
\r
396 throw new ServiceException(e);
\r
401 public <T, C> T getPossibleContextualAdapter(final Resource resource, final C context, final java.lang.Class<C> contextClass, final java.lang.Class<T> clazz) throws ValidationException ,ServiceException {
\r
403 return session.syncRequest(new Read<T>() {
\r
406 public T perform(ReadGraph graph) throws DatabaseException {
\r
407 return graph.getPossibleContextualAdapter(resource, context, contextClass, clazz);
\r
410 } catch (DatabaseException e) {
\r
411 throw new ServiceException(e);
\r
416 public SplittingWriteGraph(Session session) {
\r
417 this.session = session;
\r
421 public Resource newResource() throws ServiceException {
\r
423 return session.syncRequest(new WriteResultRequest<Resource>() {
\r
426 public Resource perform(WriteGraph graph) throws DatabaseException {
\r
427 return graph.newResource();
\r
430 } catch (DatabaseException e) {
\r
431 throw new ServiceException(e);
\r
437 public Resource newResource(final long clusterId) throws ServiceException {
\r
439 return session.syncRequest(new WriteResultRequest<Resource>() {
\r
442 public Resource perform(WriteGraph graph) throws DatabaseException {
\r
443 return graph.newResource(clusterId);
\r
446 } catch (DatabaseException e) {
\r
447 throw new ServiceException(e);
\r
452 public <T> T adapt(final Resource resource, final Class<T> clazz)
\r
453 throws AdaptionException, ValidationException, ServiceException {
\r
455 return session.syncRequest(new Read<T>() {
\r
458 public T perform(ReadGraph graph) throws DatabaseException {
\r
459 return graph.adapt(resource, clazz);
\r
462 } catch (DatabaseException e) {
\r
463 throw new ServiceException(e);
\r
468 public <T> T adaptUnique(final Resource resource, final Class<T> clazz)
\r
469 throws AdaptionException, ValidationException, ServiceException {
\r
471 return session.syncRequest(new Read<T>() {
\r
474 public T perform(ReadGraph graph) throws DatabaseException {
\r
475 return graph.adaptUnique(resource, clazz);
\r
478 } catch (DatabaseException e) {
\r
479 throw new ServiceException(e);
\r
484 public void addLiteral(final Resource resource, final Resource predicate,
\r
485 final Resource inverse, final Object value, final Binding binding)
\r
486 throws BindingException,
\r
487 ManyObjectsForFunctionalRelationException, ServiceException {
\r
489 session.syncRequest(new WriteRequest() {
\r
492 public void perform(WriteGraph graph) throws DatabaseException {
\r
493 graph.addLiteral(resource, predicate, inverse, value, binding);
\r
497 } catch (DatabaseException e) {
\r
498 throw new ServiceException(e);
\r
503 public void addLiteral(final Resource resource, final Resource predicate,
\r
504 final Resource inverse, final Resource type, final Object value, final Binding binding)
\r
505 throws BindingException,
\r
506 ManyObjectsForFunctionalRelationException, ServiceException {
\r
508 session.syncRequest(new WriteRequest() {
\r
511 public void perform(WriteGraph graph) throws DatabaseException {
\r
512 graph.addLiteral(resource, predicate, inverse, type, value, binding);
\r
516 } catch (DatabaseException e) {
\r
517 throw new ServiceException(e);
\r
522 public <T> void addMetadata(Metadata data) throws ServiceException {
\r
523 throw new RuntimeException("Not supported.");
\r
528 public void addValue(final Resource resource, final Resource predicate,
\r
529 final Resource inverse, final Resource type, final Object value, final Binding binding)
\r
530 throws BindingException,
\r
531 ManyObjectsForFunctionalRelationException, ServiceException {
\r
533 session.syncRequest(new WriteRequest() {
\r
536 public void perform(WriteGraph graph) throws DatabaseException {
\r
537 graph.addValue(resource, predicate, inverse, type, value, binding);
\r
541 } catch (DatabaseException e) {
\r
542 throw new ServiceException(e);
\r
547 public <T> void asyncRequest(final AsyncMultiRead<T> request) {
\r
548 session.asyncRequest(request);
\r
552 public <T> void asyncRequest(AsyncMultiRead<T> request,
\r
553 AsyncMultiListener<T> procedure) {
\r
554 session.asyncRequest(request,procedure);
\r
558 public <T> void asyncRequest(AsyncMultiRead<T> request,
\r
559 AsyncMultiProcedure<T> procedure) {
\r
560 session.asyncRequest(request,procedure);
\r
564 public <T> void asyncRequest(AsyncMultiRead<T> request,
\r
565 MultiListener<T> procedure) {
\r
566 session.asyncRequest(request,procedure);
\r
570 public <T> void asyncRequest(AsyncMultiRead<T> request,
\r
571 MultiProcedure<T> procedure) {
\r
572 session.asyncRequest(request,procedure);
\r
576 public <T> void asyncRequest(AsyncMultiRead<T> request,
\r
577 SyncMultiListener<T> procedure) {
\r
578 session.asyncRequest(request,procedure);
\r
582 public <T> void asyncRequest(AsyncMultiRead<T> request,
\r
583 SyncMultiProcedure<T> procedure) {
\r
584 session.asyncRequest(request,procedure);
\r
588 public <T> void asyncRequest(AsyncRead<T> request) {
\r
589 session.asyncRequest(request);
\r
593 public <T> void asyncRequest(AsyncRead<T> request,
\r
594 AsyncListener<T> procedure) {
\r
595 session.asyncRequest(request,procedure);
\r
599 public <T> void asyncRequest(AsyncRead<T> request,
\r
600 AsyncProcedure<T> procedure) {
\r
601 session.asyncRequest(request,procedure);
\r
605 public <T> void asyncRequest(AsyncRead<T> request, Listener<T> procedure) {
\r
606 session.asyncRequest(request,procedure);
\r
610 public <T> void asyncRequest(AsyncRead<T> request,
\r
611 Procedure<T> procedure) {
\r
612 session.asyncRequest(request,procedure);
\r
616 public <T> void asyncRequest(AsyncRead<T> request,
\r
617 SyncListener<T> procedure) {
\r
618 session.asyncRequest(request,procedure);
\r
622 public <T> void asyncRequest(AsyncRead<T> request,
\r
623 SyncProcedure<T> procedure) {
\r
624 session.asyncRequest(request,procedure);
\r
628 public void asyncRequest(DelayedWrite request) {
\r
629 session.asyncRequest(request);
\r
633 public void asyncRequest(DelayedWrite request,
\r
634 Callback<DatabaseException> callback) {
\r
635 session.asyncRequest(request,callback);
\r
639 public <T> void asyncRequest(DelayedWriteResult<T> r,
\r
640 Procedure<T> procedure) {
\r
641 session.asyncRequest(r,procedure);
\r
645 public <T> void asyncRequest(ExternalRead<T> request) {
\r
646 session.asyncRequest(request);
\r
650 public <T> void asyncRequest(ExternalRead<T> request,
\r
651 Listener<T> procedure) {
\r
652 session.asyncRequest(request,procedure);
\r
656 public <T> void asyncRequest(ExternalRead<T> request,
\r
657 Procedure<T> procedure) {
\r
658 session.asyncRequest(request,procedure);
\r
662 public <T> void asyncRequest(MultiRead<T> request) {
\r
663 session.asyncRequest(request);
\r
667 public <T> void asyncRequest(MultiRead<T> request,
\r
668 AsyncMultiListener<T> procedure) {
\r
669 session.asyncRequest(request,procedure);
\r
673 public <T> void asyncRequest(MultiRead<T> request,
\r
674 AsyncMultiProcedure<T> procedure) {
\r
675 session.asyncRequest(request,procedure);
\r
679 public <T> void asyncRequest(MultiRead<T> request,
\r
680 MultiListener<T> procedure) {
\r
681 session.asyncRequest(request,procedure);
\r
685 public <T> void asyncRequest(MultiRead<T> request,
\r
686 MultiProcedure<T> procedure) {
\r
687 session.asyncRequest(request,procedure);
\r
691 public <T> void asyncRequest(MultiRead<T> request,
\r
692 SyncMultiListener<T> procedure) {
\r
693 session.asyncRequest(request,procedure);
\r
697 public <T> void asyncRequest(MultiRead<T> request,
\r
698 SyncMultiProcedure<T> procedure) {
\r
699 session.asyncRequest(request,procedure);
\r
703 public <T> void asyncRequest(Read<T> request) {
\r
704 session.asyncRequest(request);
\r
708 public <T> void asyncRequest(Read<T> request, AsyncListener<T> procedure) {
\r
709 session.asyncRequest(request,procedure);
\r
713 public <T> void asyncRequest(Read<T> request,
\r
714 AsyncProcedure<T> procedure) {
\r
715 session.asyncRequest(request,procedure);
\r
719 public <T> void asyncRequest(Read<T> request, Listener<T> procedure) {
\r
720 session.asyncRequest(request,procedure);
\r
724 public <T> void asyncRequest(Read<T> request, Procedure<T> procedure) {
\r
725 session.asyncRequest(request,procedure);
\r
729 public <T> void asyncRequest(Read<T> request, SyncListener<T> procedure) {
\r
730 session.asyncRequest(request,procedure);
\r
734 public <T> void asyncRequest(Read<T> request, SyncProcedure<T> procedure) {
\r
735 session.asyncRequest(request,procedure);
\r
739 public void asyncRequest(Write request) {
\r
740 session.asyncRequest(request);
\r
744 public void asyncRequest(Write request,
\r
745 Callback<DatabaseException> callback) {
\r
746 session.asyncRequest(request, callback);
\r
750 public void asyncRequest(WriteOnly r) {
\r
751 session.asyncRequest(r);
\r
755 public void asyncRequest(WriteOnly r,
\r
756 Callback<DatabaseException> callback) {
\r
757 session.asyncRequest(r,callback);
\r
761 public <T> void asyncRequest(WriteOnlyResult<T> r,
\r
762 Procedure<T> procedure) {
\r
763 session.asyncRequest(r,procedure);
\r
767 public <T> void asyncRequest(WriteResult<T> r, Procedure<T> procedure) {
\r
768 session.asyncRequest(r,procedure);
\r
774 public void claim(final Resource subject, final Resource predicate,
\r
775 final Resource inverse, final Resource object) throws ServiceException {
\r
777 session.syncRequest(new WriteRequest() {
\r
780 public void perform(WriteGraph graph) throws DatabaseException {
\r
781 graph.claim(subject, predicate, inverse, object);
\r
784 } catch (DatabaseException e) {
\r
785 throw new ServiceException(e);
\r
790 public void claim(final Resource subject, final Resource predicate, final Resource object)
\r
791 throws ServiceException {
\r
793 session.syncRequest(new WriteRequest() {
\r
796 public void perform(WriteGraph graph) throws DatabaseException {
\r
797 graph.claim(subject, predicate, object);
\r
800 } catch (DatabaseException e) {
\r
801 throw new ServiceException(e);
\r
807 public void claimLiteral(final Resource resource, final Resource predicate,
\r
808 final Object value) throws ManyObjectsForFunctionalRelationException,
\r
811 session.syncRequest(new WriteRequest() {
\r
814 public void perform(WriteGraph graph) throws DatabaseException {
\r
815 graph.claimLiteral(resource, predicate, value);
\r
818 } catch (DatabaseException e) {
\r
819 throw new ServiceException(e);
\r
825 public void claimLiteral(final Resource resource, final Resource predicate,
\r
826 final Object value, final Binding binding) throws BindingException,
\r
827 ManyObjectsForFunctionalRelationException, ServiceException {
\r
829 session.syncRequest(new WriteRequest() {
\r
832 public void perform(WriteGraph graph) throws DatabaseException {
\r
833 graph.claimLiteral(resource, predicate, value, binding);
\r
836 } catch (DatabaseException e) {
\r
837 throw new ServiceException(e);
\r
843 public void claimLiteral(final Resource resource, final Resource predicate,
\r
844 final Resource inverse, final Resource type, final Object value)
\r
845 throws BindingException,
\r
846 ManyObjectsForFunctionalRelationException, ServiceException {
\r
848 session.syncRequest(new WriteRequest() {
\r
851 public void perform(WriteGraph graph) throws DatabaseException {
\r
852 graph.claimLiteral(resource, predicate, inverse, type, value);
\r
855 } catch (DatabaseException e) {
\r
856 throw new ServiceException(e);
\r
862 public void claimLiteral(final Resource resource, final Resource predicate,
\r
863 final Resource inverse, final Resource type, final Object value, final Binding binding)
\r
864 throws BindingException,
\r
865 ManyObjectsForFunctionalRelationException, ServiceException {
\r
867 session.syncRequest(new WriteRequest() {
\r
870 public void perform(WriteGraph graph) throws DatabaseException {
\r
871 graph.claimLiteral(resource, predicate, inverse, type, value, binding);
\r
874 } catch (DatabaseException e) {
\r
875 throw new ServiceException(e);
\r
881 public void claimLiteral(final Resource resource, final Resource predicate,
\r
882 final Resource type, final Object value) throws BindingException,
\r
883 ManyObjectsForFunctionalRelationException, ServiceException {
\r
885 session.syncRequest(new WriteRequest() {
\r
888 public void perform(WriteGraph graph) throws DatabaseException {
\r
889 graph.claimLiteral(resource, predicate, type, value);
\r
892 } catch (DatabaseException e) {
\r
893 throw new ServiceException(e);
\r
899 public void claimLiteral(final Resource resource, final Resource predicate,
\r
900 final Resource type, final Object value, final Binding binding)
\r
901 throws BindingException,
\r
902 ManyObjectsForFunctionalRelationException, ServiceException {
\r
904 session.syncRequest(new WriteRequest() {
\r
907 public void perform(WriteGraph graph) throws DatabaseException {
\r
908 graph.claimLiteral(resource, predicate, type, value, binding);
\r
911 } catch (DatabaseException e) {
\r
912 throw new ServiceException(e);
\r
918 public void claimValue(final Resource resource, final Object value)
\r
919 throws ServiceException {
\r
921 session.syncRequest(new WriteRequest() {
\r
924 public void perform(WriteGraph graph) throws DatabaseException {
\r
925 graph.claimValue(resource, value);
\r
928 } catch (DatabaseException e) {
\r
929 throw new ServiceException(e);
\r
935 public void claimValue(final Resource resource, final Object value, final Binding binding)
\r
936 throws ServiceException {
\r
938 session.syncRequest(new WriteRequest() {
\r
941 public void perform(WriteGraph graph) throws DatabaseException {
\r
942 graph.claimValue(resource, value, binding);
\r
945 } catch (DatabaseException e) {
\r
946 throw new ServiceException(e);
\r
951 @SuppressWarnings("deprecation")
\r
953 public void claimValue(final Resource resource, final Resource predicate,
\r
954 final Object value) throws ManyObjectsForFunctionalRelationException,
\r
957 session.syncRequest(new WriteRequest() {
\r
960 public void perform(WriteGraph graph) throws DatabaseException {
\r
961 graph.claimValue(resource, predicate, value);
\r
964 } catch (DatabaseException e) {
\r
965 throw new ServiceException(e);
\r
970 @SuppressWarnings("deprecation")
\r
972 public void claimValue(final Resource resource, final Resource predicate,
\r
973 final Object value, final Binding binding) throws BindingException,
\r
974 ManyObjectsForFunctionalRelationException, ServiceException {
\r
976 session.syncRequest(new WriteRequest() {
\r
979 public void perform(WriteGraph graph) throws DatabaseException {
\r
980 graph.claimValue(resource, predicate, value, binding);
\r
983 } catch (DatabaseException e) {
\r
984 throw new ServiceException(e);
\r
989 @SuppressWarnings("deprecation")
\r
991 public void claimValue(final Resource resource, final Resource predicate,
\r
992 final Resource inverse, final Resource type, final Object value, final Binding binding)
\r
993 throws BindingException,
\r
994 ManyObjectsForFunctionalRelationException, ServiceException {
\r
996 session.syncRequest(new WriteRequest() {
\r
999 public void perform(WriteGraph graph) throws DatabaseException {
\r
1000 graph.claimValue(resource, predicate, inverse, type, value, binding);
\r
1003 } catch (DatabaseException e) {
\r
1004 throw new ServiceException(e);
\r
1010 public void deny(final Resource subject) throws ServiceException {
\r
1012 session.syncRequest(new WriteRequest() {
\r
1015 public void perform(WriteGraph graph) throws DatabaseException {
\r
1016 graph.deny(subject);
\r
1019 } catch (DatabaseException e) {
\r
1020 throw new ServiceException(e);
\r
1026 public void deny(final Resource subject, final Resource predicate)
\r
1027 throws ServiceException {
\r
1029 session.syncRequest(new WriteRequest() {
\r
1032 public void perform(WriteGraph graph) throws DatabaseException {
\r
1033 graph.deny(subject, predicate);
\r
1036 } catch (DatabaseException e) {
\r
1037 throw new ServiceException(e);
\r
1043 public void deny(final Resource subject, final Resource predicate,
\r
1044 final Resource inverse, final Resource object) throws ServiceException {
\r
1046 session.syncRequest(new WriteRequest() {
\r
1049 public void perform(WriteGraph graph) throws DatabaseException {
\r
1050 graph.deny(subject, predicate, inverse, object);
\r
1053 } catch (DatabaseException e) {
\r
1054 throw new ServiceException(e);
\r
1060 public void deny(final Resource subject, final Resource predicate, final Resource object)
\r
1061 throws ServiceException {
\r
1063 session.syncRequest(new WriteRequest() {
\r
1066 public void perform(WriteGraph graph) throws DatabaseException {
\r
1067 graph.deny(subject, predicate, object);
\r
1070 } catch (DatabaseException e) {
\r
1071 throw new ServiceException(e);
\r
1077 public void deny(final Statement statement) throws ServiceException {
\r
1079 session.syncRequest(new WriteRequest() {
\r
1082 public void perform(WriteGraph graph) throws DatabaseException {
\r
1083 graph.deny(statement);
\r
1086 } catch (DatabaseException e) {
\r
1087 throw new ServiceException(e);
\r
1094 public void denyStatement(final Resource subject, final Resource predicate,
\r
1095 final Resource object) throws ServiceException {
\r
1097 session.syncRequest(new WriteRequest() {
\r
1100 public void perform(WriteGraph graph) throws DatabaseException {
\r
1101 graph.denyStatement(subject, predicate, object);
\r
1104 } catch (DatabaseException e) {
\r
1105 throw new ServiceException(e);
\r
1111 public void denyValue(final Resource resource) throws ServiceException {
\r
1113 session.syncRequest(new WriteRequest() {
\r
1116 public void perform(WriteGraph graph) throws DatabaseException {
\r
1117 graph.denyValue(resource);
\r
1120 } catch (DatabaseException e) {
\r
1121 throw new ServiceException(e);
\r
1127 public void denyValue(final Resource resource, final Resource predicate)
\r
1128 throws ManyObjectsForFunctionalRelationException,
\r
1129 ServiceException {
\r
1131 session.syncRequest(new WriteRequest() {
\r
1134 public void perform(WriteGraph graph) throws DatabaseException {
\r
1135 graph.denyValue(resource, predicate);
\r
1138 } catch (DatabaseException e) {
\r
1139 throw new ServiceException(e);
\r
1144 public void flushCluster() throws ServiceException {
\r
1146 session.syncRequest(new WriteRequest() {
\r
1149 public void perform(WriteGraph graph) throws DatabaseException {
\r
1150 graph.flushCluster();
\r
1154 } catch (DatabaseException e) {
\r
1155 throw new ServiceException(e);
\r
1161 public void flushCluster(final Resource r) throws ServiceException {
\r
1163 session.syncRequest(new WriteRequest() {
\r
1166 public void perform(WriteGraph graph) throws DatabaseException {
\r
1167 graph.flushCluster(r);
\r
1171 } catch (DatabaseException e) {
\r
1172 throw new ServiceException(e);
\r
1177 public <T> void forAdapted(final Resource resource, final Class<T> clazz,
\r
1178 final AsyncListener<T> procedure) {
\r
1180 session.syncRequest(new ReadRequest() {
\r
1183 public void run(ReadGraph graph) throws DatabaseException {
\r
1184 graph.forAdapted(resource, clazz, procedure);
\r
1187 } catch (DatabaseException e) {
\r
1194 public <T> void forAdapted(final Resource resource, final Class<T> clazz,
\r
1195 final AsyncProcedure<T> procedure) {
\r
1197 session.syncRequest(new ReadRequest() {
\r
1200 public void run(ReadGraph graph) throws DatabaseException {
\r
1201 graph.forAdapted(resource, clazz, procedure);
\r
1204 } catch (DatabaseException e) {
\r
1210 public <T> void forAdapted(final Resource resource, final Class<T> clazz,
\r
1211 final Listener<T> procedure) {
\r
1213 session.syncRequest(new ReadRequest() {
\r
1216 public void run(ReadGraph graph) throws DatabaseException {
\r
1217 graph.forAdapted(resource, clazz, procedure);
\r
1220 } catch (DatabaseException e) {
\r
1226 public <T> void forAdapted(final Resource resource, final Class<T> clazz,
\r
1227 final Procedure<T> procedure) {
\r
1229 session.syncRequest(new ReadRequest() {
\r
1232 public void run(ReadGraph graph) throws DatabaseException {
\r
1233 graph.forAdapted(resource, clazz, procedure);
\r
1236 } catch (DatabaseException e) {
\r
1243 public <T> void forAdapted(final Resource resource, final Class<T> clazz,
\r
1244 final SyncListener<T> procedure) {
\r
1246 session.syncRequest(new ReadRequest() {
\r
1249 public void run(ReadGraph graph) throws DatabaseException {
\r
1250 graph.forAdapted(resource, clazz, procedure);
\r
1253 } catch (DatabaseException e) {
\r
1260 public <T> void forAdapted(final Resource resource, final Class<T> clazz,
\r
1261 final SyncProcedure<T> procedure) {
\r
1263 session.syncRequest(new ReadRequest() {
\r
1266 public void run(ReadGraph graph) throws DatabaseException {
\r
1267 graph.forAdapted(resource, clazz, procedure);
\r
1270 } catch (DatabaseException e) {
\r
1276 public void forAssertedObjectSet(final Resource subject, final Resource relation,
\r
1277 final AsyncSetListener<Resource> procedure) {
\r
1279 session.syncRequest(new ReadRequest() {
\r
1282 public void run(ReadGraph graph) throws DatabaseException {
\r
1283 graph.forAssertedObjectSet(subject, relation, procedure);
\r
1286 } catch (DatabaseException e) {
\r
1293 public void forAssertedObjectSet(final Resource subject, final Resource relation,
\r
1294 final SetListener<Resource> procedure) {
\r
1296 session.syncRequest(new ReadRequest() {
\r
1299 public void run(ReadGraph graph) throws DatabaseException {
\r
1300 graph.forAssertedObjectSet(subject, relation, procedure);
\r
1303 } catch (DatabaseException e) {
\r
1309 public void forAssertedObjectSet(final Resource subject, final Resource relation,
\r
1310 final SyncSetListener<Resource> procedure) {
\r
1312 session.syncRequest(new ReadRequest() {
\r
1315 public void run(ReadGraph graph) throws DatabaseException {
\r
1316 graph.forAssertedObjectSet(subject, relation, procedure);
\r
1319 } catch (DatabaseException e) {
\r
1325 public void forAssertedStatementSet(final Resource subject,
\r
1326 final Resource relation, final AsyncSetListener<Statement> procedure) {
\r
1328 session.syncRequest(new ReadRequest() {
\r
1331 public void run(ReadGraph graph) throws DatabaseException {
\r
1332 graph.forAssertedStatementSet(subject, relation, procedure);
\r
1335 } catch (DatabaseException e) {
\r
1341 public void forAssertedStatementSet(final Resource subject,
\r
1342 final Resource relation, final SetListener<Statement> procedure) {
\r
1344 session.syncRequest(new ReadRequest() {
\r
1347 public void run(ReadGraph graph) throws DatabaseException {
\r
1348 graph.forAssertedStatementSet(subject, relation, procedure);
\r
1351 } catch (DatabaseException e) {
\r
1357 public void forAssertedStatementSet(final Resource subject,
\r
1358 final Resource relation, final SyncSetListener<Statement> procedure) {
\r
1360 session.syncRequest(new ReadRequest() {
\r
1363 public void run(ReadGraph graph) throws DatabaseException {
\r
1364 graph.forAssertedStatementSet(subject, relation, procedure);
\r
1367 } catch (DatabaseException e) {
\r
1373 public void forBuiltin(final String id, final AsyncListener<Resource> procedure) {
\r
1375 session.syncRequest(new ReadRequest() {
\r
1378 public void run(ReadGraph graph) throws DatabaseException {
\r
1379 graph.forBuiltin(id, procedure);
\r
1382 } catch (DatabaseException e) {
\r
1389 public void forBuiltin(final String id, final Listener<Resource> procedure) {
\r
1391 session.syncRequest(new ReadRequest() {
\r
1394 public void run(ReadGraph graph) throws DatabaseException {
\r
1395 graph.forBuiltin(id, procedure);
\r
1398 } catch (DatabaseException e) {
\r
1404 public void forBuiltin(final String id, final AsyncProcedure<Resource> procedure) {
\r
1406 session.syncRequest(new ReadRequest() {
\r
1409 public void run(ReadGraph graph) throws DatabaseException {
\r
1410 graph.forBuiltin(id, procedure);
\r
1413 } catch (DatabaseException e) {
\r
1419 public void forBuiltin(final String id, final Procedure<Resource> procedure) {
\r
1421 session.syncRequest(new ReadRequest() {
\r
1424 public void run(ReadGraph graph) throws DatabaseException {
\r
1425 graph.forBuiltin(id, procedure);
\r
1428 } catch (DatabaseException e) {
\r
1434 public void forBuiltin(final String id, final SyncListener<Resource> procedure) {
\r
1436 session.syncRequest(new ReadRequest() {
\r
1439 public void run(ReadGraph graph) throws DatabaseException {
\r
1440 graph.forBuiltin(id, procedure);
\r
1443 } catch (DatabaseException e) {
\r
1449 public void forBuiltin(final String id, final SyncProcedure<Resource> procedure) {
\r
1451 session.syncRequest(new ReadRequest() {
\r
1454 public void run(ReadGraph graph) throws DatabaseException {
\r
1455 graph.forBuiltin(id, procedure);
\r
1458 } catch (DatabaseException e) {
\r
1464 public void forDirectSuperrelations(final Resource subject,
\r
1465 final AsyncMultiProcedure<Resource> procedure) {
\r
1467 session.syncRequest(new ReadRequest() {
\r
1470 public void run(ReadGraph graph) throws DatabaseException {
\r
1471 graph.forDirectSuperrelations(subject, procedure);
\r
1474 } catch (DatabaseException e) {
\r
1480 public void forEachAssertedObject(final Resource subject, final Resource relation,
\r
1481 final AsyncMultiProcedure<Resource> procedure) {
\r
1483 session.syncRequest(new ReadRequest() {
\r
1486 public void run(ReadGraph graph) throws DatabaseException {
\r
1487 graph.forEachAssertedObject(subject, relation, procedure);
\r
1490 } catch (DatabaseException e) {
\r
1496 public void forEachAssertedObject(final Resource subject, final Resource relation,
\r
1497 final MultiProcedure<Resource> procedure) {
\r
1499 session.syncRequest(new ReadRequest() {
\r
1502 public void run(ReadGraph graph) throws DatabaseException {
\r
1503 graph.forEachAssertedObject(subject, relation, procedure);
\r
1506 } catch (DatabaseException e) {
\r
1512 public void forEachAssertedObject(final Resource subject, final Resource relation,
\r
1513 final SyncMultiProcedure<Resource> procedure) {
\r
1515 session.syncRequest(new ReadRequest() {
\r
1518 public void run(ReadGraph graph) throws DatabaseException {
\r
1519 graph.forEachAssertedObject(subject, relation, procedure);
\r
1522 } catch (DatabaseException e) {
\r
1528 public void forEachAssertedStatement(final Resource subject,
\r
1529 final Resource relation, final AsyncMultiProcedure<Statement> procedure) {
\r
1531 session.syncRequest(new ReadRequest() {
\r
1534 public void run(ReadGraph graph) throws DatabaseException {
\r
1535 graph.forEachAssertedStatement(subject, relation, procedure);
\r
1538 } catch (DatabaseException e) {
\r
1544 public void forEachAssertedStatement(final Resource subject,
\r
1545 final Resource relation, final MultiProcedure<Statement> procedure) {
\r
1547 session.syncRequest(new ReadRequest() {
\r
1550 public void run(ReadGraph graph) throws DatabaseException {
\r
1551 graph.forEachAssertedStatement(subject, relation, procedure);
\r
1554 } catch (DatabaseException e) {
\r
1560 public void forEachAssertedStatement(final Resource subject,
\r
1561 final Resource relation, final SyncMultiProcedure<Statement> procedure) {
\r
1563 session.syncRequest(new ReadRequest() {
\r
1566 public void run(ReadGraph graph) throws DatabaseException {
\r
1567 graph.forEachAssertedStatement(subject, relation, procedure);
\r
1570 } catch (DatabaseException e) {
\r
1576 public void forEachDirectObject(final Resource subject, final Resource relation,
\r
1577 final AsyncMultiProcedure<Resource> procedure) {
\r
1579 session.syncRequest(new ReadRequest() {
\r
1582 public void run(ReadGraph graph) throws DatabaseException {
\r
1583 graph.forEachDirectObject(subject, relation, procedure);
\r
1586 } catch (DatabaseException e) {
\r
1592 public void forEachDirectObject(final Resource subject, final Resource relation,
\r
1593 final MultiProcedure<Resource> procedure) {
\r
1595 session.syncRequest(new ReadRequest() {
\r
1598 public void run(ReadGraph graph) throws DatabaseException {
\r
1599 graph.forEachDirectObject(subject, relation, procedure);
\r
1602 } catch (DatabaseException e) {
\r
1608 public void forEachDirectObject(final Resource subject, final Resource relation,
\r
1609 final SyncMultiProcedure<Resource> procedure) {
\r
1611 session.syncRequest(new ReadRequest() {
\r
1614 public void run(ReadGraph graph) throws DatabaseException {
\r
1615 graph.forEachDirectObject(subject, relation, procedure);
\r
1618 } catch (DatabaseException e) {
\r
1624 public void forEachDirectPredicate(final Resource subject,
\r
1625 final AsyncMultiProcedure<Resource> procedure) {
\r
1627 session.syncRequest(new ReadRequest() {
\r
1630 public void run(ReadGraph graph) throws DatabaseException {
\r
1631 graph.forEachDirectPredicate(subject, procedure);
\r
1634 } catch (DatabaseException e) {
\r
1640 public void forEachDirectPredicate(final Resource subject,
\r
1641 final MultiProcedure<Resource> procedure) {
\r
1643 session.syncRequest(new ReadRequest() {
\r
1646 public void run(ReadGraph graph) throws DatabaseException {
\r
1647 graph.forEachDirectPredicate(subject, procedure);
\r
1650 } catch (DatabaseException e) {
\r
1656 public void forEachDirectPredicate(final Resource subject,
\r
1657 final SyncMultiProcedure<Resource> procedure) {
\r
1659 session.syncRequest(new ReadRequest() {
\r
1662 public void run(ReadGraph graph) throws DatabaseException {
\r
1663 graph.forEachDirectPredicate(subject, procedure);
\r
1666 } catch (DatabaseException e) {
\r
1672 public void forEachObject(final Resource subject, final Resource relation,
\r
1673 final AsyncMultiProcedure<Resource> procedure) {
\r
1675 session.syncRequest(new ReadRequest() {
\r
1678 public void run(ReadGraph graph) throws DatabaseException {
\r
1679 graph.forEachObject(subject, relation, procedure);
\r
1682 } catch (DatabaseException e) {
\r
1688 public void forEachObject(final Resource subject, final Resource relation,
\r
1689 final MultiProcedure<Resource> procedure) {
\r
1691 session.syncRequest(new ReadRequest() {
\r
1694 public void run(ReadGraph graph) throws DatabaseException {
\r
1695 graph.forEachObject(subject, relation, procedure);
\r
1698 } catch (DatabaseException e) {
\r
1704 public void forEachObject(final Resource subject, final Resource relation,
\r
1705 final SyncMultiProcedure<Resource> procedure) {
\r
1707 session.syncRequest(new ReadRequest() {
\r
1710 public void run(ReadGraph graph) throws DatabaseException {
\r
1711 graph.forEachObject(subject, relation, procedure);
\r
1714 } catch (DatabaseException e) {
\r
1720 public void forEachPredicate(final Resource subject,
\r
1721 final AsyncMultiProcedure<Resource> procedure) {
\r
1723 session.syncRequest(new ReadRequest() {
\r
1726 public void run(ReadGraph graph) throws DatabaseException {
\r
1727 graph.forEachPredicate(subject, procedure);
\r
1730 } catch (DatabaseException e) {
\r
1736 public void forEachPredicate(final Resource subject,
\r
1737 final MultiProcedure<Resource> procedure) {
\r
1739 session.syncRequest(new ReadRequest() {
\r
1742 public void run(ReadGraph graph) throws DatabaseException {
\r
1743 graph.forEachPredicate(subject, procedure);
\r
1746 } catch (DatabaseException e) {
\r
1752 public void forEachPredicate(final Resource subject,
\r
1753 final SyncMultiProcedure<Resource> procedure) {
\r
1755 session.syncRequest(new ReadRequest() {
\r
1758 public void run(ReadGraph graph) throws DatabaseException {
\r
1759 graph.forEachPredicate(subject, procedure);
\r
1762 } catch (DatabaseException e) {
\r
1768 public void forEachPrincipalType(final Resource subject,
\r
1769 final AsyncMultiProcedure<Resource> procedure) {
\r
1771 session.syncRequest(new ReadRequest() {
\r
1774 public void run(ReadGraph graph) throws DatabaseException {
\r
1775 graph.forEachPrincipalType(subject, procedure);
\r
1778 } catch (DatabaseException e) {
\r
1784 public void forEachPrincipalType(final Resource subject,
\r
1785 final MultiProcedure<Resource> procedure) {
\r
1787 session.syncRequest(new ReadRequest() {
\r
1790 public void run(ReadGraph graph) throws DatabaseException {
\r
1791 graph.forEachPrincipalType(subject, procedure);
\r
1794 } catch (DatabaseException e) {
\r
1800 public void forEachPrincipalType(final Resource subject,
\r
1801 final SyncMultiProcedure<Resource> procedure) {
\r
1803 session.syncRequest(new ReadRequest() {
\r
1806 public void run(ReadGraph graph) throws DatabaseException {
\r
1807 graph.forEachPrincipalType(subject, procedure);
\r
1810 } catch (DatabaseException e) {
\r
1816 public void forEachStatement(final Resource subject, final Resource relation,
\r
1817 final AsyncMultiProcedure<Statement> procedure) {
\r
1819 session.syncRequest(new ReadRequest() {
\r
1822 public void run(ReadGraph graph) throws DatabaseException {
\r
1823 graph.forEachStatement(subject, relation, procedure);
\r
1826 } catch (DatabaseException e) {
\r
1832 public void forEachStatement(final Resource subject, final Resource relation,
\r
1833 final MultiProcedure<Statement> procedure) {
\r
1835 session.syncRequest(new ReadRequest() {
\r
1838 public void run(ReadGraph graph) throws DatabaseException {
\r
1839 graph.forEachStatement(subject, relation, procedure);
\r
1842 } catch (DatabaseException e) {
\r
1848 public void forEachStatement(final Resource subject, final Resource relation,
\r
1849 final SyncMultiProcedure<Statement> procedure) {
\r
1851 session.syncRequest(new ReadRequest() {
\r
1854 public void run(ReadGraph graph) throws DatabaseException {
\r
1855 graph.forEachStatement(subject, relation, procedure);
\r
1858 } catch (DatabaseException e) {
\r
1864 public void forHasStatement(final Resource subject,
\r
1865 final AsyncListener<Boolean> procedure) {
\r
1867 session.syncRequest(new ReadRequest() {
\r
1870 public void run(ReadGraph graph) throws DatabaseException {
\r
1871 graph.forHasStatement(subject, procedure);
\r
1874 } catch (DatabaseException e) {
\r
1880 public void forHasStatement(final Resource subject,
\r
1881 final AsyncProcedure<Boolean> procedure) {
\r
1883 session.syncRequest(new ReadRequest() {
\r
1886 public void run(ReadGraph graph) throws DatabaseException {
\r
1887 graph.forHasStatement(subject, procedure);
\r
1890 } catch (DatabaseException e) {
\r
1896 public void forHasStatement(final Resource subject,
\r
1897 final Listener<Boolean> procedure) {
\r
1899 session.syncRequest(new ReadRequest() {
\r
1902 public void run(ReadGraph graph) throws DatabaseException {
\r
1903 graph.forHasStatement(subject, procedure);
\r
1906 } catch (DatabaseException e) {
\r
1912 public void forHasStatement(final Resource subject,
\r
1913 final Procedure<Boolean> procedure) {
\r
1915 session.syncRequest(new ReadRequest() {
\r
1918 public void run(ReadGraph graph) throws DatabaseException {
\r
1919 graph.forHasStatement(subject, procedure);
\r
1922 } catch (DatabaseException e) {
\r
1929 public void forHasStatement(final Resource subject, final Resource relation,
\r
1930 final AsyncListener<Boolean> procedure) {
\r
1932 session.syncRequest(new ReadRequest() {
\r
1935 public void run(ReadGraph graph) throws DatabaseException {
\r
1936 graph.forHasStatement(subject, relation, procedure);
\r
1939 } catch (DatabaseException e) {
\r
1945 public void forHasStatement(final Resource subject, final Resource relation,
\r
1946 final AsyncProcedure<Boolean> procedure) {
\r
1948 session.syncRequest(new ReadRequest() {
\r
1951 public void run(ReadGraph graph) throws DatabaseException {
\r
1952 graph.forHasStatement(subject, relation, procedure);
\r
1955 } catch (DatabaseException e) {
\r
1961 public void forHasStatement(final Resource subject, final Resource relation,
\r
1962 final Listener<Boolean> procedure) {
\r
1964 session.syncRequest(new ReadRequest() {
\r
1967 public void run(ReadGraph graph) throws DatabaseException {
\r
1968 graph.forHasStatement(subject, relation, procedure);
\r
1971 } catch (DatabaseException e) {
\r
1977 public void forHasStatement(final Resource subject, final Resource relation,
\r
1978 final Procedure<Boolean> procedure) {
\r
1980 session.syncRequest(new ReadRequest() {
\r
1983 public void run(ReadGraph graph) throws DatabaseException {
\r
1984 graph.forHasStatement(subject, relation, procedure);
\r
1987 } catch (DatabaseException e) {
\r
1993 public void forHasStatement(final Resource subject, final Resource relation,
\r
1994 final Resource object, final AsyncListener<Boolean> procedure) {
\r
1996 session.syncRequest(new ReadRequest() {
\r
1999 public void run(ReadGraph graph) throws DatabaseException {
\r
2000 graph.forHasStatement(subject, relation, object, procedure);
\r
2003 } catch (DatabaseException e) {
\r
2009 public void forHasStatement(final Resource subject, final Resource relation,
\r
2010 final Resource object, final AsyncProcedure<Boolean> procedure) {
\r
2012 session.syncRequest(new ReadRequest() {
\r
2015 public void run(ReadGraph graph) throws DatabaseException {
\r
2016 graph.forHasStatement(subject, relation, object, procedure);
\r
2019 } catch (DatabaseException e) {
\r
2025 public void forHasStatement(final Resource subject, final Resource relation,
\r
2026 final Resource object, final Listener<Boolean> procedure) {
\r
2028 session.syncRequest(new ReadRequest() {
\r
2031 public void run(ReadGraph graph) throws DatabaseException {
\r
2032 graph.forHasStatement(subject, relation, object, procedure);
\r
2035 } catch (DatabaseException e) {
\r
2041 public void forHasStatement(final Resource subject, final Resource relation,
\r
2042 final Resource object, final Procedure<Boolean> procedure) {
\r
2044 session.syncRequest(new ReadRequest() {
\r
2047 public void run(ReadGraph graph) throws DatabaseException {
\r
2048 graph.forHasStatement(subject, relation, object, procedure);
\r
2051 } catch (DatabaseException e) {
\r
2057 public void forHasStatement(final Resource subject, final Resource relation,
\r
2058 final Resource object, final SyncListener<Boolean> procedure) {
\r
2060 session.syncRequest(new ReadRequest() {
\r
2063 public void run(ReadGraph graph) throws DatabaseException {
\r
2064 graph.forHasStatement(subject, relation, object, procedure);
\r
2067 } catch (DatabaseException e) {
\r
2073 public void forHasStatement(final Resource subject, final Resource relation,
\r
2074 final Resource object, final SyncProcedure<Boolean> procedure) {
\r
2076 session.syncRequest(new ReadRequest() {
\r
2079 public void run(ReadGraph graph) throws DatabaseException {
\r
2080 graph.forHasStatement(subject, relation, object, procedure);
\r
2083 } catch (DatabaseException e) {
\r
2089 public void forHasStatement(final Resource subject, final Resource relation,
\r
2090 final SyncListener<Boolean> procedure) {
\r
2092 session.syncRequest(new ReadRequest() {
\r
2095 public void run(ReadGraph graph) throws DatabaseException {
\r
2096 graph.forHasStatement(subject, relation, procedure);
\r
2099 } catch (DatabaseException e) {
\r
2105 public void forHasStatement(final Resource subject, final Resource relation,
\r
2106 final SyncProcedure<Boolean> procedure) {
\r
2108 session.syncRequest(new ReadRequest() {
\r
2111 public void run(ReadGraph graph) throws DatabaseException {
\r
2112 graph.forHasStatement(subject, relation, procedure);
\r
2115 } catch (DatabaseException e) {
\r
2121 public void forHasStatement(final Resource subject,
\r
2122 final SyncListener<Boolean> procedure) {
\r
2124 session.syncRequest(new ReadRequest() {
\r
2127 public void run(ReadGraph graph) throws DatabaseException {
\r
2128 graph.forHasStatement(subject, procedure);
\r
2131 } catch (DatabaseException e) {
\r
2137 public void forHasStatement(final Resource subject,
\r
2138 final SyncProcedure<Boolean> procedure) {
\r
2140 session.syncRequest(new ReadRequest() {
\r
2143 public void run(ReadGraph graph) throws DatabaseException {
\r
2144 graph.forHasStatement(subject, procedure);
\r
2147 } catch (DatabaseException e) {
\r
2153 public void forHasValue(final Resource subject,
\r
2154 final AsyncListener<Boolean> procedure) {
\r
2156 session.syncRequest(new ReadRequest() {
\r
2159 public void run(ReadGraph graph) throws DatabaseException {
\r
2160 graph.forHasValue(subject, procedure);
\r
2163 } catch (DatabaseException e) {
\r
2169 public void forHasValue(final Resource subject,
\r
2170 final AsyncProcedure<Boolean> procedure) {
\r
2172 session.syncRequest(new ReadRequest() {
\r
2175 public void run(ReadGraph graph) throws DatabaseException {
\r
2176 graph.forHasValue(subject, procedure);
\r
2179 } catch (DatabaseException e) {
\r
2185 public void forHasValue(final Resource subject, final Listener<Boolean> procedure) {
\r
2187 session.syncRequest(new ReadRequest() {
\r
2190 public void run(ReadGraph graph) throws DatabaseException {
\r
2191 graph.forHasValue(subject, procedure);
\r
2194 } catch (DatabaseException e) {
\r
2200 public void forHasValue(final Resource subject, final Procedure<Boolean> procedure) {
\r
2202 session.syncRequest(new ReadRequest() {
\r
2205 public void run(ReadGraph graph) throws DatabaseException {
\r
2206 graph.forHasValue(subject, procedure);
\r
2209 } catch (DatabaseException e) {
\r
2215 public void forHasValue(final Resource subject,
\r
2216 final SyncListener<Boolean> procedure) {
\r
2218 session.syncRequest(new ReadRequest() {
\r
2221 public void run(ReadGraph graph) throws DatabaseException {
\r
2222 graph.forHasValue(subject, procedure);
\r
2225 } catch (DatabaseException e) {
\r
2231 public void forHasValue(final Resource subject,
\r
2232 final SyncProcedure<Boolean> procedure) {
\r
2234 session.syncRequest(new ReadRequest() {
\r
2237 public void run(ReadGraph graph) throws DatabaseException {
\r
2238 graph.forHasValue(subject, procedure);
\r
2241 } catch (DatabaseException e) {
\r
2247 public void forInverse(final Resource relation,
\r
2248 final AsyncListener<Resource> procedure) {
\r
2250 session.syncRequest(new ReadRequest() {
\r
2253 public void run(ReadGraph graph) throws DatabaseException {
\r
2254 graph.forInverse(relation, procedure);
\r
2257 } catch (DatabaseException e) {
\r
2263 public <T> T getService(Class<T> api) throws ServiceNotFoundException {
\r
2264 return session.getService(api);
\r
2268 public <T> T peekService(Class<T> api) {
\r
2269 return session.peekService(api);
\r
2273 public boolean hasService(Class<?> api) {
\r
2274 return session.hasService(api);
\r
2278 public <T> void registerService(Class<T> api, T service) {
\r
2279 session.registerService(api, service);
\r
2283 public String getURI(final Resource resource)
\r
2284 throws ValidationException,
\r
2285 ServiceException, AssumptionException {
\r
2287 return session.syncRequest(new Read<String>() {
\r
2290 public String perform(ReadGraph graph) throws DatabaseException {
\r
2291 return graph.getURI(resource);
\r
2294 } catch (DatabaseException e) {
\r
2295 throw new ServiceException(e);
\r
2301 public String getPossibleURI(final Resource resource)
\r
2302 throws ValidationException,
\r
2303 ServiceException {
\r
2305 return session.syncRequest(new Read<String>() {
\r
2308 public String perform(ReadGraph graph) throws DatabaseException {
\r
2309 return graph.getPossibleURI(resource);
\r
2312 } catch (DatabaseException e) {
\r
2313 throw new ServiceException(e);
\r
2318 public Resource getResource(final String uri)
\r
2319 throws ResourceNotFoundException, ValidationException,
\r
2320 ServiceException {
\r
2322 return session.syncRequest(new Read<Resource>() {
\r
2325 public Resource perform(ReadGraph graph) throws DatabaseException {
\r
2326 return graph.getResource(uri);
\r
2329 } catch (DatabaseException e) {
\r
2330 throw new ServiceException(e);
\r
2335 public Resource getPossibleResource(final String uri)
\r
2336 throws ResourceNotFoundException, ValidationException,
\r
2337 ServiceException {
\r
2339 return session.syncRequest(new Read<Resource>() {
\r
2342 public Resource perform(ReadGraph graph) throws DatabaseException {
\r
2343 return graph.getPossibleResource(uri);
\r
2346 } catch (DatabaseException e) {
\r
2347 throw new ServiceException(e);
\r
2352 public Collection<Statement> getStatements(final Resource subject,
\r
2353 final Resource relation)
\r
2354 throws ManyObjectsForFunctionalRelationException,
\r
2355 ServiceException {
\r
2357 return session.syncRequest(new Read<Collection<Statement>>() {
\r
2360 public Collection<Statement> perform(ReadGraph graph) throws DatabaseException {
\r
2361 return graph.getStatements(subject, relation);
\r
2364 } catch (DatabaseException e) {
\r
2365 throw new ServiceException(e);
\r
2370 public Collection<Statement> getAssertedStatements(final Resource subject,
\r
2371 final Resource relation)
\r
2372 throws ManyObjectsForFunctionalRelationException,
\r
2373 ServiceException {
\r
2375 return session.syncRequest(new Read<Collection<Statement>>() {
\r
2378 public Collection<Statement> perform(ReadGraph graph) throws DatabaseException {
\r
2379 return graph.getAssertedStatements(subject, relation);
\r
2382 } catch (DatabaseException e) {
\r
2383 throw new ServiceException(e);
\r
2388 public Collection<Resource> getPredicates(final Resource subject)
\r
2389 throws ServiceException {
\r
2391 return session.syncRequest(new Read<Collection<Resource>>() {
\r
2394 public Collection<Resource> perform(ReadGraph graph) throws DatabaseException {
\r
2395 return graph.getPredicates(subject);
\r
2398 } catch (DatabaseException e) {
\r
2399 throw new ServiceException(e);
\r
2404 public Collection<Resource> getPrincipalTypes(final Resource subject)
\r
2405 throws ServiceException {
\r
2407 return session.syncRequest(new Read<Collection<Resource>>() {
\r
2410 public Collection<Resource> perform(ReadGraph graph) throws DatabaseException {
\r
2411 return graph.getPrincipalTypes(subject);
\r
2414 } catch (DatabaseException e) {
\r
2415 throw new ServiceException(e);
\r
2420 public Set<Resource> getTypes(final Resource subject) throws ServiceException {
\r
2422 return session.syncRequest(new Read<Set<Resource>>() {
\r
2425 public Set<Resource> perform(ReadGraph graph) throws DatabaseException {
\r
2426 return graph.getTypes(subject);
\r
2429 } catch (DatabaseException e) {
\r
2430 throw new ServiceException(e);
\r
2435 public Set<Resource> getSupertypes(final Resource subject)
\r
2436 throws ServiceException {
\r
2438 return session.syncRequest(new Read<Set<Resource>>() {
\r
2441 public Set<Resource> perform(ReadGraph graph) throws DatabaseException {
\r
2442 return graph.getSupertypes(subject);
\r
2445 } catch (DatabaseException e) {
\r
2446 throw new ServiceException(e);
\r
2451 public Set<Resource> getSuperrelations(final Resource subject)
\r
2452 throws ServiceException {
\r
2454 return session.syncRequest(new Read<Set<Resource>>() {
\r
2457 public Set<Resource> perform(ReadGraph graph) throws DatabaseException {
\r
2458 return graph.getSuperrelations(subject);
\r
2461 } catch (DatabaseException e) {
\r
2462 throw new ServiceException(e);
\r
2467 // public Collection<Resource> getObjects(final Resource subject,
\r
2468 // Resource relation)
\r
2469 // throws ManyObjectsForFunctionalRelationException,
\r
2470 // ServiceException {
\r
2471 // return graph.getObjects(subject, relation);
\r
2475 public Collection<Resource> getAssertedObjects(final Resource subject, final Resource relation)
\r
2476 throws ManyObjectsForFunctionalRelationException,
\r
2477 ServiceException {
\r
2479 return session.syncRequest(new Read<Collection<Resource>>() {
\r
2482 public Collection<Resource> perform(ReadGraph graph) throws DatabaseException {
\r
2483 return graph.getAssertedObjects(subject, relation);
\r
2486 } catch (DatabaseException e) {
\r
2487 throw new ServiceException(e);
\r
2492 public Resource getInverse(final Resource relation)
\r
2493 throws NoInverseException,
\r
2494 ManyObjectsForFunctionalRelationException, ServiceException {
\r
2496 return session.syncRequest(new Read<Resource>() {
\r
2499 public Resource perform(ReadGraph graph) throws DatabaseException {
\r
2500 return graph.getInverse(relation);
\r
2503 } catch (DatabaseException e) {
\r
2504 throw new ServiceException(e);
\r
2509 public Resource getSingleObject(final Resource subject, final Resource relation)
\r
2510 throws NoSingleResultException,
\r
2511 ManyObjectsForFunctionalRelationException, ServiceException {
\r
2513 return session.syncRequest(new Read<Resource>() {
\r
2516 public Resource perform(ReadGraph graph) throws DatabaseException {
\r
2517 return graph.getSingleObject(subject, relation);
\r
2520 } catch (DatabaseException e) {
\r
2521 throw new ServiceException(e);
\r
2526 public Statement getSingleStatement(final Resource subject, final Resource relation)
\r
2527 throws NoSingleResultException,
\r
2528 ManyObjectsForFunctionalRelationException, ServiceException {
\r
2530 return session.syncRequest(new Read<Statement>() {
\r
2533 public Statement perform(ReadGraph graph) throws DatabaseException {
\r
2534 return graph.getSingleStatement(subject, relation);
\r
2537 } catch (DatabaseException e) {
\r
2538 throw new ServiceException(e);
\r
2543 public Resource getSingleType(final Resource subject)
\r
2544 throws NoSingleResultException, ServiceException {
\r
2546 return session.syncRequest(new Read<Resource>() {
\r
2549 public Resource perform(ReadGraph graph) throws DatabaseException {
\r
2550 return graph.getSingleType(subject);
\r
2553 } catch (DatabaseException e) {
\r
2554 throw new ServiceException(e);
\r
2559 public Resource getSingleType(final Resource subject, final Resource baseType)
\r
2560 throws NoSingleResultException, ServiceException {
\r
2562 return session.syncRequest(new Read<Resource>() {
\r
2565 public Resource perform(ReadGraph graph) throws DatabaseException {
\r
2566 return graph.getSingleType(subject, baseType);
\r
2569 } catch (DatabaseException e) {
\r
2570 throw new ServiceException(e);
\r
2575 public <T> T getValue(final Resource subject)
\r
2576 throws DoesNotContainValueException, ServiceException {
\r
2578 return session.syncRequest(new Read<T>() {
\r
2581 public T perform(ReadGraph graph) throws DatabaseException {
\r
2582 return graph.getValue(subject);
\r
2585 } catch (DatabaseException e) {
\r
2586 throw new ServiceException(e);
\r
2591 public <T> T getValue(final Resource subject, final Binding binding)
\r
2592 throws DoesNotContainValueException, BindingException,
\r
2593 ServiceException {
\r
2595 return session.syncRequest(new Read<T>() {
\r
2598 public T perform(ReadGraph graph) throws DatabaseException {
\r
2599 return graph.getValue(subject, binding);
\r
2602 } catch (DatabaseException e) {
\r
2603 throw new ServiceException(e);
\r
2608 public <T> T getRelatedValue(final Resource subject, final Resource relation)
\r
2609 throws NoSingleResultException, DoesNotContainValueException,
\r
2610 ServiceException {
\r
2612 return session.syncRequest(new Read<T>() {
\r
2615 public T perform(ReadGraph graph) throws DatabaseException {
\r
2616 return graph.getRelatedValue(subject, relation);
\r
2619 } catch (DatabaseException e) {
\r
2620 throw new ServiceException(e);
\r
2625 public <T> T getRelatedValue(final Resource subject, final Resource relation,
\r
2626 final Binding binding) throws NoSingleResultException,
\r
2627 DoesNotContainValueException, BindingException,
\r
2628 ServiceException {
\r
2630 return session.syncRequest(new Read<T>() {
\r
2633 public T perform(ReadGraph graph) throws DatabaseException {
\r
2634 return graph.getRelatedValue(subject, relation, binding);
\r
2637 } catch (DatabaseException e) {
\r
2638 throw new ServiceException(e);
\r
2643 public Resource getPossibleInverse(final Resource relation)
\r
2644 throws ManyObjectsForFunctionalRelationException,
\r
2645 ServiceException {
\r
2647 return session.syncRequest(new Read<Resource>() {
\r
2650 public Resource perform(ReadGraph graph) throws DatabaseException {
\r
2651 return graph.getPossibleInverse(relation);
\r
2654 } catch (DatabaseException e) {
\r
2655 throw new ServiceException(e);
\r
2660 public Resource getPossibleObject(final Resource subject, final Resource relation)
\r
2661 throws ManyObjectsForFunctionalRelationException,
\r
2662 ServiceException {
\r
2664 return session.syncRequest(new Read<Resource>() {
\r
2667 public Resource perform(ReadGraph graph) throws DatabaseException {
\r
2668 return graph.getPossibleObject(subject, relation);
\r
2671 } catch (DatabaseException e) {
\r
2672 throw new ServiceException(e);
\r
2677 public Statement getPossibleStatement(final Resource subject,
\r
2678 final Resource relation)
\r
2679 throws ManyObjectsForFunctionalRelationException,
\r
2680 ServiceException {
\r
2682 return session.syncRequest(new Read<Statement>() {
\r
2685 public Statement perform(ReadGraph graph) throws DatabaseException {
\r
2686 return graph.getPossibleStatement(subject, relation);
\r
2689 } catch (DatabaseException e) {
\r
2690 throw new ServiceException(e);
\r
2695 public Resource getPossibleType(final Resource subject, final Resource baseType)
\r
2696 throws ServiceException {
\r
2698 return session.syncRequest(new Read<Resource>() {
\r
2701 public Resource perform(ReadGraph graph) throws DatabaseException {
\r
2702 return graph.getPossibleType(subject, baseType);
\r
2705 } catch (DatabaseException e) {
\r
2706 throw new ServiceException(e);
\r
2711 public <T> T getPossibleValue(final Resource subject) throws ServiceException {
\r
2713 return session.syncRequest(new Read<T>() {
\r
2716 public T perform(ReadGraph graph) throws DatabaseException {
\r
2717 return graph.getPossibleValue(subject);
\r
2720 } catch (DatabaseException e) {
\r
2721 throw new ServiceException(e);
\r
2726 public <T> T getPossibleValue(final Resource subject, final Binding binding)
\r
2727 throws BindingException, ServiceException {
\r
2729 return session.syncRequest(new Read<T>() {
\r
2732 public T perform(ReadGraph graph) throws DatabaseException {
\r
2733 return graph.getPossibleValue(subject, binding);
\r
2736 } catch (DatabaseException e) {
\r
2737 throw new ServiceException(e);
\r
2742 public <T> T getPossibleRelatedValue(final Resource subject, final Resource relation)
\r
2743 throws ManyObjectsForFunctionalRelationException,
\r
2744 ServiceException {
\r
2746 return session.syncRequest(new Read<T>() {
\r
2749 public T perform(ReadGraph graph) throws DatabaseException {
\r
2750 return graph.getPossibleRelatedValue(subject, relation);
\r
2753 } catch (DatabaseException e) {
\r
2754 throw new ServiceException(e);
\r
2759 public <T> T getPossibleRelatedValue(final Resource subject,
\r
2760 final Resource relation, final Binding binding)
\r
2761 throws ManyObjectsForFunctionalRelationException,
\r
2762 BindingException, ServiceException {
\r
2764 return session.syncRequest(new Read<T>() {
\r
2767 public T perform(ReadGraph graph) throws DatabaseException {
\r
2768 return graph.getPossibleRelatedValue(subject, relation, binding);
\r
2771 } catch (DatabaseException e) {
\r
2772 throw new ServiceException(e);
\r
2777 public <T> T getPossibleAdapter(final Resource resource, final Class<T> clazz)
\r
2778 throws ValidationException, ServiceException {
\r
2780 return session.syncRequest(new Read<T>() {
\r
2783 public T perform(ReadGraph graph) throws DatabaseException {
\r
2784 return graph.getPossibleAdapter(resource, clazz);
\r
2787 } catch (DatabaseException e) {
\r
2788 throw new ServiceException(e);
\r
2793 public <T> T getPossibleUniqueAdapter(final Resource resource, final Class<T> clazz)
\r
2794 throws ValidationException, ServiceException {
\r
2796 return session.syncRequest(new Read<T>() {
\r
2799 public T perform(ReadGraph graph) throws DatabaseException {
\r
2800 return graph.getPossibleUniqueAdapter(resource, clazz);
\r
2803 } catch (DatabaseException e) {
\r
2804 throw new ServiceException(e);
\r
2809 public boolean isInstanceOf(final Resource resource, final Resource type)
\r
2810 throws ServiceException {
\r
2812 return session.syncRequest(new Read<Boolean>() {
\r
2815 public Boolean perform(ReadGraph graph) throws DatabaseException {
\r
2816 return graph.isInstanceOf(resource, type);
\r
2819 } catch (DatabaseException e) {
\r
2820 throw new ServiceException(e);
\r
2825 public boolean isInheritedFrom(final Resource resource, final Resource type)
\r
2826 throws ServiceException {
\r
2828 return session.syncRequest(new Read<Boolean>() {
\r
2831 public Boolean perform(ReadGraph graph) throws DatabaseException {
\r
2832 return graph.isInheritedFrom(resource, type);
\r
2835 } catch (DatabaseException e) {
\r
2836 throw new ServiceException(e);
\r
2841 public boolean isSubrelationOf(final Resource resource, final Resource relation)
\r
2842 throws ServiceException {
\r
2844 return session.syncRequest(new Read<Boolean>() {
\r
2847 public Boolean perform(ReadGraph graph) throws DatabaseException {
\r
2848 return graph.isSubrelationOf(resource, relation);
\r
2851 } catch (DatabaseException e) {
\r
2852 throw new ServiceException(e);
\r
2857 public boolean hasStatement(final Resource subject) throws ServiceException {
\r
2859 return session.syncRequest(new Read<Boolean>() {
\r
2862 public Boolean perform(ReadGraph graph) throws DatabaseException {
\r
2863 return graph.hasStatement(subject);
\r
2866 } catch (DatabaseException e) {
\r
2867 throw new ServiceException(e);
\r
2872 public boolean hasStatement(final Resource subject, final Resource relation)
\r
2873 throws ServiceException {
\r
2875 return session.syncRequest(new Read<Boolean>() {
\r
2878 public Boolean perform(ReadGraph graph) throws DatabaseException {
\r
2879 return graph.hasStatement(subject, relation);
\r
2882 } catch (DatabaseException e) {
\r
2883 throw new ServiceException(e);
\r
2888 public boolean hasStatement(final Resource subject, final Resource relation,
\r
2889 final Resource object) throws ServiceException {
\r
2891 return session.syncRequest(new Read<Boolean>() {
\r
2894 public Boolean perform(ReadGraph graph) throws DatabaseException {
\r
2895 return graph.hasStatement(subject, relation, object);
\r
2898 } catch (DatabaseException e) {
\r
2899 throw new ServiceException(e);
\r
2904 public boolean hasValue(final Resource subject) throws ServiceException {
\r
2906 return session.syncRequest(new Read<Boolean>() {
\r
2909 public Boolean perform(ReadGraph graph) throws DatabaseException {
\r
2910 return graph.hasValue(subject);
\r
2913 } catch (DatabaseException e) {
\r
2914 throw new ServiceException(e);
\r
2919 public Datatype getDataType(final Resource subject) throws DatabaseException {
\r
2921 return session.syncRequest(new Read<Datatype>() {
\r
2924 public Datatype perform(ReadGraph graph) throws DatabaseException {
\r
2925 return graph.getDataType(subject);
\r
2928 } catch (DatabaseException e) {
\r
2929 throw new ServiceException(e);
\r
2934 public <T extends Accessor> T getAccessor(final Resource subject)
\r
2935 throws DatabaseException {
\r
2937 return session.syncRequest(new Read<T>() {
\r
2940 public T perform(ReadGraph graph) throws DatabaseException {
\r
2941 return graph.getAccessor(subject);
\r
2944 } catch (DatabaseException e) {
\r
2945 throw new ServiceException(e);
\r
2950 public RandomAccessBinary getRandomAccessBinary(final Resource subject)
\r
2951 throws DatabaseException {
\r
2953 return session.syncRequest(new Read<RandomAccessBinary>() {
\r
2955 public RandomAccessBinary perform(ReadGraph graph) throws DatabaseException {
\r
2956 return graph.getRandomAccessBinary(subject);
\r
2959 } catch (DatabaseException e) {
\r
2960 throw new ServiceException(e);
\r
2965 public <T> T syncRequest(Read<T> request) throws DatabaseException {
\r
2966 return session.syncRequest(request);
\r
2970 public <T> T syncRequest(Read<T> request, AsyncListener<T> procedure)
\r
2971 throws DatabaseException {
\r
2972 return session.syncRequest(request, procedure);
\r
2976 public <T> T syncRequest(Read<T> request, SyncListener<T> procedure)
\r
2977 throws DatabaseException {
\r
2978 return session.syncRequest(request, procedure);
\r
2982 public <T> T syncRequest(Read<T> request, Listener<T> procedure)
\r
2983 throws DatabaseException {
\r
2984 return session.syncRequest(request, procedure);
\r
2988 public <T> T syncRequest(Read<T> request, AsyncProcedure<T> procedure)
\r
2989 throws DatabaseException {
\r
2990 return session.syncRequest(request, procedure);
\r
2994 public <T> T syncRequest(Read<T> request, SyncProcedure<T> procedure)
\r
2995 throws DatabaseException {
\r
2996 return session.syncRequest(request, procedure);
\r
3000 public <T> T syncRequest(Read<T> request, Procedure<T> procedure)
\r
3001 throws DatabaseException {
\r
3002 return session.syncRequest(request, procedure);
\r
3006 public <T> T syncRequest(AsyncRead<T> request) throws DatabaseException {
\r
3007 return session.syncRequest(request);
\r
3011 public <T> T syncRequest(AsyncRead<T> request,
\r
3012 AsyncListener<T> procedure) throws DatabaseException {
\r
3013 return session.syncRequest(request, procedure);
\r
3017 public <T> T syncRequest(AsyncRead<T> request, SyncListener<T> procedure)
\r
3018 throws DatabaseException {
\r
3019 return session.syncRequest(request, procedure);
\r
3023 public <T> T syncRequest(AsyncRead<T> request, Listener<T> procedure)
\r
3024 throws DatabaseException {
\r
3025 return session.syncRequest(request, procedure);
\r
3029 public <T> T syncRequest(AsyncRead<T> request,
\r
3030 AsyncProcedure<T> procedure) throws DatabaseException {
\r
3031 return session.syncRequest(request, procedure);
\r
3035 public <T> T syncRequest(AsyncRead<T> request,
\r
3036 SyncProcedure<T> procedure) throws DatabaseException {
\r
3037 return session.syncRequest(request, procedure);
\r
3041 public <T> T syncRequest(AsyncRead<T> request, Procedure<T> procedure)
\r
3042 throws DatabaseException {
\r
3043 return session.syncRequest(request, procedure);
\r
3047 public <T> Collection<T> syncRequest(MultiRead<T> request)
\r
3048 throws DatabaseException {
\r
3049 return session.syncRequest(request);
\r
3053 public <T> Collection<T> syncRequest(MultiRead<T> request,
\r
3054 AsyncMultiListener<T> procedure) throws DatabaseException {
\r
3055 return session.syncRequest(request, procedure);
\r
3059 public <T> Collection<T> syncRequest(MultiRead<T> request,
\r
3060 SyncMultiListener<T> procedure) throws DatabaseException {
\r
3061 return session.syncRequest(request, procedure);
\r
3065 public <T> Collection<T> syncRequest(MultiRead<T> request,
\r
3066 MultiListener<T> procedure) throws DatabaseException {
\r
3067 return session.syncRequest(request, procedure);
\r
3071 public <T> Collection<T> syncRequest(MultiRead<T> request,
\r
3072 AsyncMultiProcedure<T> procedure) throws DatabaseException {
\r
3073 return session.syncRequest(request, procedure);
\r
3077 public <T> Collection<T> syncRequest(MultiRead<T> request,
\r
3078 SyncMultiProcedure<T> procedure) throws DatabaseException {
\r
3079 return session.syncRequest(request, procedure);
\r
3083 public <T> Collection<T> syncRequest(MultiRead<T> request,
\r
3084 MultiProcedure<T> procedure) throws DatabaseException {
\r
3085 return session.syncRequest(request, procedure);
\r
3089 public <T> Collection<T> syncRequest(AsyncMultiRead<T> request)
\r
3090 throws DatabaseException {
\r
3091 return session.syncRequest(request);
\r
3095 public <T> Collection<T> syncRequest(AsyncMultiRead<T> request,
\r
3096 AsyncMultiListener<T> procedure) throws DatabaseException {
\r
3097 return session.syncRequest(request, procedure);
\r
3101 public <T> Collection<T> syncRequest(AsyncMultiRead<T> request,
\r
3102 SyncMultiListener<T> procedure) throws DatabaseException {
\r
3103 return session.syncRequest(request, procedure);
\r
3107 public <T> Collection<T> syncRequest(AsyncMultiRead<T> request,
\r
3108 MultiListener<T> procedure) throws DatabaseException {
\r
3109 return session.syncRequest(request, procedure);
\r
3113 public <T> Collection<T> syncRequest(AsyncMultiRead<T> request,
\r
3114 AsyncMultiProcedure<T> procedure) throws DatabaseException {
\r
3115 return session.syncRequest(request, procedure);
\r
3119 public <T> Collection<T> syncRequest(AsyncMultiRead<T> request,
\r
3120 SyncMultiProcedure<T> procedure) throws DatabaseException {
\r
3121 return session.syncRequest(request, procedure);
\r
3125 public <T> Collection<T> syncRequest(AsyncMultiRead<T> request,
\r
3126 MultiProcedure<T> procedure) throws DatabaseException {
\r
3127 return session.syncRequest(request, procedure);
\r
3131 public <T> T syncRequest(ExternalRead<T> request)
\r
3132 throws DatabaseException {
\r
3133 return session.syncRequest(request);
\r
3137 public <T> T syncRequest(ExternalRead<T> request, Listener<T> procedure)
\r
3138 throws DatabaseException {
\r
3139 return session.syncRequest(request, procedure);
\r
3143 public <T> T syncRequest(ExternalRead<T> request, Procedure<T> procedure)
\r
3144 throws DatabaseException {
\r
3145 return session.syncRequest(request, procedure);
\r
3149 public void syncRequest(Write request) throws DatabaseException {
\r
3150 session.syncRequest(request);
\r
3154 public void syncRequest(DelayedWrite request) throws DatabaseException {
\r
3155 session.syncRequest(request);
\r
3159 public void syncRequest(WriteOnly r) throws DatabaseException {
\r
3160 session.syncRequest(r);
\r
3164 public <T> T syncRequest(WriteResult<T> request)
\r
3165 throws DatabaseException {
\r
3166 return session.syncRequest(request);
\r
3170 public <T> T syncRequest(DelayedWriteResult<T> request)
\r
3171 throws DatabaseException {
\r
3172 return session.syncRequest(request);
\r
3176 public <T> T syncRequest(WriteOnlyResult<T> r) throws DatabaseException {
\r
3177 return session.syncRequest(r);
\r
3181 public void forURI(final Resource resource, final AsyncListener<String> procedure) {
\r
3183 session.syncRequest(new ReadRequest() {
\r
3186 public void run(ReadGraph graph) throws DatabaseException {
\r
3187 graph.forURI(resource, procedure);
\r
3190 } catch (DatabaseException e) {
\r
3196 public void forURI(final Resource resource, final SyncListener<String> procedure) {
\r
3198 session.syncRequest(new ReadRequest() {
\r
3201 public void run(ReadGraph graph) throws DatabaseException {
\r
3202 graph.forURI(resource, procedure);
\r
3205 } catch (DatabaseException e) {
\r
3211 public void forURI(final Resource resource, final Listener<String> procedure) {
\r
3213 session.syncRequest(new ReadRequest() {
\r
3216 public void run(ReadGraph graph) throws DatabaseException {
\r
3217 graph.forURI(resource, procedure);
\r
3220 } catch (DatabaseException e) {
\r
3226 public void forURI(final Resource resource, final AsyncProcedure<String> procedure) {
\r
3228 session.syncRequest(new ReadRequest() {
\r
3231 public void run(ReadGraph graph) throws DatabaseException {
\r
3232 graph.forURI(resource, procedure);
\r
3235 } catch (DatabaseException e) {
\r
3241 public void forURI(final Resource resource, final SyncProcedure<String> procedure) {
\r
3243 session.syncRequest(new ReadRequest() {
\r
3246 public void run(ReadGraph graph) throws DatabaseException {
\r
3247 graph.forURI(resource, procedure);
\r
3250 } catch (DatabaseException e) {
\r
3256 public void forURI(final Resource resource, final Procedure<String> procedure) {
\r
3258 session.syncRequest(new ReadRequest() {
\r
3261 public void run(ReadGraph graph) throws DatabaseException {
\r
3262 graph.forURI(resource, procedure);
\r
3265 } catch (DatabaseException e) {
\r
3271 public void forResource(final String id, final AsyncListener<Resource> procedure) {
\r
3273 session.syncRequest(new ReadRequest() {
\r
3276 public void run(ReadGraph graph) throws DatabaseException {
\r
3277 graph.forResource(id, procedure);
\r
3280 } catch (DatabaseException e) {
\r
3286 public void forResource(final String id, final SyncListener<Resource> procedure) {
\r
3288 session.syncRequest(new ReadRequest() {
\r
3291 public void run(ReadGraph graph) throws DatabaseException {
\r
3292 graph.forResource(id, procedure);
\r
3295 } catch (DatabaseException e) {
\r
3301 public void forResource(final String id, final Listener<Resource> procedure) {
\r
3303 session.syncRequest(new ReadRequest() {
\r
3306 public void run(ReadGraph graph) throws DatabaseException {
\r
3307 graph.forResource(id, procedure);
\r
3310 } catch (DatabaseException e) {
\r
3316 public void forResource(final String id, final AsyncProcedure<Resource> procedure) {
\r
3318 session.syncRequest(new ReadRequest() {
\r
3321 public void run(ReadGraph graph) throws DatabaseException {
\r
3322 graph.forResource(id, procedure);
\r
3325 } catch (DatabaseException e) {
\r
3331 public void forResource(final String id, final SyncProcedure<Resource> procedure) {
\r
3333 session.syncRequest(new ReadRequest() {
\r
3336 public void run(ReadGraph graph) throws DatabaseException {
\r
3337 graph.forResource(id, procedure);
\r
3340 } catch (DatabaseException e) {
\r
3346 public void forResource(final String id, final Procedure<Resource> procedure) {
\r
3348 session.syncRequest(new ReadRequest() {
\r
3351 public void run(ReadGraph graph) throws DatabaseException {
\r
3352 graph.forResource(id, procedure);
\r
3355 } catch (DatabaseException e) {
\r
3361 public void forStatementSet(final Resource subject, final Resource relation,
\r
3362 final AsyncSetListener<Statement> procedure) {
\r
3364 session.syncRequest(new ReadRequest() {
\r
3367 public void run(ReadGraph graph) throws DatabaseException {
\r
3368 graph.forStatementSet(subject, relation, procedure);
\r
3371 } catch (DatabaseException e) {
\r
3377 public void forStatementSet(final Resource subject, final Resource relation,
\r
3378 final SyncSetListener<Statement> procedure) {
\r
3381 session.syncRequest(new ReadRequest() {
\r
3384 public void run(ReadGraph graph) throws DatabaseException {
\r
3385 graph.forStatementSet(subject, relation, procedure);
\r
3388 } catch (DatabaseException e) {
\r
3394 public void forStatementSet(final Resource subject, final Resource relation,
\r
3395 final SetListener<Statement> procedure) {
\r
3397 session.syncRequest(new ReadRequest() {
\r
3400 public void run(ReadGraph graph) throws DatabaseException {
\r
3401 graph.forStatementSet(subject, relation, procedure);
\r
3404 } catch (DatabaseException e) {
\r
3410 public void forPredicateSet(final Resource subject,
\r
3411 final AsyncSetListener<Resource> procedure) {
\r
3413 session.syncRequest(new ReadRequest() {
\r
3416 public void run(ReadGraph graph) throws DatabaseException {
\r
3417 graph.forPredicateSet(subject, procedure);
\r
3420 } catch (DatabaseException e) {
\r
3426 public void forPredicateSet(final Resource subject,
\r
3427 final SyncSetListener<Resource> procedure) {
\r
3429 session.syncRequest(new ReadRequest() {
\r
3432 public void run(ReadGraph graph) throws DatabaseException {
\r
3433 graph.forPredicateSet(subject, procedure);
\r
3436 } catch (DatabaseException e) {
\r
3442 public void forPredicateSet(final Resource subject,
\r
3443 final SetListener<Resource> procedure) {
\r
3445 session.syncRequest(new ReadRequest() {
\r
3448 public void run(ReadGraph graph) throws DatabaseException {
\r
3449 graph.forPredicateSet(subject, procedure);
\r
3452 } catch (DatabaseException e) {
\r
3458 public void forPrincipalTypeSet(final Resource subject,
\r
3459 final AsyncSetListener<Resource> procedure) {
\r
3461 session.syncRequest(new ReadRequest() {
\r
3464 public void run(ReadGraph graph) throws DatabaseException {
\r
3465 graph.forPrincipalTypeSet(subject, procedure);
\r
3468 } catch (DatabaseException e) {
\r
3474 public void forPrincipalTypeSet(final Resource subject,
\r
3475 final SyncSetListener<Resource> procedure) {
\r
3477 session.syncRequest(new ReadRequest() {
\r
3480 public void run(ReadGraph graph) throws DatabaseException {
\r
3481 graph.forPrincipalTypeSet(subject, procedure);
\r
3484 } catch (DatabaseException e) {
\r
3490 public void forPrincipalTypeSet(final Resource subject,
\r
3491 final SetListener<Resource> procedure) {
\r
3493 session.syncRequest(new ReadRequest() {
\r
3496 public void run(ReadGraph graph) throws DatabaseException {
\r
3497 graph.forPrincipalTypeSet(subject, procedure);
\r
3500 } catch (DatabaseException e) {
\r
3506 public void forTypes(final Resource subject,
\r
3507 final AsyncListener<Set<Resource>> procedure) {
\r
3509 session.syncRequest(new ReadRequest() {
\r
3512 public void run(ReadGraph graph) throws DatabaseException {
\r
3513 graph.forTypes(subject, procedure);
\r
3516 } catch (DatabaseException e) {
\r
3522 public void forTypes(final Resource subject,
\r
3523 final SyncListener<Set<Resource>> procedure) {
\r
3525 session.syncRequest(new ReadRequest() {
\r
3528 public void run(ReadGraph graph) throws DatabaseException {
\r
3529 graph.forTypes(subject, procedure);
\r
3532 } catch (DatabaseException e) {
\r
3538 public void forTypes(final Resource subject, final Listener<Set<Resource>> procedure) {
\r
3540 session.syncRequest(new ReadRequest() {
\r
3543 public void run(ReadGraph graph) throws DatabaseException {
\r
3544 graph.forTypes(subject, procedure);
\r
3547 } catch (DatabaseException e) {
\r
3553 public void forTypes(final Resource subject,
\r
3554 final AsyncProcedure<Set<Resource>> procedure) {
\r
3556 session.syncRequest(new ReadRequest() {
\r
3559 public void run(ReadGraph graph) throws DatabaseException {
\r
3560 graph.forTypes(subject, procedure);
\r
3563 } catch (DatabaseException e) {
\r
3569 public void forTypes(final Resource subject,
\r
3570 final SyncProcedure<Set<Resource>> procedure) {
\r
3572 session.syncRequest(new ReadRequest() {
\r
3575 public void run(ReadGraph graph) throws DatabaseException {
\r
3576 graph.forTypes(subject, procedure);
\r
3579 } catch (DatabaseException e) {
\r
3585 public void forTypes(final Resource subject,
\r
3586 final Procedure<Set<Resource>> procedure) {
\r
3588 session.syncRequest(new ReadRequest() {
\r
3591 public void run(ReadGraph graph) throws DatabaseException {
\r
3592 graph.forTypes(subject, procedure);
\r
3595 } catch (DatabaseException e) {
\r
3601 public void forSupertypes(final Resource subject,
\r
3602 final AsyncListener<Set<Resource>> procedure) {
\r
3604 session.syncRequest(new ReadRequest() {
\r
3607 public void run(ReadGraph graph) throws DatabaseException {
\r
3608 graph.forSupertypes(subject, procedure);
\r
3611 } catch (DatabaseException e) {
\r
3617 public void forSupertypes(final Resource subject,
\r
3618 final SyncListener<Set<Resource>> procedure) {
\r
3620 session.syncRequest(new ReadRequest() {
\r
3623 public void run(ReadGraph graph) throws DatabaseException {
\r
3624 graph.forSupertypes(subject, procedure);
\r
3627 } catch (DatabaseException e) {
\r
3633 public void forSupertypes(final Resource subject,
\r
3634 final Listener<Set<Resource>> procedure) {
\r
3636 session.syncRequest(new ReadRequest() {
\r
3639 public void run(ReadGraph graph) throws DatabaseException {
\r
3640 graph.forSupertypes(subject, procedure);
\r
3643 } catch (DatabaseException e) {
\r
3649 public void forSupertypes(final Resource subject,
\r
3650 final AsyncProcedure<Set<Resource>> procedure) {
\r
3652 session.syncRequest(new ReadRequest() {
\r
3655 public void run(ReadGraph graph) throws DatabaseException {
\r
3656 graph.forSupertypes(subject, procedure);
\r
3659 } catch (DatabaseException e) {
\r
3665 public void forSupertypes(final Resource subject,
\r
3666 final SyncProcedure<Set<Resource>> procedure) {
\r
3668 session.syncRequest(new ReadRequest() {
\r
3671 public void run(ReadGraph graph) throws DatabaseException {
\r
3672 graph.forSupertypes(subject, procedure);
\r
3675 } catch (DatabaseException e) {
\r
3681 public void forSupertypes(final Resource subject,
\r
3682 final Procedure<Set<Resource>> procedure) {
\r
3684 session.syncRequest(new ReadRequest() {
\r
3687 public void run(ReadGraph graph) throws DatabaseException {
\r
3688 graph.forSupertypes(subject, procedure);
\r
3691 } catch (DatabaseException e) {
\r
3697 public void forPossibleSuperrelation(final Resource subject,
\r
3698 final AsyncProcedure<Resource> procedure) {
\r
3700 session.syncRequest(new ReadRequest() {
\r
3703 public void run(ReadGraph graph) throws DatabaseException {
\r
3704 graph.forPossibleSuperrelation(subject, procedure);
\r
3707 } catch (DatabaseException e) {
\r
3713 public void forSuperrelations(final Resource subject,
\r
3714 final AsyncListener<Set<Resource>> procedure) {
\r
3716 session.syncRequest(new ReadRequest() {
\r
3719 public void run(ReadGraph graph) throws DatabaseException {
\r
3720 graph.forSuperrelations(subject, procedure);
\r
3723 } catch (DatabaseException e) {
\r
3729 public void forSuperrelations(final Resource subject,
\r
3730 final SyncListener<Set<Resource>> procedure) {
\r
3732 session.syncRequest(new ReadRequest() {
\r
3735 public void run(ReadGraph graph) throws DatabaseException {
\r
3736 graph.forSuperrelations(subject, procedure);
\r
3739 } catch (DatabaseException e) {
\r
3745 public void forSuperrelations(final Resource subject,
\r
3746 final Listener<Set<Resource>> procedure) {
\r
3748 session.syncRequest(new ReadRequest() {
\r
3751 public void run(ReadGraph graph) throws DatabaseException {
\r
3752 graph.forSuperrelations(subject, procedure);
\r
3755 } catch (DatabaseException e) {
\r
3761 public void forSuperrelations(final Resource subject,
\r
3762 final AsyncProcedure<Set<Resource>> procedure) {
\r
3764 session.syncRequest(new ReadRequest() {
\r
3767 public void run(ReadGraph graph) throws DatabaseException {
\r
3768 graph.forSuperrelations(subject, procedure);
\r
3771 } catch (DatabaseException e) {
\r
3777 public void forSuperrelations(final Resource subject,
\r
3778 final SyncProcedure<Set<Resource>> procedure) {
\r
3780 session.syncRequest(new ReadRequest() {
\r
3783 public void run(ReadGraph graph) throws DatabaseException {
\r
3784 graph.forSuperrelations(subject, procedure);
\r
3787 } catch (DatabaseException e) {
\r
3793 public void forSuperrelations(final Resource subject,
\r
3794 final Procedure<Set<Resource>> procedure) {
\r
3796 session.syncRequest(new ReadRequest() {
\r
3799 public void run(ReadGraph graph) throws DatabaseException {
\r
3800 graph.forSuperrelations(subject, procedure);
\r
3803 } catch (DatabaseException e) {
\r
3809 public void forObjectSet(final Resource subject, final Resource relation,
\r
3810 final AsyncSetListener<Resource> procedure) {
\r
3812 session.syncRequest(new ReadRequest() {
\r
3815 public void run(ReadGraph graph) throws DatabaseException {
\r
3816 graph.forObjectSet(subject, relation, procedure);
\r
3819 } catch (DatabaseException e) {
\r
3825 public void forObjectSet(final Resource subject, final Resource relation,
\r
3826 final SyncSetListener<Resource> procedure) {
\r
3828 session.syncRequest(new ReadRequest() {
\r
3831 public void run(ReadGraph graph) throws DatabaseException {
\r
3832 graph.forObjectSet(subject, relation, procedure);
\r
3835 } catch (DatabaseException e) {
\r
3841 public void forObjectSet(final Resource subject, final Resource relation,
\r
3842 final SetListener<Resource> procedure) {
\r
3844 session.syncRequest(new ReadRequest() {
\r
3847 public void run(ReadGraph graph) throws DatabaseException {
\r
3848 graph.forObjectSet(subject, relation, procedure);
\r
3851 } catch (DatabaseException e) {
\r
3857 public void forInverse(final Resource relation,
\r
3858 final SyncListener<Resource> procedure) {
\r
3860 session.syncRequest(new ReadRequest() {
\r
3863 public void run(ReadGraph graph) throws DatabaseException {
\r
3864 graph.forInverse(relation, procedure);
\r
3867 } catch (DatabaseException e) {
\r
3873 public void forInverse(final Resource relation, final Listener<Resource> procedure) {
\r
3875 session.syncRequest(new ReadRequest() {
\r
3878 public void run(ReadGraph graph) throws DatabaseException {
\r
3879 graph.forInverse(relation, procedure);
\r
3882 } catch (DatabaseException e) {
\r
3888 public void forInverse(final Resource relation,
\r
3889 final AsyncProcedure<Resource> procedure) {
\r
3891 session.syncRequest(new ReadRequest() {
\r
3894 public void run(ReadGraph graph) throws DatabaseException {
\r
3895 graph.forInverse(relation, procedure);
\r
3898 } catch (DatabaseException e) {
\r
3904 public void forInverse(final Resource relation,
\r
3905 final SyncProcedure<Resource> procedure) {
\r
3907 session.syncRequest(new ReadRequest() {
\r
3910 public void run(ReadGraph graph) throws DatabaseException {
\r
3911 graph.forInverse(relation, procedure);
\r
3914 } catch (DatabaseException e) {
\r
3920 public void forInverse(final Resource relation, final Procedure<Resource> procedure) {
\r
3922 session.syncRequest(new ReadRequest() {
\r
3925 public void run(ReadGraph graph) throws DatabaseException {
\r
3926 graph.forInverse(relation, procedure);
\r
3929 } catch (DatabaseException e) {
\r
3935 public void forSingleObject(final Resource subject, final Resource relation,
\r
3936 final AsyncListener<Resource> procedure) {
\r
3938 session.syncRequest(new ReadRequest() {
\r
3941 public void run(ReadGraph graph) throws DatabaseException {
\r
3942 graph.forSingleObject(subject, relation, procedure);
\r
3945 } catch (DatabaseException e) {
\r
3951 public void forSingleObject(final Resource subject, final Resource relation,
\r
3952 final SyncListener<Resource> procedure) {
\r
3954 session.syncRequest(new ReadRequest() {
\r
3957 public void run(ReadGraph graph) throws DatabaseException {
\r
3958 graph.forSingleObject(subject, relation, procedure);
\r
3961 } catch (DatabaseException e) {
\r
3967 public void forSingleObject(final Resource subject, final Resource relation,
\r
3968 final Listener<Resource> procedure) {
\r
3970 session.syncRequest(new ReadRequest() {
\r
3973 public void run(ReadGraph graph) throws DatabaseException {
\r
3974 graph.forSingleObject(subject, relation, procedure);
\r
3977 } catch (DatabaseException e) {
\r
3983 public void forSingleObject(final Resource subject, final Resource relation,
\r
3984 final AsyncProcedure<Resource> procedure) {
\r
3986 session.syncRequest(new ReadRequest() {
\r
3989 public void run(ReadGraph graph) throws DatabaseException {
\r
3990 graph.forSingleObject(subject, relation, procedure);
\r
3993 } catch (DatabaseException e) {
\r
3999 public void forSingleObject(final Resource subject, final Resource relation,
\r
4000 final SyncProcedure<Resource> procedure) {
\r
4002 session.syncRequest(new ReadRequest() {
\r
4005 public void run(ReadGraph graph) throws DatabaseException {
\r
4006 graph.forSingleObject(subject, relation, procedure);
\r
4009 } catch (DatabaseException e) {
\r
4015 public void forSingleObject(final Resource subject, final Resource relation,
\r
4016 final Procedure<Resource> procedure) {
\r
4018 session.syncRequest(new ReadRequest() {
\r
4021 public void run(ReadGraph graph) throws DatabaseException {
\r
4022 graph.forSingleObject(subject, relation, procedure);
\r
4025 } catch (DatabaseException e) {
\r
4031 public void forSingleStatement(final Resource subject, final Resource relation,
\r
4032 final AsyncListener<Statement> procedure) {
\r
4034 session.syncRequest(new ReadRequest() {
\r
4037 public void run(ReadGraph graph) throws DatabaseException {
\r
4038 graph.forSingleStatement(subject, relation, procedure);
\r
4041 } catch (DatabaseException e) {
\r
4047 public void forSingleStatement(final Resource subject, final Resource relation,
\r
4048 final SyncListener<Statement> procedure) {
\r
4050 session.syncRequest(new ReadRequest() {
\r
4053 public void run(ReadGraph graph) throws DatabaseException {
\r
4054 graph.forSingleStatement(subject, relation, procedure);
\r
4057 } catch (DatabaseException e) {
\r
4063 public void forSingleStatement(final Resource subject, final Resource relation,
\r
4064 final Listener<Statement> procedure) {
\r
4066 session.syncRequest(new ReadRequest() {
\r
4069 public void run(ReadGraph graph) throws DatabaseException {
\r
4070 graph.forSingleStatement(subject, relation, procedure);
\r
4073 } catch (DatabaseException e) {
\r
4080 public void forSingleStatement(final Resource subject, final Resource relation,
\r
4081 final AsyncProcedure<Statement> procedure) {
\r
4083 session.syncRequest(new ReadRequest() {
\r
4086 public void run(ReadGraph graph) throws DatabaseException {
\r
4087 graph.forSingleStatement(subject, relation, procedure);
\r
4090 } catch (DatabaseException e) {
\r
4096 public void forSingleStatement(final Resource subject, final Resource relation,
\r
4097 final SyncProcedure<Statement> procedure) {
\r
4099 session.syncRequest(new ReadRequest() {
\r
4102 public void run(ReadGraph graph) throws DatabaseException {
\r
4103 graph.forSingleStatement(subject, relation, procedure);
\r
4106 } catch (DatabaseException e) {
\r
4112 public void forSingleStatement(final Resource subject, final Resource relation,
\r
4113 final Procedure<Statement> procedure) {
\r
4115 session.syncRequest(new ReadRequest() {
\r
4118 public void run(ReadGraph graph) throws DatabaseException {
\r
4119 graph.forSingleStatement(subject, relation, procedure);
\r
4122 } catch (DatabaseException e) {
\r
4128 public void forSingleType(final Resource subject,
\r
4129 final AsyncListener<Resource> procedure) {
\r
4131 session.syncRequest(new ReadRequest() {
\r
4134 public void run(ReadGraph graph) throws DatabaseException {
\r
4135 graph.forSingleType(subject, procedure);
\r
4138 } catch (DatabaseException e) {
\r
4144 public void forSingleType(final Resource subject,
\r
4145 final SyncListener<Resource> procedure) {
\r
4147 session.syncRequest(new ReadRequest() {
\r
4150 public void run(ReadGraph graph) throws DatabaseException {
\r
4151 graph.forSingleType(subject, procedure);
\r
4154 } catch (DatabaseException e) {
\r
4160 public void forSingleType(final Resource subject, final Listener<Resource> procedure) {
\r
4162 session.syncRequest(new ReadRequest() {
\r
4165 public void run(ReadGraph graph) throws DatabaseException {
\r
4166 graph.forSingleType(subject, procedure);
\r
4169 } catch (DatabaseException e) {
\r
4175 public void forSingleType(final Resource subject,
\r
4176 final AsyncProcedure<Resource> procedure) {
\r
4178 session.syncRequest(new ReadRequest() {
\r
4181 public void run(ReadGraph graph) throws DatabaseException {
\r
4182 graph.forSingleType(subject, procedure);
\r
4185 } catch (DatabaseException e) {
\r
4191 public void forSingleType(final Resource subject,
\r
4192 final SyncProcedure<Resource> procedure) {
\r
4194 session.syncRequest(new ReadRequest() {
\r
4197 public void run(ReadGraph graph) throws DatabaseException {
\r
4198 graph.forSingleType(subject, procedure);
\r
4201 } catch (DatabaseException e) {
\r
4207 public void forSingleType(final Resource subject,
\r
4208 final Procedure<Resource> procedure) {
\r
4210 session.syncRequest(new ReadRequest() {
\r
4213 public void run(ReadGraph graph) throws DatabaseException {
\r
4214 graph.forSingleType(subject, procedure);
\r
4217 } catch (DatabaseException e) {
\r
4223 public void forSingleType(final Resource subject, final Resource baseType,
\r
4224 final AsyncListener<Resource> procedure) {
\r
4226 session.syncRequest(new ReadRequest() {
\r
4229 public void run(ReadGraph graph) throws DatabaseException {
\r
4230 graph.forSingleType(subject, baseType, procedure);
\r
4233 } catch (DatabaseException e) {
\r
4239 public void forSingleType(final Resource subject, final Resource baseType,
\r
4240 final SyncListener<Resource> procedure) {
\r
4242 session.syncRequest(new ReadRequest() {
\r
4245 public void run(ReadGraph graph) throws DatabaseException {
\r
4246 graph.forSingleType(subject, baseType, procedure);
\r
4249 } catch (DatabaseException e) {
\r
4255 public void forSingleType(final Resource subject, final Resource baseType,
\r
4256 final Listener<Resource> procedure) {
\r
4258 session.syncRequest(new ReadRequest() {
\r
4261 public void run(ReadGraph graph) throws DatabaseException {
\r
4262 graph.forSingleType(subject, baseType, procedure);
\r
4265 } catch (DatabaseException e) {
\r
4271 public void forSingleType(final Resource subject, final Resource baseType,
\r
4272 final AsyncProcedure<Resource> procedure) {
\r
4274 session.syncRequest(new ReadRequest() {
\r
4277 public void run(ReadGraph graph) throws DatabaseException {
\r
4278 graph.forSingleType(subject, baseType, procedure);
\r
4281 } catch (DatabaseException e) {
\r
4287 public void forSingleType(final Resource subject, final Resource baseType,
\r
4288 final SyncProcedure<Resource> procedure) {
\r
4290 session.syncRequest(new ReadRequest() {
\r
4293 public void run(ReadGraph graph) throws DatabaseException {
\r
4294 graph.forSingleType(subject, baseType, procedure);
\r
4297 } catch (DatabaseException e) {
\r
4303 public void forSingleType(final Resource subject, final Resource baseType,
\r
4304 final Procedure<Resource> procedure) {
\r
4306 session.syncRequest(new ReadRequest() {
\r
4309 public void run(ReadGraph graph) throws DatabaseException {
\r
4310 graph.forSingleType(subject, baseType, procedure);
\r
4313 } catch (DatabaseException e) {
\r
4319 public <T> void forValue(final Resource subject, final AsyncListener<T> procedure) {
\r
4321 session.syncRequest(new ReadRequest() {
\r
4324 public void run(ReadGraph graph) throws DatabaseException {
\r
4325 graph.forValue(subject, procedure);
\r
4328 } catch (DatabaseException e) {
\r
4334 public <T> void forValue(final Resource subject, final SyncListener<T> procedure) {
\r
4336 session.syncRequest(new ReadRequest() {
\r
4339 public void run(ReadGraph graph) throws DatabaseException {
\r
4340 graph.forValue(subject, procedure);
\r
4343 } catch (DatabaseException e) {
\r
4349 public <T> void forValue(final Resource subject, final Listener<T> procedure) {
\r
4351 session.syncRequest(new ReadRequest() {
\r
4354 public void run(ReadGraph graph) throws DatabaseException {
\r
4355 graph.forValue(subject, procedure);
\r
4358 } catch (DatabaseException e) {
\r
4364 public <T> void forValue(final Resource subject, final AsyncProcedure<T> procedure) {
\r
4366 session.syncRequest(new ReadRequest() {
\r
4369 public void run(ReadGraph graph) throws DatabaseException {
\r
4370 graph.forValue(subject, procedure);
\r
4373 } catch (DatabaseException e) {
\r
4379 public <T> void forValue(final Resource subject, final SyncProcedure<T> procedure) {
\r
4381 session.syncRequest(new ReadRequest() {
\r
4384 public void run(ReadGraph graph) throws DatabaseException {
\r
4385 graph.forValue(subject, procedure);
\r
4388 } catch (DatabaseException e) {
\r
4394 public <T> void forValue(final Resource subject, final Procedure<T> procedure) {
\r
4396 session.syncRequest(new ReadRequest() {
\r
4399 public void run(ReadGraph graph) throws DatabaseException {
\r
4400 graph.forValue(subject, procedure);
\r
4403 } catch (DatabaseException e) {
\r
4409 public <T> void forValue(final Resource subject, final Binding binding,
\r
4410 final AsyncListener<T> procedure) {
\r
4412 session.syncRequest(new ReadRequest() {
\r
4415 public void run(ReadGraph graph) throws DatabaseException {
\r
4416 graph.forValue(subject, binding, procedure);
\r
4419 } catch (DatabaseException e) {
\r
4425 public <T> void forValue(final Resource subject, final Binding binding,
\r
4426 final SyncListener<T> procedure) {
\r
4428 session.syncRequest(new ReadRequest() {
\r
4431 public void run(ReadGraph graph) throws DatabaseException {
\r
4432 graph.forValue(subject, binding, procedure);
\r
4435 } catch (DatabaseException e) {
\r
4441 public <T> void forValue(final Resource subject, final Binding binding,
\r
4442 final Listener<T> procedure) {
\r
4444 session.syncRequest(new ReadRequest() {
\r
4447 public void run(ReadGraph graph) throws DatabaseException {
\r
4448 graph.forValue(subject, binding, procedure);
\r
4451 } catch (DatabaseException e) {
\r
4457 public <T> void forValue(final Resource subject, final Binding binding,
\r
4458 final AsyncProcedure<T> procedure) {
\r
4460 session.syncRequest(new ReadRequest() {
\r
4463 public void run(ReadGraph graph) throws DatabaseException {
\r
4464 graph.forValue(subject, binding, procedure);
\r
4467 } catch (DatabaseException e) {
\r
4473 public <T> void forValue(final Resource subject, final Binding binding,
\r
4474 final SyncProcedure<T> procedure) {
\r
4476 session.syncRequest(new ReadRequest() {
\r
4479 public void run(ReadGraph graph) throws DatabaseException {
\r
4480 graph.forValue(subject, binding, procedure);
\r
4483 } catch (DatabaseException e) {
\r
4489 public <T> void forValue(final Resource subject, final Binding binding,
\r
4490 final Procedure<T> procedure) {
\r
4492 session.syncRequest(new ReadRequest() {
\r
4495 public void run(ReadGraph graph) throws DatabaseException {
\r
4496 graph.forValue(subject, binding, procedure);
\r
4499 } catch (DatabaseException e) {
\r
4505 public <T> void forRelatedValue(final Resource subject, final Resource relation,
\r
4506 final AsyncListener<T> procedure) {
\r
4508 session.syncRequest(new ReadRequest() {
\r
4511 public void run(ReadGraph graph) throws DatabaseException {
\r
4512 graph.forRelatedValue(subject, relation, procedure);
\r
4515 } catch (DatabaseException e) {
\r
4521 public <T> void forRelatedValue(final Resource subject, final Resource relation,
\r
4522 final SyncListener<T> procedure) {
\r
4524 session.syncRequest(new ReadRequest() {
\r
4527 public void run(ReadGraph graph) throws DatabaseException {
\r
4528 graph.forRelatedValue(subject, relation, procedure);
\r
4531 } catch (DatabaseException e) {
\r
4537 public <T> void forRelatedValue(final Resource subject, final Resource relation,
\r
4538 final Listener<T> procedure) {
\r
4540 session.syncRequest(new ReadRequest() {
\r
4543 public void run(ReadGraph graph) throws DatabaseException {
\r
4544 graph.forRelatedValue(subject, relation, procedure);
\r
4547 } catch (DatabaseException e) {
\r
4553 public <T> void forRelatedValue(final Resource subject, final Resource relation,
\r
4554 final AsyncProcedure<T> procedure) {
\r
4556 session.syncRequest(new ReadRequest() {
\r
4559 public void run(ReadGraph graph) throws DatabaseException {
\r
4560 graph.forRelatedValue(subject, relation, procedure);
\r
4563 } catch (DatabaseException e) {
\r
4569 public <T> void forRelatedValue(final Resource subject, final Resource relation,
\r
4570 final SyncProcedure<T> procedure) {
\r
4572 session.syncRequest(new ReadRequest() {
\r
4575 public void run(ReadGraph graph) throws DatabaseException {
\r
4576 graph.forRelatedValue(subject, relation, procedure);
\r
4579 } catch (DatabaseException e) {
\r
4585 public <T> void forRelatedValue(final Resource subject, final Resource relation,
\r
4586 final Procedure<T> procedure) {
\r
4588 session.syncRequest(new ReadRequest() {
\r
4591 public void run(ReadGraph graph) throws DatabaseException {
\r
4592 graph.forRelatedValue(subject, relation, procedure);
\r
4595 } catch (DatabaseException e) {
\r
4601 public <T> void forRelatedValue(final Resource subject, final Resource relation,
\r
4602 final Binding binding, final AsyncListener<T> procedure) {
\r
4604 session.syncRequest(new ReadRequest() {
\r
4607 public void run(ReadGraph graph) throws DatabaseException {
\r
4608 graph.forRelatedValue(subject, relation, binding, procedure);
\r
4611 } catch (DatabaseException e) {
\r
4617 public <T> void forRelatedValue(final Resource subject, final Resource relation,
\r
4618 final Binding binding, final SyncListener<T> procedure) {
\r
4620 session.syncRequest(new ReadRequest() {
\r
4623 public void run(ReadGraph graph) throws DatabaseException {
\r
4624 graph.forRelatedValue(subject, relation, binding, procedure);
\r
4627 } catch (DatabaseException e) {
\r
4633 public <T> void forRelatedValue(final Resource subject, final Resource relation,
\r
4634 final Binding binding, final Listener<T> procedure) {
\r
4636 session.syncRequest(new ReadRequest() {
\r
4639 public void run(ReadGraph graph) throws DatabaseException {
\r
4640 graph.forRelatedValue(subject, relation, binding, procedure);
\r
4643 } catch (DatabaseException e) {
\r
4649 public <T> void forRelatedValue(final Resource subject, final Resource relation,
\r
4650 final Binding binding, final AsyncProcedure<T> procedure) {
\r
4652 session.syncRequest(new ReadRequest() {
\r
4655 public void run(ReadGraph graph) throws DatabaseException {
\r
4656 graph.forRelatedValue(subject, relation, binding, procedure);
\r
4659 } catch (DatabaseException e) {
\r
4665 public <T> void forRelatedValue(final Resource subject, final Resource relation,
\r
4666 final Binding binding, final SyncProcedure<T> procedure) {
\r
4668 session.syncRequest(new ReadRequest() {
\r
4671 public void run(ReadGraph graph) throws DatabaseException {
\r
4672 graph.forRelatedValue(subject, relation, binding, procedure);
\r
4675 } catch (DatabaseException e) {
\r
4681 public <T> void forRelatedValue(final Resource subject, final Resource relation,
\r
4682 final Binding binding, final Procedure<T> procedure) {
\r
4684 session.syncRequest(new ReadRequest() {
\r
4687 public void run(ReadGraph graph) throws DatabaseException {
\r
4688 graph.forRelatedValue(subject, relation, binding, procedure);
\r
4691 } catch (DatabaseException e) {
\r
4697 public <T> void forUniqueAdapted(final Resource resource, final Class<T> clazz,
\r
4698 final AsyncListener<T> procedure) {
\r
4700 session.syncRequest(new ReadRequest() {
\r
4703 public void run(ReadGraph graph) throws DatabaseException {
\r
4704 graph.forUniqueAdapted(resource, clazz, procedure);
\r
4707 } catch (DatabaseException e) {
\r
4713 public <T> void forUniqueAdapted(final Resource resource, final Class<T> clazz,
\r
4714 final SyncListener<T> procedure) {
\r
4716 session.syncRequest(new ReadRequest() {
\r
4719 public void run(ReadGraph graph) throws DatabaseException {
\r
4720 graph.forUniqueAdapted(resource, clazz, procedure);
\r
4723 } catch (DatabaseException e) {
\r
4729 public <T> void forUniqueAdapted(final Resource resource, final Class<T> clazz,
\r
4730 final Listener<T> procedure) {
\r
4732 session.syncRequest(new ReadRequest() {
\r
4735 public void run(ReadGraph graph) throws DatabaseException {
\r
4736 graph.forUniqueAdapted(resource, clazz, procedure);
\r
4739 } catch (DatabaseException e) {
\r
4745 public <T> void forUniqueAdapted(final Resource resource, final Class<T> clazz,
\r
4746 final AsyncProcedure<T> procedure) {
\r
4748 session.syncRequest(new ReadRequest() {
\r
4751 public void run(ReadGraph graph) throws DatabaseException {
\r
4752 graph.forUniqueAdapted(resource, clazz, procedure);
\r
4755 } catch (DatabaseException e) {
\r
4761 public <T> void forUniqueAdapted(final Resource resource, final Class<T> clazz,
\r
4762 final SyncProcedure<T> procedure) {
\r
4764 session.syncRequest(new ReadRequest() {
\r
4767 public void run(ReadGraph graph) throws DatabaseException {
\r
4768 graph.forUniqueAdapted(resource, clazz, procedure);
\r
4771 } catch (DatabaseException e) {
\r
4777 public <T> void forUniqueAdapted(final Resource resource, final Class<T> clazz,
\r
4778 final Procedure<T> procedure) {
\r
4780 session.syncRequest(new ReadRequest() {
\r
4783 public void run(ReadGraph graph) throws DatabaseException {
\r
4784 graph.forUniqueAdapted(resource, clazz, procedure);
\r
4787 } catch (DatabaseException e) {
\r
4793 public void forPossibleInverse(final Resource relation,
\r
4794 final AsyncListener<Resource> procedure) {
\r
4796 session.syncRequest(new ReadRequest() {
\r
4799 public void run(ReadGraph graph) throws DatabaseException {
\r
4800 graph.forPossibleInverse(relation, procedure);
\r
4803 } catch (DatabaseException e) {
\r
4809 public void forPossibleInverse(final Resource relation,
\r
4810 final SyncListener<Resource> procedure) {
\r
4812 session.syncRequest(new ReadRequest() {
\r
4815 public void run(ReadGraph graph) throws DatabaseException {
\r
4816 graph.forPossibleInverse(relation, procedure);
\r
4819 } catch (DatabaseException e) {
\r
4825 public void forPossibleInverse(final Resource relation,
\r
4826 final Listener<Resource> procedure) {
\r
4828 session.syncRequest(new ReadRequest() {
\r
4831 public void run(ReadGraph graph) throws DatabaseException {
\r
4832 graph.forPossibleInverse(relation, procedure);
\r
4835 } catch (DatabaseException e) {
\r
4841 public void forPossibleInverse(final Resource relation,
\r
4842 final AsyncProcedure<Resource> procedure) {
\r
4844 session.syncRequest(new ReadRequest() {
\r
4847 public void run(ReadGraph graph) throws DatabaseException {
\r
4848 graph.forPossibleInverse(relation, procedure);
\r
4851 } catch (DatabaseException e) {
\r
4857 public void forPossibleInverse(final Resource relation,
\r
4858 final SyncProcedure<Resource> procedure) {
\r
4860 session.syncRequest(new ReadRequest() {
\r
4863 public void run(ReadGraph graph) throws DatabaseException {
\r
4864 graph.forPossibleInverse(relation, procedure);
\r
4867 } catch (DatabaseException e) {
\r
4873 public void forPossibleInverse(final Resource relation,
\r
4874 final Procedure<Resource> procedure) {
\r
4876 session.syncRequest(new ReadRequest() {
\r
4879 public void run(ReadGraph graph) throws DatabaseException {
\r
4880 graph.forPossibleInverse(relation, procedure);
\r
4883 } catch (DatabaseException e) {
\r
4889 public void forPossibleObject(final Resource subject, final Resource relation,
\r
4890 final AsyncListener<Resource> procedure) {
\r
4892 session.syncRequest(new ReadRequest() {
\r
4895 public void run(ReadGraph graph) throws DatabaseException {
\r
4896 graph.forPossibleObject(subject, relation, procedure);
\r
4899 } catch (DatabaseException e) {
\r
4905 public void forPossibleObject(final Resource subject, final Resource relation,
\r
4906 final SyncListener<Resource> procedure) {
\r
4908 session.syncRequest(new ReadRequest() {
\r
4911 public void run(ReadGraph graph) throws DatabaseException {
\r
4912 graph.forPossibleObject(subject, relation, procedure);
\r
4915 } catch (DatabaseException e) {
\r
4921 public void forPossibleObject(final Resource subject, final Resource relation,
\r
4922 final Listener<Resource> procedure) {
\r
4924 session.syncRequest(new ReadRequest() {
\r
4927 public void run(ReadGraph graph) throws DatabaseException {
\r
4928 graph.forPossibleObject(subject, relation, procedure);
\r
4931 } catch (DatabaseException e) {
\r
4937 public void forPossibleObject(final Resource subject, final Resource relation,
\r
4938 final AsyncProcedure<Resource> procedure) {
\r
4940 session.syncRequest(new ReadRequest() {
\r
4943 public void run(ReadGraph graph) throws DatabaseException {
\r
4944 graph.forPossibleObject(subject, relation, procedure);
\r
4947 } catch (DatabaseException e) {
\r
4953 public void forPossibleObject(final Resource subject, final Resource relation,
\r
4954 final SyncProcedure<Resource> procedure) {
\r
4956 session.syncRequest(new ReadRequest() {
\r
4959 public void run(ReadGraph graph) throws DatabaseException {
\r
4960 graph.forPossibleObject(subject, relation, procedure);
\r
4963 } catch (DatabaseException e) {
\r
4969 public void forPossibleObject(final Resource subject, final Resource relation,
\r
4970 final Procedure<Resource> procedure) {
\r
4972 session.syncRequest(new ReadRequest() {
\r
4975 public void run(ReadGraph graph) throws DatabaseException {
\r
4976 graph.forPossibleObject(subject, relation, procedure);
\r
4979 } catch (DatabaseException e) {
\r
4985 public void forPossibleStatement(final Resource subject, final Resource relation,
\r
4986 final AsyncListener<Statement> procedure) {
\r
4988 session.syncRequest(new ReadRequest() {
\r
4991 public void run(ReadGraph graph) throws DatabaseException {
\r
4992 graph.forPossibleStatement(subject, relation, procedure);
\r
4995 } catch (DatabaseException e) {
\r
5001 public void forPossibleStatement(final Resource subject, final Resource relation,
\r
5002 final SyncListener<Statement> procedure) {
\r
5004 session.syncRequest(new ReadRequest() {
\r
5007 public void run(ReadGraph graph) throws DatabaseException {
\r
5008 graph.forPossibleStatement(subject, relation, procedure);
\r
5011 } catch (DatabaseException e) {
\r
5017 public void forPossibleStatement(final Resource subject, final Resource relation,
\r
5018 final Listener<Statement> procedure) {
\r
5020 session.syncRequest(new ReadRequest() {
\r
5023 public void run(ReadGraph graph) throws DatabaseException {
\r
5024 graph.forPossibleStatement(subject, relation, procedure);
\r
5027 } catch (DatabaseException e) {
\r
5033 public void forPossibleStatement(final Resource subject, final Resource relation,
\r
5034 final AsyncProcedure<Statement> procedure) {
\r
5036 session.syncRequest(new ReadRequest() {
\r
5039 public void run(ReadGraph graph) throws DatabaseException {
\r
5040 graph.forPossibleStatement(subject, relation, procedure);
\r
5043 } catch (DatabaseException e) {
\r
5049 public void forPossibleStatement(final Resource subject, final Resource relation,
\r
5050 final SyncProcedure<Statement> procedure) {
\r
5052 session.syncRequest(new ReadRequest() {
\r
5055 public void run(ReadGraph graph) throws DatabaseException {
\r
5056 graph.forPossibleStatement(subject, relation, procedure);
\r
5059 } catch (DatabaseException e) {
\r
5065 public void forPossibleStatement(final Resource subject, final Resource relation,
\r
5066 final Procedure<Statement> procedure) {
\r
5068 session.syncRequest(new ReadRequest() {
\r
5071 public void run(ReadGraph graph) throws DatabaseException {
\r
5072 graph.forPossibleStatement(subject, relation, procedure);
\r
5075 } catch (DatabaseException e) {
\r
5081 public void forPossibleType(final Resource subject, final Resource baseType,
\r
5082 final AsyncListener<Resource> procedure) {
\r
5084 session.syncRequest(new ReadRequest() {
\r
5087 public void run(ReadGraph graph) throws DatabaseException {
\r
5088 graph.forPossibleType(subject, baseType, procedure);
\r
5091 } catch (DatabaseException e) {
\r
5097 public void forPossibleType(final Resource subject, final Resource baseType,
\r
5098 final SyncListener<Resource> procedure) {
\r
5100 session.syncRequest(new ReadRequest() {
\r
5103 public void run(ReadGraph graph) throws DatabaseException {
\r
5104 graph.forPossibleType(subject, baseType, procedure);
\r
5107 } catch (DatabaseException e) {
\r
5113 public void forPossibleType(final Resource subject, final Resource baseType,
\r
5114 final Listener<Resource> procedure) {
\r
5116 session.syncRequest(new ReadRequest() {
\r
5119 public void run(ReadGraph graph) throws DatabaseException {
\r
5120 graph.forPossibleType(subject, baseType, procedure);
\r
5123 } catch (DatabaseException e) {
\r
5129 public void forPossibleType(final Resource subject, final Resource baseType,
\r
5130 final AsyncProcedure<Resource> procedure) {
\r
5132 session.syncRequest(new ReadRequest() {
\r
5135 public void run(ReadGraph graph) throws DatabaseException {
\r
5136 graph.forPossibleType(subject, baseType, procedure);
\r
5139 } catch (DatabaseException e) {
\r
5145 public void forPossibleType(final Resource subject, final Resource baseType,
\r
5146 final SyncProcedure<Resource> procedure) {
\r
5148 session.syncRequest(new ReadRequest() {
\r
5151 public void run(ReadGraph graph) throws DatabaseException {
\r
5152 graph.forPossibleType(subject, baseType, procedure);
\r
5155 } catch (DatabaseException e) {
\r
5161 public void forPossibleType(final Resource subject, final Resource baseType,
\r
5162 final Procedure<Resource> procedure) {
\r
5164 session.syncRequest(new ReadRequest() {
\r
5167 public void run(ReadGraph graph) throws DatabaseException {
\r
5168 graph.forPossibleType(subject, baseType, procedure);
\r
5171 } catch (DatabaseException e) {
\r
5177 public <T> void forPossibleValue(final Resource subject,
\r
5178 final AsyncListener<T> procedure) {
\r
5180 session.syncRequest(new ReadRequest() {
\r
5183 public void run(ReadGraph graph) throws DatabaseException {
\r
5184 graph.forPossibleValue(subject, procedure);
\r
5187 } catch (DatabaseException e) {
\r
5193 public <T> void forPossibleValue(final Resource subject,
\r
5194 final SyncListener<T> procedure) {
\r
5196 session.syncRequest(new ReadRequest() {
\r
5199 public void run(ReadGraph graph) throws DatabaseException {
\r
5200 graph.forPossibleValue(subject, procedure);
\r
5203 } catch (DatabaseException e) {
\r
5209 public <T> void forPossibleValue(final Resource subject, final Listener<T> procedure) {
\r
5211 session.syncRequest(new ReadRequest() {
\r
5214 public void run(ReadGraph graph) throws DatabaseException {
\r
5215 graph.forPossibleValue(subject, procedure);
\r
5218 } catch (DatabaseException e) {
\r
5224 public <T> void forPossibleValue(final Resource subject,
\r
5225 final AsyncProcedure<T> procedure) {
\r
5227 session.syncRequest(new ReadRequest() {
\r
5230 public void run(ReadGraph graph) throws DatabaseException {
\r
5231 graph.forPossibleValue(subject, procedure);
\r
5234 } catch (DatabaseException e) {
\r
5240 public <T> void forPossibleValue(final Resource subject,
\r
5241 final SyncProcedure<T> procedure) {
\r
5243 session.syncRequest(new ReadRequest() {
\r
5246 public void run(ReadGraph graph) throws DatabaseException {
\r
5247 graph.forPossibleValue(subject, procedure);
\r
5250 } catch (DatabaseException e) {
\r
5256 public <T> void forPossibleValue(final Resource subject,
\r
5257 final Procedure<T> procedure) {
\r
5259 session.syncRequest(new ReadRequest() {
\r
5262 public void run(ReadGraph graph) throws DatabaseException {
\r
5263 graph.forPossibleValue(subject, procedure);
\r
5266 } catch (DatabaseException e) {
\r
5272 public <T> void forPossibleValue(final Resource subject, final Binding binding,
\r
5273 final AsyncListener<T> procedure) {
\r
5275 session.syncRequest(new ReadRequest() {
\r
5278 public void run(ReadGraph graph) throws DatabaseException {
\r
5279 graph.forPossibleValue(subject, procedure);
\r
5282 } catch (DatabaseException e) {
\r
5288 public <T> void forPossibleValue(final Resource subject, final Binding binding,
\r
5289 final SyncListener<T> procedure) {
\r
5291 session.syncRequest(new ReadRequest() {
\r
5294 public void run(ReadGraph graph) throws DatabaseException {
\r
5295 graph.forPossibleValue(subject, procedure);
\r
5298 } catch (DatabaseException e) {
\r
5304 public <T> void forPossibleValue(final Resource subject, final Binding binding,
\r
5305 final Listener<T> procedure) {
\r
5307 session.syncRequest(new ReadRequest() {
\r
5310 public void run(ReadGraph graph) throws DatabaseException {
\r
5311 graph.forPossibleValue(subject, procedure);
\r
5314 } catch (DatabaseException e) {
\r
5320 public <T> void forPossibleValue(final Resource subject, final Binding binding,
\r
5321 final AsyncProcedure<T> procedure) {
\r
5323 session.syncRequest(new ReadRequest() {
\r
5326 public void run(ReadGraph graph) throws DatabaseException {
\r
5327 graph.forPossibleValue(subject, procedure);
\r
5330 } catch (DatabaseException e) {
\r
5336 public <T> void forPossibleValue(final Resource subject, final Binding binding,
\r
5337 final SyncProcedure<T> procedure) {
\r
5339 session.syncRequest(new ReadRequest() {
\r
5342 public void run(ReadGraph graph) throws DatabaseException {
\r
5343 graph.forPossibleValue(subject, procedure);
\r
5346 } catch (DatabaseException e) {
\r
5352 public <T> void forPossibleValue(final Resource subject, final Binding binding,
\r
5353 final Procedure<T> procedure) {
\r
5355 session.syncRequest(new ReadRequest() {
\r
5358 public void run(ReadGraph graph) throws DatabaseException {
\r
5359 graph.forPossibleValue(subject, procedure);
\r
5362 } catch (DatabaseException e) {
\r
5368 public <T> void forPossibleRelatedValue(final Resource subject,
\r
5369 final Resource relation, final AsyncListener<T> procedure) {
\r
5371 session.syncRequest(new ReadRequest() {
\r
5374 public void run(ReadGraph graph) throws DatabaseException {
\r
5375 graph.forPossibleRelatedValue(subject, relation, procedure);
\r
5378 } catch (DatabaseException e) {
\r
5384 public <T> void forPossibleRelatedValue(final Resource subject,
\r
5385 final Resource relation, final SyncListener<T> procedure) {
\r
5387 session.syncRequest(new ReadRequest() {
\r
5390 public void run(ReadGraph graph) throws DatabaseException {
\r
5391 graph.forPossibleRelatedValue(subject, relation, procedure);
\r
5394 } catch (DatabaseException e) {
\r
5400 public <T> void forPossibleRelatedValue(final Resource subject,
\r
5401 final Resource relation, final Listener<T> procedure) {
\r
5403 session.syncRequest(new ReadRequest() {
\r
5406 public void run(ReadGraph graph) throws DatabaseException {
\r
5407 graph.forPossibleRelatedValue(subject, relation, procedure);
\r
5410 } catch (DatabaseException e) {
\r
5416 public <T> void forPossibleRelatedValue(final Resource subject,
\r
5417 final Resource relation, final AsyncProcedure<T> procedure) {
\r
5419 session.syncRequest(new ReadRequest() {
\r
5422 public void run(ReadGraph graph) throws DatabaseException {
\r
5423 graph.forPossibleRelatedValue(subject, relation, procedure);
\r
5426 } catch (DatabaseException e) {
\r
5432 public <T> void forPossibleRelatedValue(final Resource subject,
\r
5433 final Resource relation, final SyncProcedure<T> procedure) {
\r
5435 session.syncRequest(new ReadRequest() {
\r
5438 public void run(ReadGraph graph) throws DatabaseException {
\r
5439 graph.forPossibleRelatedValue(subject, relation, procedure);
\r
5442 } catch (DatabaseException e) {
\r
5448 public <T> void forPossibleRelatedValue(final Resource subject,
\r
5449 final Resource relation, final Procedure<T> procedure) {
\r
5451 session.syncRequest(new ReadRequest() {
\r
5454 public void run(ReadGraph graph) throws DatabaseException {
\r
5455 graph.forPossibleRelatedValue(subject, relation, procedure);
\r
5458 } catch (DatabaseException e) {
\r
5464 public <T> void forPossibleRelatedValue(final Resource subject,
\r
5465 final Resource relation, final Binding binding, final AsyncListener<T> procedure) {
\r
5467 session.syncRequest(new ReadRequest() {
\r
5470 public void run(ReadGraph graph) throws DatabaseException {
\r
5471 graph.forPossibleRelatedValue(subject, relation, binding, procedure);
\r
5474 } catch (DatabaseException e) {
\r
5480 public <T> void forPossibleRelatedValue(final Resource subject,
\r
5481 final Resource relation, final Binding binding, final SyncListener<T> procedure) {
\r
5483 session.syncRequest(new ReadRequest() {
\r
5486 public void run(ReadGraph graph) throws DatabaseException {
\r
5487 graph.forPossibleRelatedValue(subject, relation, procedure);
\r
5490 } catch (DatabaseException e) {
\r
5496 public <T> void forPossibleRelatedValue(final Resource subject,
\r
5497 final Resource relation, final Binding binding, final Listener<T> procedure) {
\r
5499 session.syncRequest(new ReadRequest() {
\r
5502 public void run(ReadGraph graph) throws DatabaseException {
\r
5503 graph.forPossibleRelatedValue(subject, relation, binding, procedure);
\r
5506 } catch (DatabaseException e) {
\r
5512 public <T> void forPossibleRelatedValue(final Resource subject,
\r
5513 final Resource relation, final Binding binding, final AsyncProcedure<T> procedure) {
\r
5515 session.syncRequest(new ReadRequest() {
\r
5518 public void run(ReadGraph graph) throws DatabaseException {
\r
5519 graph.forPossibleRelatedValue(subject, relation, binding, procedure);
\r
5522 } catch (DatabaseException e) {
\r
5528 public <T> void forPossibleRelatedValue(final Resource subject,
\r
5529 final Resource relation, final Binding binding, final SyncProcedure<T> procedure) {
\r
5531 session.syncRequest(new ReadRequest() {
\r
5534 public void run(ReadGraph graph) throws DatabaseException {
\r
5535 graph.forPossibleRelatedValue(subject, relation, binding, procedure);
\r
5538 } catch (DatabaseException e) {
\r
5544 public <T> void forPossibleRelatedValue(final Resource subject,
\r
5545 final Resource relation, final Binding binding, final Procedure<T> procedure) {
\r
5547 session.syncRequest(new ReadRequest() {
\r
5550 public void run(ReadGraph graph) throws DatabaseException {
\r
5551 graph.forPossibleRelatedValue(subject, relation, binding, procedure);
\r
5554 } catch (DatabaseException e) {
\r
5560 public <T> void forPossibleAdapted(final Resource resource, final Class<T> clazz,
\r
5561 final AsyncListener<T> procedure) {
\r
5563 session.syncRequest(new ReadRequest() {
\r
5566 public void run(ReadGraph graph) throws DatabaseException {
\r
5567 graph.forPossibleAdapted(resource, clazz, procedure);
\r
5570 } catch (DatabaseException e) {
\r
5576 public <T> void forPossibleAdapted(final Resource resource, final Class<T> clazz,
\r
5577 final SyncListener<T> procedure) {
\r
5579 session.syncRequest(new ReadRequest() {
\r
5582 public void run(ReadGraph graph) throws DatabaseException {
\r
5583 graph.forPossibleAdapted(resource, clazz, procedure);
\r
5586 } catch (DatabaseException e) {
\r
5592 public <T> void forPossibleAdapted(final Resource resource, final Class<T> clazz,
\r
5593 final Listener<T> procedure) {
\r
5595 session.syncRequest(new ReadRequest() {
\r
5598 public void run(ReadGraph graph) throws DatabaseException {
\r
5599 graph.forPossibleAdapted(resource, clazz, procedure);
\r
5602 } catch (DatabaseException e) {
\r
5608 public <T> void forPossibleAdapted(final Resource resource, final Class<T> clazz,
\r
5609 final AsyncProcedure<T> procedure) {
\r
5611 session.syncRequest(new ReadRequest() {
\r
5614 public void run(ReadGraph graph) throws DatabaseException {
\r
5615 graph.forPossibleAdapted(resource, clazz, procedure);
\r
5618 } catch (DatabaseException e) {
\r
5624 public <T> void forPossibleAdapted(final Resource resource, final Class<T> clazz,
\r
5625 final SyncProcedure<T> procedure) {
\r
5627 session.syncRequest(new ReadRequest() {
\r
5630 public void run(ReadGraph graph) throws DatabaseException {
\r
5631 graph.forPossibleAdapted(resource, clazz, procedure);
\r
5634 } catch (DatabaseException e) {
\r
5640 public <T> void forPossibleAdapted(final Resource resource, final Class<T> clazz,
\r
5641 final Procedure<T> procedure) {
\r
5643 session.syncRequest(new ReadRequest() {
\r
5646 public void run(ReadGraph graph) throws DatabaseException {
\r
5647 graph.forPossibleAdapted(resource, clazz, procedure);
\r
5650 } catch (DatabaseException e) {
\r
5656 public <T> void forPossibleUniqueAdapted(final Resource resource,
\r
5657 final Class<T> clazz, final AsyncListener<T> procedure) {
\r
5659 session.syncRequest(new ReadRequest() {
\r
5662 public void run(ReadGraph graph) throws DatabaseException {
\r
5663 graph.forPossibleUniqueAdapted(resource, clazz, procedure);
\r
5666 } catch (DatabaseException e) {
\r
5672 public <T> void forPossibleUniqueAdapted(final Resource resource,
\r
5673 final Class<T> clazz, final SyncListener<T> procedure) {
\r
5675 session.syncRequest(new ReadRequest() {
\r
5678 public void run(ReadGraph graph) throws DatabaseException {
\r
5679 graph.forPossibleUniqueAdapted(resource, clazz, procedure);
\r
5682 } catch (DatabaseException e) {
\r
5688 public <T> void forPossibleUniqueAdapted(final Resource resource,
\r
5689 final Class<T> clazz, final Listener<T> procedure) {
\r
5691 session.syncRequest(new ReadRequest() {
\r
5694 public void run(ReadGraph graph) throws DatabaseException {
\r
5695 graph.forPossibleUniqueAdapted(resource, clazz, procedure);
\r
5698 } catch (DatabaseException e) {
\r
5704 public <T> void forPossibleUniqueAdapted(final Resource resource,
\r
5705 final Class<T> clazz, final AsyncProcedure<T> procedure) {
\r
5707 session.syncRequest(new ReadRequest() {
\r
5710 public void run(ReadGraph graph) throws DatabaseException {
\r
5711 graph.forPossibleUniqueAdapted(resource, clazz, procedure);
\r
5714 } catch (DatabaseException e) {
\r
5720 public <T> void forPossibleUniqueAdapted(final Resource resource,
\r
5721 final Class<T> clazz, final SyncProcedure<T> procedure) {
\r
5723 session.syncRequest(new ReadRequest() {
\r
5726 public void run(ReadGraph graph) throws DatabaseException {
\r
5727 graph.forPossibleUniqueAdapted(resource, clazz, procedure);
\r
5730 } catch (DatabaseException e) {
\r
5736 public <T> void forPossibleUniqueAdapted(final Resource resource,
\r
5737 final Class<T> clazz, final Procedure<T> procedure) {
\r
5739 session.syncRequest(new ReadRequest() {
\r
5742 public void run(ReadGraph graph) throws DatabaseException {
\r
5743 graph.forPossibleUniqueAdapted(resource, clazz, procedure);
\r
5746 } catch (DatabaseException e) {
\r
5752 public void forIsInstanceOf(final Resource resource, final Resource type,
\r
5753 final AsyncListener<Boolean> procedure) {
\r
5755 session.syncRequest(new ReadRequest() {
\r
5758 public void run(ReadGraph graph) throws DatabaseException {
\r
5759 graph.forIsInstanceOf(resource, type, procedure);
\r
5762 } catch (DatabaseException e) {
\r
5768 public void forIsInstanceOf(final Resource resource, final Resource type,
\r
5769 final SyncListener<Boolean> procedure) {
\r
5771 session.syncRequest(new ReadRequest() {
\r
5774 public void run(ReadGraph graph) throws DatabaseException {
\r
5775 graph.forIsInstanceOf(resource, type, procedure);
\r
5778 } catch (DatabaseException e) {
\r
5784 public void forIsInstanceOf(final Resource resource, final Resource type,
\r
5785 final Listener<Boolean> procedure) {
\r
5787 session.syncRequest(new ReadRequest() {
\r
5790 public void run(ReadGraph graph) throws DatabaseException {
\r
5791 graph.forIsInstanceOf(resource, type, procedure);
\r
5794 } catch (DatabaseException e) {
\r
5800 public void forIsInstanceOf(final Resource resource, final Resource type,
\r
5801 final AsyncProcedure<Boolean> procedure) {
\r
5803 session.syncRequest(new ReadRequest() {
\r
5806 public void run(ReadGraph graph) throws DatabaseException {
\r
5807 graph.forIsInstanceOf(resource, type, procedure);
\r
5810 } catch (DatabaseException e) {
\r
5816 public void forIsInstanceOf(final Resource resource, final Resource type,
\r
5817 final SyncProcedure<Boolean> procedure) {
\r
5819 session.syncRequest(new ReadRequest() {
\r
5822 public void run(ReadGraph graph) throws DatabaseException {
\r
5823 graph.forIsInstanceOf(resource, type, procedure);
\r
5826 } catch (DatabaseException e) {
\r
5832 public void forIsInstanceOf(final Resource resource, final Resource type,
\r
5833 final Procedure<Boolean> procedure) {
\r
5835 session.syncRequest(new ReadRequest() {
\r
5838 public void run(ReadGraph graph) throws DatabaseException {
\r
5839 graph.forIsInstanceOf(resource, type, procedure);
\r
5842 } catch (DatabaseException e) {
\r
5848 public void forIsInheritedFrom(final Resource resource, final Resource type,
\r
5849 final AsyncListener<Boolean> procedure) {
\r
5851 session.syncRequest(new ReadRequest() {
\r
5854 public void run(ReadGraph graph) throws DatabaseException {
\r
5855 graph.forIsInheritedFrom(resource, type, procedure);
\r
5858 } catch (DatabaseException e) {
\r
5864 public void forIsInheritedFrom(final Resource resource, final Resource type,
\r
5865 final SyncListener<Boolean> procedure) {
\r
5867 session.syncRequest(new ReadRequest() {
\r
5870 public void run(ReadGraph graph) throws DatabaseException {
\r
5871 graph.forIsInheritedFrom(resource, type, procedure);
\r
5874 } catch (DatabaseException e) {
\r
5880 public void forIsInheritedFrom(final Resource resource, final Resource type,
\r
5881 final Listener<Boolean> procedure) {
\r
5883 session.syncRequest(new ReadRequest() {
\r
5886 public void run(ReadGraph graph) throws DatabaseException {
\r
5887 graph.forIsInheritedFrom(resource, type, procedure);
\r
5890 } catch (DatabaseException e) {
\r
5896 public void forIsInheritedFrom(final Resource resource, final Resource type,
\r
5897 final AsyncProcedure<Boolean> procedure) {
\r
5899 session.syncRequest(new ReadRequest() {
\r
5902 public void run(ReadGraph graph) throws DatabaseException {
\r
5903 graph.forIsInheritedFrom(resource, type, procedure);
\r
5906 } catch (DatabaseException e) {
\r
5912 public void forIsInheritedFrom(final Resource resource, final Resource type,
\r
5913 final SyncProcedure<Boolean> procedure) {
\r
5915 session.syncRequest(new ReadRequest() {
\r
5918 public void run(ReadGraph graph) throws DatabaseException {
\r
5919 graph.forIsInheritedFrom(resource, type, procedure);
\r
5922 } catch (DatabaseException e) {
\r
5928 public void forIsInheritedFrom(final Resource resource, final Resource type,
\r
5929 final Procedure<Boolean> procedure) {
\r
5931 session.syncRequest(new ReadRequest() {
\r
5934 public void run(ReadGraph graph) throws DatabaseException {
\r
5935 graph.forIsInheritedFrom(resource, type, procedure);
\r
5938 } catch (DatabaseException e) {
\r
5944 public void forIsSubrelationOf(final Resource resource, final Resource relation,
\r
5945 final AsyncListener<Boolean> procedure) {
\r
5947 session.syncRequest(new ReadRequest() {
\r
5950 public void run(ReadGraph graph) throws DatabaseException {
\r
5951 graph.forIsSubrelationOf(resource, relation, procedure);
\r
5954 } catch (DatabaseException e) {
\r
5960 public void forIsSubrelationOf(final Resource resource, final Resource relation,
\r
5961 final SyncListener<Boolean> procedure) {
\r
5963 session.syncRequest(new ReadRequest() {
\r
5966 public void run(ReadGraph graph) throws DatabaseException {
\r
5967 graph.forIsSubrelationOf(resource, relation, procedure);
\r
5970 } catch (DatabaseException e) {
\r
5976 public void forIsSubrelationOf(final Resource resource, final Resource relation,
\r
5977 final Listener<Boolean> procedure) {
\r
5979 session.syncRequest(new ReadRequest() {
\r
5982 public void run(ReadGraph graph) throws DatabaseException {
\r
5983 graph.forIsSubrelationOf(resource, relation, procedure);
\r
5986 } catch (DatabaseException e) {
\r
5992 public void forIsSubrelationOf(final Resource resource, final Resource relation,
\r
5993 final AsyncProcedure<Boolean> procedure) {
\r
5995 session.syncRequest(new ReadRequest() {
\r
5998 public void run(ReadGraph graph) throws DatabaseException {
\r
5999 graph.forIsSubrelationOf(resource, relation, procedure);
\r
6002 } catch (DatabaseException e) {
\r
6008 public void forIsSubrelationOf(final Resource resource, final Resource relation,
\r
6009 final SyncProcedure<Boolean> procedure) {
\r
6011 session.syncRequest(new ReadRequest() {
\r
6014 public void run(ReadGraph graph) throws DatabaseException {
\r
6015 graph.forIsSubrelationOf(resource, relation, procedure);
\r
6018 } catch (DatabaseException e) {
\r
6024 public void forIsSubrelationOf(final Resource resource, final Resource relation,
\r
6025 final Procedure<Boolean> procedure) {
\r
6027 session.syncRequest(new ReadRequest() {
\r
6030 public void run(ReadGraph graph) throws DatabaseException {
\r
6031 graph.forIsSubrelationOf(resource, relation, procedure);
\r
6034 } catch (DatabaseException e) {
\r
6040 public void forOrderedSet(final Resource subject,
\r
6041 final AsyncMultiListener<Resource> procedure) {
\r
6043 session.syncRequest(new ReadRequest() {
\r
6046 public void run(ReadGraph graph) throws DatabaseException {
\r
6047 graph.forOrderedSet(subject, procedure);
\r
6050 } catch (DatabaseException e) {
\r
6056 public void forOrderedSet(final Resource subject,
\r
6057 final SyncMultiListener<Resource> procedure) {
\r
6059 session.syncRequest(new ReadRequest() {
\r
6062 public void run(ReadGraph graph) throws DatabaseException {
\r
6063 graph.forOrderedSet(subject, procedure);
\r
6066 } catch (DatabaseException e) {
\r
6072 public void forOrderedSet(final Resource subject,
\r
6073 final MultiListener<Resource> procedure) {
\r
6075 session.syncRequest(new ReadRequest() {
\r
6078 public void run(ReadGraph graph) throws DatabaseException {
\r
6079 graph.forOrderedSet(subject, procedure);
\r
6082 } catch (DatabaseException e) {
\r
6088 public void forOrderedSet(final Resource subject,
\r
6089 final AsyncMultiProcedure<Resource> procedure) {
\r
6091 session.syncRequest(new ReadRequest() {
\r
6094 public void run(ReadGraph graph) throws DatabaseException {
\r
6095 graph.forOrderedSet(subject, procedure);
\r
6098 } catch (DatabaseException e) {
\r
6104 public void forOrderedSet(final Resource subject,
\r
6105 final SyncMultiProcedure<Resource> procedure) {
\r
6108 session.syncRequest(new ReadRequest() {
\r
6111 public void run(ReadGraph graph) throws DatabaseException {
\r
6112 graph.forOrderedSet(subject, procedure);
\r
6115 } catch (DatabaseException e) {
\r
6121 public void forOrderedSet(final Resource subject,
\r
6122 final MultiProcedure<Resource> procedure) {
\r
6124 session.syncRequest(new ReadRequest() {
\r
6127 public void run(ReadGraph graph) throws DatabaseException {
\r
6128 graph.forOrderedSet(subject, procedure);
\r
6131 } catch (DatabaseException e) {
\r
6137 public int thread() {
\r
6142 public Session getSession() {
\r
6147 public Resource getBuiltin(final String id) throws ResourceNotFoundException,
\r
6148 ServiceException {
\r
6150 return session.syncRequest(new Read<Resource>() {
\r
6153 public Resource perform(ReadGraph graph) throws DatabaseException {
\r
6154 return graph.getBuiltin(id);
\r
6157 } catch (DatabaseException e) {
\r
6158 throw new ServiceException(e);
\r
6163 public VirtualGraph getProvider() {
\r