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
374 public RandomAccessBinary createRandomAccessBinary(final Resource resource, final Resource predicate, final Datatype datatype, final Object initialValue) throws DatabaseException {
\r
375 return session.syncRequest(new WriteResultRequest<RandomAccessBinary>() {
\r
377 public RandomAccessBinary perform(WriteGraph graph) throws DatabaseException {
\r
378 return graph.createRandomAccessBinary(resource, predicate, datatype, initialValue);
\r
383 public RandomAccessBinary createRandomAccessBinary(final Resource resource, final Datatype datatype, final Object initialValue) throws DatabaseException {
\r
384 return session.syncRequest(new WriteResultRequest<RandomAccessBinary>() {
\r
386 public RandomAccessBinary perform(WriteGraph graph) throws DatabaseException {
\r
387 return graph.createRandomAccessBinary(resource, datatype, initialValue);
\r
392 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
394 return session.syncRequest(new Read<T>() {
\r
397 public T perform(ReadGraph graph) throws DatabaseException {
\r
398 return graph.adaptContextual(resource, context, contextClass, clazz);
\r
401 } catch (DatabaseException e) {
\r
402 throw new ServiceException(e);
\r
407 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
409 return session.syncRequest(new Read<T>() {
\r
412 public T perform(ReadGraph graph) throws DatabaseException {
\r
413 return graph.getPossibleContextualAdapter(resource, context, contextClass, clazz);
\r
416 } catch (DatabaseException e) {
\r
417 throw new ServiceException(e);
\r
422 public SplittingWriteGraph(Session session) {
\r
423 this.session = session;
\r
427 public Resource newResource() throws ServiceException {
\r
429 return session.syncRequest(new WriteResultRequest<Resource>() {
\r
432 public Resource perform(WriteGraph graph) throws DatabaseException {
\r
433 return graph.newResource();
\r
436 } catch (DatabaseException e) {
\r
437 throw new ServiceException(e);
\r
443 public Resource newResource(final long clusterId) throws ServiceException {
\r
445 return session.syncRequest(new WriteResultRequest<Resource>() {
\r
448 public Resource perform(WriteGraph graph) throws DatabaseException {
\r
449 return graph.newResource(clusterId);
\r
452 } catch (DatabaseException e) {
\r
453 throw new ServiceException(e);
\r
458 public <T> T adapt(final Resource resource, final Class<T> clazz)
\r
459 throws AdaptionException, ValidationException, ServiceException {
\r
461 return session.syncRequest(new Read<T>() {
\r
464 public T perform(ReadGraph graph) throws DatabaseException {
\r
465 return graph.adapt(resource, clazz);
\r
468 } catch (DatabaseException e) {
\r
469 throw new ServiceException(e);
\r
474 public <T> T adaptUnique(final Resource resource, final Class<T> clazz)
\r
475 throws AdaptionException, ValidationException, ServiceException {
\r
477 return session.syncRequest(new Read<T>() {
\r
480 public T perform(ReadGraph graph) throws DatabaseException {
\r
481 return graph.adaptUnique(resource, clazz);
\r
484 } catch (DatabaseException e) {
\r
485 throw new ServiceException(e);
\r
490 public void addLiteral(final Resource resource, final Resource predicate,
\r
491 final Resource inverse, final Object value, final Binding binding)
\r
492 throws BindingException,
\r
493 ManyObjectsForFunctionalRelationException, ServiceException {
\r
495 session.syncRequest(new WriteRequest() {
\r
498 public void perform(WriteGraph graph) throws DatabaseException {
\r
499 graph.addLiteral(resource, predicate, inverse, value, binding);
\r
503 } catch (DatabaseException e) {
\r
504 throw new ServiceException(e);
\r
509 public void addLiteral(final Resource resource, final Resource predicate,
\r
510 final Resource inverse, final Resource type, final Object value, final Binding binding)
\r
511 throws BindingException,
\r
512 ManyObjectsForFunctionalRelationException, ServiceException {
\r
514 session.syncRequest(new WriteRequest() {
\r
517 public void perform(WriteGraph graph) throws DatabaseException {
\r
518 graph.addLiteral(resource, predicate, inverse, type, value, binding);
\r
522 } catch (DatabaseException e) {
\r
523 throw new ServiceException(e);
\r
528 public <T> void addMetadata(Metadata data) throws ServiceException {
\r
529 throw new RuntimeException("Not supported.");
\r
534 public void addValue(final Resource resource, final Resource predicate,
\r
535 final Resource inverse, final Resource type, final Object value, final Binding binding)
\r
536 throws BindingException,
\r
537 ManyObjectsForFunctionalRelationException, ServiceException {
\r
539 session.syncRequest(new WriteRequest() {
\r
542 public void perform(WriteGraph graph) throws DatabaseException {
\r
543 graph.addValue(resource, predicate, inverse, type, value, binding);
\r
547 } catch (DatabaseException e) {
\r
548 throw new ServiceException(e);
\r
553 public <T> void asyncRequest(final AsyncMultiRead<T> request) {
\r
554 session.asyncRequest(request);
\r
558 public <T> void asyncRequest(AsyncMultiRead<T> request,
\r
559 AsyncMultiListener<T> procedure) {
\r
560 session.asyncRequest(request,procedure);
\r
564 public <T> void asyncRequest(AsyncMultiRead<T> request,
\r
565 AsyncMultiProcedure<T> procedure) {
\r
566 session.asyncRequest(request,procedure);
\r
570 public <T> void asyncRequest(AsyncMultiRead<T> request,
\r
571 MultiListener<T> procedure) {
\r
572 session.asyncRequest(request,procedure);
\r
576 public <T> void asyncRequest(AsyncMultiRead<T> request,
\r
577 MultiProcedure<T> procedure) {
\r
578 session.asyncRequest(request,procedure);
\r
582 public <T> void asyncRequest(AsyncMultiRead<T> request,
\r
583 SyncMultiListener<T> procedure) {
\r
584 session.asyncRequest(request,procedure);
\r
588 public <T> void asyncRequest(AsyncMultiRead<T> request,
\r
589 SyncMultiProcedure<T> procedure) {
\r
590 session.asyncRequest(request,procedure);
\r
594 public <T> void asyncRequest(AsyncRead<T> request) {
\r
595 session.asyncRequest(request);
\r
599 public <T> void asyncRequest(AsyncRead<T> request,
\r
600 AsyncListener<T> procedure) {
\r
601 session.asyncRequest(request,procedure);
\r
605 public <T> void asyncRequest(AsyncRead<T> request,
\r
606 AsyncProcedure<T> procedure) {
\r
607 session.asyncRequest(request,procedure);
\r
611 public <T> void asyncRequest(AsyncRead<T> request, Listener<T> procedure) {
\r
612 session.asyncRequest(request,procedure);
\r
616 public <T> void asyncRequest(AsyncRead<T> request,
\r
617 Procedure<T> procedure) {
\r
618 session.asyncRequest(request,procedure);
\r
622 public <T> void asyncRequest(AsyncRead<T> request,
\r
623 SyncListener<T> procedure) {
\r
624 session.asyncRequest(request,procedure);
\r
628 public <T> void asyncRequest(AsyncRead<T> request,
\r
629 SyncProcedure<T> procedure) {
\r
630 session.asyncRequest(request,procedure);
\r
634 public void asyncRequest(DelayedWrite request) {
\r
635 session.asyncRequest(request);
\r
639 public void asyncRequest(DelayedWrite request,
\r
640 Callback<DatabaseException> callback) {
\r
641 session.asyncRequest(request,callback);
\r
645 public <T> void asyncRequest(DelayedWriteResult<T> r,
\r
646 Procedure<T> procedure) {
\r
647 session.asyncRequest(r,procedure);
\r
651 public <T> void asyncRequest(ExternalRead<T> request) {
\r
652 session.asyncRequest(request);
\r
656 public <T> void asyncRequest(ExternalRead<T> request,
\r
657 Listener<T> procedure) {
\r
658 session.asyncRequest(request,procedure);
\r
662 public <T> void asyncRequest(ExternalRead<T> request,
\r
663 Procedure<T> procedure) {
\r
664 session.asyncRequest(request,procedure);
\r
668 public <T> void asyncRequest(MultiRead<T> request) {
\r
669 session.asyncRequest(request);
\r
673 public <T> void asyncRequest(MultiRead<T> request,
\r
674 AsyncMultiListener<T> procedure) {
\r
675 session.asyncRequest(request,procedure);
\r
679 public <T> void asyncRequest(MultiRead<T> request,
\r
680 AsyncMultiProcedure<T> procedure) {
\r
681 session.asyncRequest(request,procedure);
\r
685 public <T> void asyncRequest(MultiRead<T> request,
\r
686 MultiListener<T> procedure) {
\r
687 session.asyncRequest(request,procedure);
\r
691 public <T> void asyncRequest(MultiRead<T> request,
\r
692 MultiProcedure<T> procedure) {
\r
693 session.asyncRequest(request,procedure);
\r
697 public <T> void asyncRequest(MultiRead<T> request,
\r
698 SyncMultiListener<T> procedure) {
\r
699 session.asyncRequest(request,procedure);
\r
703 public <T> void asyncRequest(MultiRead<T> request,
\r
704 SyncMultiProcedure<T> procedure) {
\r
705 session.asyncRequest(request,procedure);
\r
709 public <T> void asyncRequest(Read<T> request) {
\r
710 session.asyncRequest(request);
\r
714 public <T> void asyncRequest(Read<T> request, AsyncListener<T> procedure) {
\r
715 session.asyncRequest(request,procedure);
\r
719 public <T> void asyncRequest(Read<T> request,
\r
720 AsyncProcedure<T> procedure) {
\r
721 session.asyncRequest(request,procedure);
\r
725 public <T> void asyncRequest(Read<T> request, Listener<T> procedure) {
\r
726 session.asyncRequest(request,procedure);
\r
730 public <T> void asyncRequest(Read<T> request, Procedure<T> procedure) {
\r
731 session.asyncRequest(request,procedure);
\r
735 public <T> void asyncRequest(Read<T> request, SyncListener<T> procedure) {
\r
736 session.asyncRequest(request,procedure);
\r
740 public <T> void asyncRequest(Read<T> request, SyncProcedure<T> procedure) {
\r
741 session.asyncRequest(request,procedure);
\r
745 public void asyncRequest(Write request) {
\r
746 session.asyncRequest(request);
\r
750 public void asyncRequest(Write request,
\r
751 Callback<DatabaseException> callback) {
\r
752 session.asyncRequest(request, callback);
\r
756 public void asyncRequest(WriteOnly r) {
\r
757 session.asyncRequest(r);
\r
761 public void asyncRequest(WriteOnly r,
\r
762 Callback<DatabaseException> callback) {
\r
763 session.asyncRequest(r,callback);
\r
767 public <T> void asyncRequest(WriteOnlyResult<T> r,
\r
768 Procedure<T> procedure) {
\r
769 session.asyncRequest(r,procedure);
\r
773 public <T> void asyncRequest(WriteResult<T> r, Procedure<T> procedure) {
\r
774 session.asyncRequest(r,procedure);
\r
780 public void claim(final Resource subject, final Resource predicate,
\r
781 final Resource inverse, final Resource object) throws ServiceException {
\r
783 session.syncRequest(new WriteRequest() {
\r
786 public void perform(WriteGraph graph) throws DatabaseException {
\r
787 graph.claim(subject, predicate, inverse, object);
\r
790 } catch (DatabaseException e) {
\r
791 throw new ServiceException(e);
\r
796 public void claim(final Resource subject, final Resource predicate, final Resource object)
\r
797 throws ServiceException {
\r
799 session.syncRequest(new WriteRequest() {
\r
802 public void perform(WriteGraph graph) throws DatabaseException {
\r
803 graph.claim(subject, predicate, object);
\r
806 } catch (DatabaseException e) {
\r
807 throw new ServiceException(e);
\r
813 public void claimLiteral(final Resource resource, final Resource predicate,
\r
814 final Object value) throws ManyObjectsForFunctionalRelationException,
\r
817 session.syncRequest(new WriteRequest() {
\r
820 public void perform(WriteGraph graph) throws DatabaseException {
\r
821 graph.claimLiteral(resource, predicate, value);
\r
824 } catch (DatabaseException e) {
\r
825 throw new ServiceException(e);
\r
831 public void claimLiteral(final Resource resource, final Resource predicate,
\r
832 final Object value, final Binding binding) throws BindingException,
\r
833 ManyObjectsForFunctionalRelationException, ServiceException {
\r
835 session.syncRequest(new WriteRequest() {
\r
838 public void perform(WriteGraph graph) throws DatabaseException {
\r
839 graph.claimLiteral(resource, predicate, value, binding);
\r
842 } catch (DatabaseException e) {
\r
843 throw new ServiceException(e);
\r
849 public void claimLiteral(final Resource resource, final Resource predicate,
\r
850 final Resource inverse, final Resource type, final Object value)
\r
851 throws BindingException,
\r
852 ManyObjectsForFunctionalRelationException, ServiceException {
\r
854 session.syncRequest(new WriteRequest() {
\r
857 public void perform(WriteGraph graph) throws DatabaseException {
\r
858 graph.claimLiteral(resource, predicate, inverse, type, value);
\r
861 } catch (DatabaseException e) {
\r
862 throw new ServiceException(e);
\r
868 public void claimLiteral(final Resource resource, final Resource predicate,
\r
869 final Resource inverse, final Resource type, final Object value, final Binding binding)
\r
870 throws BindingException,
\r
871 ManyObjectsForFunctionalRelationException, ServiceException {
\r
873 session.syncRequest(new WriteRequest() {
\r
876 public void perform(WriteGraph graph) throws DatabaseException {
\r
877 graph.claimLiteral(resource, predicate, inverse, type, value, binding);
\r
880 } catch (DatabaseException e) {
\r
881 throw new ServiceException(e);
\r
887 public void claimLiteral(final Resource resource, final Resource predicate,
\r
888 final Resource type, final Object value) throws BindingException,
\r
889 ManyObjectsForFunctionalRelationException, ServiceException {
\r
891 session.syncRequest(new WriteRequest() {
\r
894 public void perform(WriteGraph graph) throws DatabaseException {
\r
895 graph.claimLiteral(resource, predicate, type, value);
\r
898 } catch (DatabaseException e) {
\r
899 throw new ServiceException(e);
\r
905 public void claimLiteral(final Resource resource, final Resource predicate,
\r
906 final Resource type, final Object value, final Binding binding)
\r
907 throws BindingException,
\r
908 ManyObjectsForFunctionalRelationException, ServiceException {
\r
910 session.syncRequest(new WriteRequest() {
\r
913 public void perform(WriteGraph graph) throws DatabaseException {
\r
914 graph.claimLiteral(resource, predicate, type, value, binding);
\r
917 } catch (DatabaseException e) {
\r
918 throw new ServiceException(e);
\r
924 public void claimValue(final Resource resource, final Object value)
\r
925 throws ServiceException {
\r
927 session.syncRequest(new WriteRequest() {
\r
930 public void perform(WriteGraph graph) throws DatabaseException {
\r
931 graph.claimValue(resource, value);
\r
934 } catch (DatabaseException e) {
\r
935 throw new ServiceException(e);
\r
941 public void claimValue(final Resource resource, final Object value, final Binding binding)
\r
942 throws ServiceException {
\r
944 session.syncRequest(new WriteRequest() {
\r
947 public void perform(WriteGraph graph) throws DatabaseException {
\r
948 graph.claimValue(resource, value, binding);
\r
951 } catch (DatabaseException e) {
\r
952 throw new ServiceException(e);
\r
957 @SuppressWarnings("deprecation")
\r
959 public void claimValue(final Resource resource, final Resource predicate,
\r
960 final Object value) throws ManyObjectsForFunctionalRelationException,
\r
963 session.syncRequest(new WriteRequest() {
\r
966 public void perform(WriteGraph graph) throws DatabaseException {
\r
967 graph.claimValue(resource, predicate, value);
\r
970 } catch (DatabaseException e) {
\r
971 throw new ServiceException(e);
\r
976 @SuppressWarnings("deprecation")
\r
978 public void claimValue(final Resource resource, final Resource predicate,
\r
979 final Object value, final Binding binding) throws BindingException,
\r
980 ManyObjectsForFunctionalRelationException, ServiceException {
\r
982 session.syncRequest(new WriteRequest() {
\r
985 public void perform(WriteGraph graph) throws DatabaseException {
\r
986 graph.claimValue(resource, predicate, value, binding);
\r
989 } catch (DatabaseException e) {
\r
990 throw new ServiceException(e);
\r
995 @SuppressWarnings("deprecation")
\r
997 public void claimValue(final Resource resource, final Resource predicate,
\r
998 final Resource inverse, final Resource type, final Object value, final Binding binding)
\r
999 throws BindingException,
\r
1000 ManyObjectsForFunctionalRelationException, ServiceException {
\r
1002 session.syncRequest(new WriteRequest() {
\r
1005 public void perform(WriteGraph graph) throws DatabaseException {
\r
1006 graph.claimValue(resource, predicate, inverse, type, value, binding);
\r
1009 } catch (DatabaseException e) {
\r
1010 throw new ServiceException(e);
\r
1016 public void deny(final Resource subject) throws ServiceException {
\r
1018 session.syncRequest(new WriteRequest() {
\r
1021 public void perform(WriteGraph graph) throws DatabaseException {
\r
1022 graph.deny(subject);
\r
1025 } catch (DatabaseException e) {
\r
1026 throw new ServiceException(e);
\r
1032 public void deny(final Resource subject, final Resource predicate)
\r
1033 throws ServiceException {
\r
1035 session.syncRequest(new WriteRequest() {
\r
1038 public void perform(WriteGraph graph) throws DatabaseException {
\r
1039 graph.deny(subject, predicate);
\r
1042 } catch (DatabaseException e) {
\r
1043 throw new ServiceException(e);
\r
1049 public void deny(final Resource subject, final Resource predicate,
\r
1050 final Resource inverse, final Resource object) throws ServiceException {
\r
1052 session.syncRequest(new WriteRequest() {
\r
1055 public void perform(WriteGraph graph) throws DatabaseException {
\r
1056 graph.deny(subject, predicate, inverse, object);
\r
1059 } catch (DatabaseException e) {
\r
1060 throw new ServiceException(e);
\r
1066 public void deny(final Resource subject, final Resource predicate, final Resource object)
\r
1067 throws ServiceException {
\r
1069 session.syncRequest(new WriteRequest() {
\r
1072 public void perform(WriteGraph graph) throws DatabaseException {
\r
1073 graph.deny(subject, predicate, object);
\r
1076 } catch (DatabaseException e) {
\r
1077 throw new ServiceException(e);
\r
1083 public void deny(final Statement statement) throws ServiceException {
\r
1085 session.syncRequest(new WriteRequest() {
\r
1088 public void perform(WriteGraph graph) throws DatabaseException {
\r
1089 graph.deny(statement);
\r
1092 } catch (DatabaseException e) {
\r
1093 throw new ServiceException(e);
\r
1100 public void denyStatement(final Resource subject, final Resource predicate,
\r
1101 final Resource object) throws ServiceException {
\r
1103 session.syncRequest(new WriteRequest() {
\r
1106 public void perform(WriteGraph graph) throws DatabaseException {
\r
1107 graph.denyStatement(subject, predicate, object);
\r
1110 } catch (DatabaseException e) {
\r
1111 throw new ServiceException(e);
\r
1117 public void denyValue(final Resource resource) throws ServiceException {
\r
1119 session.syncRequest(new WriteRequest() {
\r
1122 public void perform(WriteGraph graph) throws DatabaseException {
\r
1123 graph.denyValue(resource);
\r
1126 } catch (DatabaseException e) {
\r
1127 throw new ServiceException(e);
\r
1133 public void denyValue(final Resource resource, final Resource predicate)
\r
1134 throws ManyObjectsForFunctionalRelationException,
\r
1135 ServiceException {
\r
1137 session.syncRequest(new WriteRequest() {
\r
1140 public void perform(WriteGraph graph) throws DatabaseException {
\r
1141 graph.denyValue(resource, predicate);
\r
1144 } catch (DatabaseException e) {
\r
1145 throw new ServiceException(e);
\r
1150 public void flushCluster() throws ServiceException {
\r
1152 session.syncRequest(new WriteRequest() {
\r
1155 public void perform(WriteGraph graph) throws DatabaseException {
\r
1156 graph.flushCluster();
\r
1160 } catch (DatabaseException e) {
\r
1161 throw new ServiceException(e);
\r
1167 public void flushCluster(final Resource r) throws ServiceException {
\r
1169 session.syncRequest(new WriteRequest() {
\r
1172 public void perform(WriteGraph graph) throws DatabaseException {
\r
1173 graph.flushCluster(r);
\r
1177 } catch (DatabaseException e) {
\r
1178 throw new ServiceException(e);
\r
1183 public <T> void forAdapted(final Resource resource, final Class<T> clazz,
\r
1184 final AsyncListener<T> procedure) {
\r
1186 session.syncRequest(new ReadRequest() {
\r
1189 public void run(ReadGraph graph) throws DatabaseException {
\r
1190 graph.forAdapted(resource, clazz, procedure);
\r
1193 } catch (DatabaseException e) {
\r
1200 public <T> void forAdapted(final Resource resource, final Class<T> clazz,
\r
1201 final AsyncProcedure<T> procedure) {
\r
1203 session.syncRequest(new ReadRequest() {
\r
1206 public void run(ReadGraph graph) throws DatabaseException {
\r
1207 graph.forAdapted(resource, clazz, procedure);
\r
1210 } catch (DatabaseException e) {
\r
1216 public <T> void forAdapted(final Resource resource, final Class<T> clazz,
\r
1217 final Listener<T> procedure) {
\r
1219 session.syncRequest(new ReadRequest() {
\r
1222 public void run(ReadGraph graph) throws DatabaseException {
\r
1223 graph.forAdapted(resource, clazz, procedure);
\r
1226 } catch (DatabaseException e) {
\r
1232 public <T> void forAdapted(final Resource resource, final Class<T> clazz,
\r
1233 final Procedure<T> procedure) {
\r
1235 session.syncRequest(new ReadRequest() {
\r
1238 public void run(ReadGraph graph) throws DatabaseException {
\r
1239 graph.forAdapted(resource, clazz, procedure);
\r
1242 } catch (DatabaseException e) {
\r
1249 public <T> void forAdapted(final Resource resource, final Class<T> clazz,
\r
1250 final SyncListener<T> procedure) {
\r
1252 session.syncRequest(new ReadRequest() {
\r
1255 public void run(ReadGraph graph) throws DatabaseException {
\r
1256 graph.forAdapted(resource, clazz, procedure);
\r
1259 } catch (DatabaseException e) {
\r
1266 public <T> void forAdapted(final Resource resource, final Class<T> clazz,
\r
1267 final SyncProcedure<T> procedure) {
\r
1269 session.syncRequest(new ReadRequest() {
\r
1272 public void run(ReadGraph graph) throws DatabaseException {
\r
1273 graph.forAdapted(resource, clazz, procedure);
\r
1276 } catch (DatabaseException e) {
\r
1282 public void forAssertedObjectSet(final Resource subject, final Resource relation,
\r
1283 final AsyncSetListener<Resource> procedure) {
\r
1285 session.syncRequest(new ReadRequest() {
\r
1288 public void run(ReadGraph graph) throws DatabaseException {
\r
1289 graph.forAssertedObjectSet(subject, relation, procedure);
\r
1292 } catch (DatabaseException e) {
\r
1299 public void forAssertedObjectSet(final Resource subject, final Resource relation,
\r
1300 final SetListener<Resource> procedure) {
\r
1302 session.syncRequest(new ReadRequest() {
\r
1305 public void run(ReadGraph graph) throws DatabaseException {
\r
1306 graph.forAssertedObjectSet(subject, relation, procedure);
\r
1309 } catch (DatabaseException e) {
\r
1315 public void forAssertedObjectSet(final Resource subject, final Resource relation,
\r
1316 final SyncSetListener<Resource> procedure) {
\r
1318 session.syncRequest(new ReadRequest() {
\r
1321 public void run(ReadGraph graph) throws DatabaseException {
\r
1322 graph.forAssertedObjectSet(subject, relation, procedure);
\r
1325 } catch (DatabaseException e) {
\r
1331 public void forAssertedStatementSet(final Resource subject,
\r
1332 final Resource relation, final AsyncSetListener<Statement> procedure) {
\r
1334 session.syncRequest(new ReadRequest() {
\r
1337 public void run(ReadGraph graph) throws DatabaseException {
\r
1338 graph.forAssertedStatementSet(subject, relation, procedure);
\r
1341 } catch (DatabaseException e) {
\r
1347 public void forAssertedStatementSet(final Resource subject,
\r
1348 final Resource relation, final SetListener<Statement> procedure) {
\r
1350 session.syncRequest(new ReadRequest() {
\r
1353 public void run(ReadGraph graph) throws DatabaseException {
\r
1354 graph.forAssertedStatementSet(subject, relation, procedure);
\r
1357 } catch (DatabaseException e) {
\r
1363 public void forAssertedStatementSet(final Resource subject,
\r
1364 final Resource relation, final SyncSetListener<Statement> procedure) {
\r
1366 session.syncRequest(new ReadRequest() {
\r
1369 public void run(ReadGraph graph) throws DatabaseException {
\r
1370 graph.forAssertedStatementSet(subject, relation, procedure);
\r
1373 } catch (DatabaseException e) {
\r
1379 public void forBuiltin(final String id, final AsyncListener<Resource> procedure) {
\r
1381 session.syncRequest(new ReadRequest() {
\r
1384 public void run(ReadGraph graph) throws DatabaseException {
\r
1385 graph.forBuiltin(id, procedure);
\r
1388 } catch (DatabaseException e) {
\r
1395 public void forBuiltin(final String id, final Listener<Resource> procedure) {
\r
1397 session.syncRequest(new ReadRequest() {
\r
1400 public void run(ReadGraph graph) throws DatabaseException {
\r
1401 graph.forBuiltin(id, procedure);
\r
1404 } catch (DatabaseException e) {
\r
1410 public void forBuiltin(final String id, final AsyncProcedure<Resource> procedure) {
\r
1412 session.syncRequest(new ReadRequest() {
\r
1415 public void run(ReadGraph graph) throws DatabaseException {
\r
1416 graph.forBuiltin(id, procedure);
\r
1419 } catch (DatabaseException e) {
\r
1425 public void forBuiltin(final String id, final Procedure<Resource> procedure) {
\r
1427 session.syncRequest(new ReadRequest() {
\r
1430 public void run(ReadGraph graph) throws DatabaseException {
\r
1431 graph.forBuiltin(id, procedure);
\r
1434 } catch (DatabaseException e) {
\r
1440 public void forBuiltin(final String id, final SyncListener<Resource> procedure) {
\r
1442 session.syncRequest(new ReadRequest() {
\r
1445 public void run(ReadGraph graph) throws DatabaseException {
\r
1446 graph.forBuiltin(id, procedure);
\r
1449 } catch (DatabaseException e) {
\r
1455 public void forBuiltin(final String id, final SyncProcedure<Resource> procedure) {
\r
1457 session.syncRequest(new ReadRequest() {
\r
1460 public void run(ReadGraph graph) throws DatabaseException {
\r
1461 graph.forBuiltin(id, procedure);
\r
1464 } catch (DatabaseException e) {
\r
1470 public void forDirectSuperrelations(final Resource subject,
\r
1471 final AsyncMultiProcedure<Resource> procedure) {
\r
1473 session.syncRequest(new ReadRequest() {
\r
1476 public void run(ReadGraph graph) throws DatabaseException {
\r
1477 graph.forDirectSuperrelations(subject, procedure);
\r
1480 } catch (DatabaseException e) {
\r
1486 public void forEachAssertedObject(final Resource subject, final Resource relation,
\r
1487 final AsyncMultiProcedure<Resource> procedure) {
\r
1489 session.syncRequest(new ReadRequest() {
\r
1492 public void run(ReadGraph graph) throws DatabaseException {
\r
1493 graph.forEachAssertedObject(subject, relation, procedure);
\r
1496 } catch (DatabaseException e) {
\r
1502 public void forEachAssertedObject(final Resource subject, final Resource relation,
\r
1503 final MultiProcedure<Resource> procedure) {
\r
1505 session.syncRequest(new ReadRequest() {
\r
1508 public void run(ReadGraph graph) throws DatabaseException {
\r
1509 graph.forEachAssertedObject(subject, relation, procedure);
\r
1512 } catch (DatabaseException e) {
\r
1518 public void forEachAssertedObject(final Resource subject, final Resource relation,
\r
1519 final SyncMultiProcedure<Resource> procedure) {
\r
1521 session.syncRequest(new ReadRequest() {
\r
1524 public void run(ReadGraph graph) throws DatabaseException {
\r
1525 graph.forEachAssertedObject(subject, relation, procedure);
\r
1528 } catch (DatabaseException e) {
\r
1534 public void forEachAssertedStatement(final Resource subject,
\r
1535 final Resource relation, final AsyncMultiProcedure<Statement> procedure) {
\r
1537 session.syncRequest(new ReadRequest() {
\r
1540 public void run(ReadGraph graph) throws DatabaseException {
\r
1541 graph.forEachAssertedStatement(subject, relation, procedure);
\r
1544 } catch (DatabaseException e) {
\r
1550 public void forEachAssertedStatement(final Resource subject,
\r
1551 final Resource relation, final MultiProcedure<Statement> procedure) {
\r
1553 session.syncRequest(new ReadRequest() {
\r
1556 public void run(ReadGraph graph) throws DatabaseException {
\r
1557 graph.forEachAssertedStatement(subject, relation, procedure);
\r
1560 } catch (DatabaseException e) {
\r
1566 public void forEachAssertedStatement(final Resource subject,
\r
1567 final Resource relation, final SyncMultiProcedure<Statement> procedure) {
\r
1569 session.syncRequest(new ReadRequest() {
\r
1572 public void run(ReadGraph graph) throws DatabaseException {
\r
1573 graph.forEachAssertedStatement(subject, relation, procedure);
\r
1576 } catch (DatabaseException e) {
\r
1582 // public void forEachDirectObject(final Resource subject, final Resource relation,
\r
1583 // final AsyncMultiProcedure<Resource> procedure) {
\r
1585 // session.syncRequest(new ReadRequest() {
\r
1588 // public void run(ReadGraph graph) throws DatabaseException {
\r
1589 // graph.forEachDirectObject(subject, relation, procedure);
\r
1592 // } catch (DatabaseException e) {
\r
1598 // public void forEachDirectObject(final Resource subject, final Resource relation,
\r
1599 // final MultiProcedure<Resource> procedure) {
\r
1601 // session.syncRequest(new ReadRequest() {
\r
1604 // public void run(ReadGraph graph) throws DatabaseException {
\r
1605 // graph.forEachDirectObject(subject, relation, procedure);
\r
1608 // } catch (DatabaseException e) {
\r
1614 // public void forEachDirectObject(final Resource subject, final Resource relation,
\r
1615 // final SyncMultiProcedure<Resource> procedure) {
\r
1617 // session.syncRequest(new ReadRequest() {
\r
1620 // public void run(ReadGraph graph) throws DatabaseException {
\r
1621 // graph.forEachDirectObject(subject, relation, procedure);
\r
1624 // } catch (DatabaseException e) {
\r
1630 public void forEachDirectPredicate(final Resource subject,
\r
1631 final AsyncMultiProcedure<Resource> procedure) {
\r
1633 session.syncRequest(new ReadRequest() {
\r
1636 public void run(ReadGraph graph) throws DatabaseException {
\r
1637 graph.forEachDirectPredicate(subject, procedure);
\r
1640 } catch (DatabaseException e) {
\r
1646 public void forEachDirectPredicate(final Resource subject,
\r
1647 final MultiProcedure<Resource> procedure) {
\r
1649 session.syncRequest(new ReadRequest() {
\r
1652 public void run(ReadGraph graph) throws DatabaseException {
\r
1653 graph.forEachDirectPredicate(subject, procedure);
\r
1656 } catch (DatabaseException e) {
\r
1662 public void forEachDirectPredicate(final Resource subject,
\r
1663 final SyncMultiProcedure<Resource> procedure) {
\r
1665 session.syncRequest(new ReadRequest() {
\r
1668 public void run(ReadGraph graph) throws DatabaseException {
\r
1669 graph.forEachDirectPredicate(subject, procedure);
\r
1672 } catch (DatabaseException e) {
\r
1678 public void forEachObject(final Resource subject, final Resource relation,
\r
1679 final AsyncMultiProcedure<Resource> procedure) {
\r
1681 session.syncRequest(new ReadRequest() {
\r
1684 public void run(ReadGraph graph) throws DatabaseException {
\r
1685 graph.forEachObject(subject, relation, procedure);
\r
1688 } catch (DatabaseException e) {
\r
1694 public void forEachObject(final Resource subject, final Resource relation,
\r
1695 final MultiProcedure<Resource> procedure) {
\r
1697 session.syncRequest(new ReadRequest() {
\r
1700 public void run(ReadGraph graph) throws DatabaseException {
\r
1701 graph.forEachObject(subject, relation, procedure);
\r
1704 } catch (DatabaseException e) {
\r
1710 public void forEachObject(final Resource subject, final Resource relation,
\r
1711 final SyncMultiProcedure<Resource> procedure) {
\r
1713 session.syncRequest(new ReadRequest() {
\r
1716 public void run(ReadGraph graph) throws DatabaseException {
\r
1717 graph.forEachObject(subject, relation, procedure);
\r
1720 } catch (DatabaseException e) {
\r
1726 public void forEachPredicate(final Resource subject,
\r
1727 final AsyncMultiProcedure<Resource> procedure) {
\r
1729 session.syncRequest(new ReadRequest() {
\r
1732 public void run(ReadGraph graph) throws DatabaseException {
\r
1733 graph.forEachPredicate(subject, procedure);
\r
1736 } catch (DatabaseException e) {
\r
1742 public void forEachPredicate(final Resource subject,
\r
1743 final MultiProcedure<Resource> procedure) {
\r
1745 session.syncRequest(new ReadRequest() {
\r
1748 public void run(ReadGraph graph) throws DatabaseException {
\r
1749 graph.forEachPredicate(subject, procedure);
\r
1752 } catch (DatabaseException e) {
\r
1758 public void forEachPredicate(final Resource subject,
\r
1759 final SyncMultiProcedure<Resource> procedure) {
\r
1761 session.syncRequest(new ReadRequest() {
\r
1764 public void run(ReadGraph graph) throws DatabaseException {
\r
1765 graph.forEachPredicate(subject, procedure);
\r
1768 } catch (DatabaseException e) {
\r
1774 public void forEachPrincipalType(final Resource subject,
\r
1775 final AsyncMultiProcedure<Resource> procedure) {
\r
1777 session.syncRequest(new ReadRequest() {
\r
1780 public void run(ReadGraph graph) throws DatabaseException {
\r
1781 graph.forEachPrincipalType(subject, procedure);
\r
1784 } catch (DatabaseException e) {
\r
1790 public void forEachPrincipalType(final Resource subject,
\r
1791 final MultiProcedure<Resource> procedure) {
\r
1793 session.syncRequest(new ReadRequest() {
\r
1796 public void run(ReadGraph graph) throws DatabaseException {
\r
1797 graph.forEachPrincipalType(subject, procedure);
\r
1800 } catch (DatabaseException e) {
\r
1806 public void forEachPrincipalType(final Resource subject,
\r
1807 final SyncMultiProcedure<Resource> procedure) {
\r
1809 session.syncRequest(new ReadRequest() {
\r
1812 public void run(ReadGraph graph) throws DatabaseException {
\r
1813 graph.forEachPrincipalType(subject, procedure);
\r
1816 } catch (DatabaseException e) {
\r
1822 public void forEachStatement(final Resource subject, final Resource relation,
\r
1823 final AsyncMultiProcedure<Statement> procedure) {
\r
1825 session.syncRequest(new ReadRequest() {
\r
1828 public void run(ReadGraph graph) throws DatabaseException {
\r
1829 graph.forEachStatement(subject, relation, procedure);
\r
1832 } catch (DatabaseException e) {
\r
1838 public void forEachStatement(final Resource subject, final Resource relation,
\r
1839 final MultiProcedure<Statement> procedure) {
\r
1841 session.syncRequest(new ReadRequest() {
\r
1844 public void run(ReadGraph graph) throws DatabaseException {
\r
1845 graph.forEachStatement(subject, relation, procedure);
\r
1848 } catch (DatabaseException e) {
\r
1854 public void forEachStatement(final Resource subject, final Resource relation,
\r
1855 final SyncMultiProcedure<Statement> procedure) {
\r
1857 session.syncRequest(new ReadRequest() {
\r
1860 public void run(ReadGraph graph) throws DatabaseException {
\r
1861 graph.forEachStatement(subject, relation, procedure);
\r
1864 } catch (DatabaseException e) {
\r
1870 public void forHasStatement(final Resource subject,
\r
1871 final AsyncListener<Boolean> procedure) {
\r
1873 session.syncRequest(new ReadRequest() {
\r
1876 public void run(ReadGraph graph) throws DatabaseException {
\r
1877 graph.forHasStatement(subject, procedure);
\r
1880 } catch (DatabaseException e) {
\r
1886 public void forHasStatement(final Resource subject,
\r
1887 final AsyncProcedure<Boolean> procedure) {
\r
1889 session.syncRequest(new ReadRequest() {
\r
1892 public void run(ReadGraph graph) throws DatabaseException {
\r
1893 graph.forHasStatement(subject, procedure);
\r
1896 } catch (DatabaseException e) {
\r
1902 public void forHasStatement(final Resource subject,
\r
1903 final Listener<Boolean> procedure) {
\r
1905 session.syncRequest(new ReadRequest() {
\r
1908 public void run(ReadGraph graph) throws DatabaseException {
\r
1909 graph.forHasStatement(subject, procedure);
\r
1912 } catch (DatabaseException e) {
\r
1918 public void forHasStatement(final Resource subject,
\r
1919 final Procedure<Boolean> procedure) {
\r
1921 session.syncRequest(new ReadRequest() {
\r
1924 public void run(ReadGraph graph) throws DatabaseException {
\r
1925 graph.forHasStatement(subject, procedure);
\r
1928 } catch (DatabaseException e) {
\r
1935 public void forHasStatement(final Resource subject, final Resource relation,
\r
1936 final AsyncListener<Boolean> procedure) {
\r
1938 session.syncRequest(new ReadRequest() {
\r
1941 public void run(ReadGraph graph) throws DatabaseException {
\r
1942 graph.forHasStatement(subject, relation, procedure);
\r
1945 } catch (DatabaseException e) {
\r
1951 public void forHasStatement(final Resource subject, final Resource relation,
\r
1952 final AsyncProcedure<Boolean> procedure) {
\r
1954 session.syncRequest(new ReadRequest() {
\r
1957 public void run(ReadGraph graph) throws DatabaseException {
\r
1958 graph.forHasStatement(subject, relation, procedure);
\r
1961 } catch (DatabaseException e) {
\r
1967 public void forHasStatement(final Resource subject, final Resource relation,
\r
1968 final Listener<Boolean> procedure) {
\r
1970 session.syncRequest(new ReadRequest() {
\r
1973 public void run(ReadGraph graph) throws DatabaseException {
\r
1974 graph.forHasStatement(subject, relation, procedure);
\r
1977 } catch (DatabaseException e) {
\r
1983 public void forHasStatement(final Resource subject, final Resource relation,
\r
1984 final Procedure<Boolean> procedure) {
\r
1986 session.syncRequest(new ReadRequest() {
\r
1989 public void run(ReadGraph graph) throws DatabaseException {
\r
1990 graph.forHasStatement(subject, relation, procedure);
\r
1993 } catch (DatabaseException e) {
\r
1999 public void forHasStatement(final Resource subject, final Resource relation,
\r
2000 final Resource object, final AsyncListener<Boolean> procedure) {
\r
2002 session.syncRequest(new ReadRequest() {
\r
2005 public void run(ReadGraph graph) throws DatabaseException {
\r
2006 graph.forHasStatement(subject, relation, object, procedure);
\r
2009 } catch (DatabaseException e) {
\r
2015 public void forHasStatement(final Resource subject, final Resource relation,
\r
2016 final Resource object, final AsyncProcedure<Boolean> procedure) {
\r
2018 session.syncRequest(new ReadRequest() {
\r
2021 public void run(ReadGraph graph) throws DatabaseException {
\r
2022 graph.forHasStatement(subject, relation, object, procedure);
\r
2025 } catch (DatabaseException e) {
\r
2031 public void forHasStatement(final Resource subject, final Resource relation,
\r
2032 final Resource object, final Listener<Boolean> procedure) {
\r
2034 session.syncRequest(new ReadRequest() {
\r
2037 public void run(ReadGraph graph) throws DatabaseException {
\r
2038 graph.forHasStatement(subject, relation, object, procedure);
\r
2041 } catch (DatabaseException e) {
\r
2047 public void forHasStatement(final Resource subject, final Resource relation,
\r
2048 final Resource object, final Procedure<Boolean> procedure) {
\r
2050 session.syncRequest(new ReadRequest() {
\r
2053 public void run(ReadGraph graph) throws DatabaseException {
\r
2054 graph.forHasStatement(subject, relation, object, procedure);
\r
2057 } catch (DatabaseException e) {
\r
2063 public void forHasStatement(final Resource subject, final Resource relation,
\r
2064 final Resource object, final SyncListener<Boolean> procedure) {
\r
2066 session.syncRequest(new ReadRequest() {
\r
2069 public void run(ReadGraph graph) throws DatabaseException {
\r
2070 graph.forHasStatement(subject, relation, object, procedure);
\r
2073 } catch (DatabaseException e) {
\r
2079 public void forHasStatement(final Resource subject, final Resource relation,
\r
2080 final Resource object, final SyncProcedure<Boolean> procedure) {
\r
2082 session.syncRequest(new ReadRequest() {
\r
2085 public void run(ReadGraph graph) throws DatabaseException {
\r
2086 graph.forHasStatement(subject, relation, object, procedure);
\r
2089 } catch (DatabaseException e) {
\r
2095 public void forHasStatement(final Resource subject, final Resource relation,
\r
2096 final SyncListener<Boolean> procedure) {
\r
2098 session.syncRequest(new ReadRequest() {
\r
2101 public void run(ReadGraph graph) throws DatabaseException {
\r
2102 graph.forHasStatement(subject, relation, procedure);
\r
2105 } catch (DatabaseException e) {
\r
2111 public void forHasStatement(final Resource subject, final Resource relation,
\r
2112 final SyncProcedure<Boolean> procedure) {
\r
2114 session.syncRequest(new ReadRequest() {
\r
2117 public void run(ReadGraph graph) throws DatabaseException {
\r
2118 graph.forHasStatement(subject, relation, procedure);
\r
2121 } catch (DatabaseException e) {
\r
2127 public void forHasStatement(final Resource subject,
\r
2128 final SyncListener<Boolean> procedure) {
\r
2130 session.syncRequest(new ReadRequest() {
\r
2133 public void run(ReadGraph graph) throws DatabaseException {
\r
2134 graph.forHasStatement(subject, procedure);
\r
2137 } catch (DatabaseException e) {
\r
2143 public void forHasStatement(final Resource subject,
\r
2144 final SyncProcedure<Boolean> procedure) {
\r
2146 session.syncRequest(new ReadRequest() {
\r
2149 public void run(ReadGraph graph) throws DatabaseException {
\r
2150 graph.forHasStatement(subject, procedure);
\r
2153 } catch (DatabaseException e) {
\r
2159 public void forHasValue(final Resource subject,
\r
2160 final AsyncListener<Boolean> procedure) {
\r
2162 session.syncRequest(new ReadRequest() {
\r
2165 public void run(ReadGraph graph) throws DatabaseException {
\r
2166 graph.forHasValue(subject, procedure);
\r
2169 } catch (DatabaseException e) {
\r
2175 public void forHasValue(final Resource subject,
\r
2176 final AsyncProcedure<Boolean> procedure) {
\r
2178 session.syncRequest(new ReadRequest() {
\r
2181 public void run(ReadGraph graph) throws DatabaseException {
\r
2182 graph.forHasValue(subject, procedure);
\r
2185 } catch (DatabaseException e) {
\r
2191 public void forHasValue(final Resource subject, final Listener<Boolean> procedure) {
\r
2193 session.syncRequest(new ReadRequest() {
\r
2196 public void run(ReadGraph graph) throws DatabaseException {
\r
2197 graph.forHasValue(subject, procedure);
\r
2200 } catch (DatabaseException e) {
\r
2206 public void forHasValue(final Resource subject, final Procedure<Boolean> procedure) {
\r
2208 session.syncRequest(new ReadRequest() {
\r
2211 public void run(ReadGraph graph) throws DatabaseException {
\r
2212 graph.forHasValue(subject, procedure);
\r
2215 } catch (DatabaseException e) {
\r
2221 public void forHasValue(final Resource subject,
\r
2222 final SyncListener<Boolean> procedure) {
\r
2224 session.syncRequest(new ReadRequest() {
\r
2227 public void run(ReadGraph graph) throws DatabaseException {
\r
2228 graph.forHasValue(subject, procedure);
\r
2231 } catch (DatabaseException e) {
\r
2237 public void forHasValue(final Resource subject,
\r
2238 final SyncProcedure<Boolean> procedure) {
\r
2240 session.syncRequest(new ReadRequest() {
\r
2243 public void run(ReadGraph graph) throws DatabaseException {
\r
2244 graph.forHasValue(subject, procedure);
\r
2247 } catch (DatabaseException e) {
\r
2253 public void forInverse(final Resource relation,
\r
2254 final AsyncListener<Resource> procedure) {
\r
2256 session.syncRequest(new ReadRequest() {
\r
2259 public void run(ReadGraph graph) throws DatabaseException {
\r
2260 graph.forInverse(relation, procedure);
\r
2263 } catch (DatabaseException e) {
\r
2269 public <T> T getService(Class<T> api) throws ServiceNotFoundException {
\r
2270 return session.getService(api);
\r
2274 public <T> T peekService(Class<T> api) {
\r
2275 return session.peekService(api);
\r
2279 public boolean hasService(Class<?> api) {
\r
2280 return session.hasService(api);
\r
2284 public <T> void registerService(Class<T> api, T service) {
\r
2285 session.registerService(api, service);
\r
2289 public String getURI(final Resource resource)
\r
2290 throws ValidationException,
\r
2291 ServiceException, AssumptionException {
\r
2293 return session.syncRequest(new Read<String>() {
\r
2296 public String perform(ReadGraph graph) throws DatabaseException {
\r
2297 return graph.getURI(resource);
\r
2300 } catch (DatabaseException e) {
\r
2301 throw new ServiceException(e);
\r
2307 public String getPossibleURI(final Resource resource)
\r
2308 throws ValidationException,
\r
2309 ServiceException {
\r
2311 return session.syncRequest(new Read<String>() {
\r
2314 public String perform(ReadGraph graph) throws DatabaseException {
\r
2315 return graph.getPossibleURI(resource);
\r
2318 } catch (DatabaseException e) {
\r
2319 throw new ServiceException(e);
\r
2324 public Resource getResource(final String uri)
\r
2325 throws ResourceNotFoundException, ValidationException,
\r
2326 ServiceException {
\r
2328 return session.syncRequest(new Read<Resource>() {
\r
2331 public Resource perform(ReadGraph graph) throws DatabaseException {
\r
2332 return graph.getResource(uri);
\r
2335 } catch (DatabaseException e) {
\r
2336 throw new ServiceException(e);
\r
2341 public Resource getPossibleResource(final String uri)
\r
2342 throws ResourceNotFoundException, ValidationException,
\r
2343 ServiceException {
\r
2345 return session.syncRequest(new Read<Resource>() {
\r
2348 public Resource perform(ReadGraph graph) throws DatabaseException {
\r
2349 return graph.getPossibleResource(uri);
\r
2352 } catch (DatabaseException e) {
\r
2353 throw new ServiceException(e);
\r
2358 public Collection<Statement> getStatements(final Resource subject,
\r
2359 final Resource relation)
\r
2360 throws ManyObjectsForFunctionalRelationException,
\r
2361 ServiceException {
\r
2363 return session.syncRequest(new Read<Collection<Statement>>() {
\r
2366 public Collection<Statement> perform(ReadGraph graph) throws DatabaseException {
\r
2367 return graph.getStatements(subject, relation);
\r
2370 } catch (DatabaseException e) {
\r
2371 throw new ServiceException(e);
\r
2376 public Collection<Statement> getAssertedStatements(final Resource subject,
\r
2377 final Resource relation)
\r
2378 throws ManyObjectsForFunctionalRelationException,
\r
2379 ServiceException {
\r
2381 return session.syncRequest(new Read<Collection<Statement>>() {
\r
2384 public Collection<Statement> perform(ReadGraph graph) throws DatabaseException {
\r
2385 return graph.getAssertedStatements(subject, relation);
\r
2388 } catch (DatabaseException e) {
\r
2389 throw new ServiceException(e);
\r
2394 public Collection<Resource> getPredicates(final Resource subject)
\r
2395 throws ServiceException {
\r
2397 return session.syncRequest(new Read<Collection<Resource>>() {
\r
2400 public Collection<Resource> perform(ReadGraph graph) throws DatabaseException {
\r
2401 return graph.getPredicates(subject);
\r
2404 } catch (DatabaseException e) {
\r
2405 throw new ServiceException(e);
\r
2410 public Collection<Resource> getPrincipalTypes(final Resource subject)
\r
2411 throws ServiceException {
\r
2413 return session.syncRequest(new Read<Collection<Resource>>() {
\r
2416 public Collection<Resource> perform(ReadGraph graph) throws DatabaseException {
\r
2417 return graph.getPrincipalTypes(subject);
\r
2420 } catch (DatabaseException e) {
\r
2421 throw new ServiceException(e);
\r
2426 public Set<Resource> getTypes(final Resource subject) throws ServiceException {
\r
2428 return session.syncRequest(new Read<Set<Resource>>() {
\r
2431 public Set<Resource> perform(ReadGraph graph) throws DatabaseException {
\r
2432 return graph.getTypes(subject);
\r
2435 } catch (DatabaseException e) {
\r
2436 throw new ServiceException(e);
\r
2441 public Set<Resource> getSupertypes(final Resource subject)
\r
2442 throws ServiceException {
\r
2444 return session.syncRequest(new Read<Set<Resource>>() {
\r
2447 public Set<Resource> perform(ReadGraph graph) throws DatabaseException {
\r
2448 return graph.getSupertypes(subject);
\r
2451 } catch (DatabaseException e) {
\r
2452 throw new ServiceException(e);
\r
2457 public Set<Resource> getSuperrelations(final Resource subject)
\r
2458 throws ServiceException {
\r
2460 return session.syncRequest(new Read<Set<Resource>>() {
\r
2463 public Set<Resource> perform(ReadGraph graph) throws DatabaseException {
\r
2464 return graph.getSuperrelations(subject);
\r
2467 } catch (DatabaseException e) {
\r
2468 throw new ServiceException(e);
\r
2472 public Resource getPossibleSuperrelation(final Resource subject) throws ServiceException {
\r
2474 return session.syncRequest(new Read<Resource>() {
\r
2476 public Resource perform(ReadGraph graph) throws DatabaseException {
\r
2477 return graph.getPossibleSuperrelation(subject);
\r
2480 } catch (DatabaseException e) {
\r
2481 throw new ServiceException(e);
\r
2486 // public Collection<Resource> getObjects(final Resource subject,
\r
2487 // Resource relation)
\r
2488 // throws ManyObjectsForFunctionalRelationException,
\r
2489 // ServiceException {
\r
2490 // return graph.getObjects(subject, relation);
\r
2494 public Collection<Resource> getAssertedObjects(final Resource subject, final Resource relation)
\r
2495 throws ManyObjectsForFunctionalRelationException,
\r
2496 ServiceException {
\r
2498 return session.syncRequest(new Read<Collection<Resource>>() {
\r
2501 public Collection<Resource> perform(ReadGraph graph) throws DatabaseException {
\r
2502 return graph.getAssertedObjects(subject, relation);
\r
2505 } catch (DatabaseException e) {
\r
2506 throw new ServiceException(e);
\r
2511 public Resource getInverse(final Resource relation)
\r
2512 throws NoInverseException,
\r
2513 ManyObjectsForFunctionalRelationException, ServiceException {
\r
2515 return session.syncRequest(new Read<Resource>() {
\r
2518 public Resource perform(ReadGraph graph) throws DatabaseException {
\r
2519 return graph.getInverse(relation);
\r
2522 } catch (DatabaseException e) {
\r
2523 throw new ServiceException(e);
\r
2528 public Resource getSingleObject(final Resource subject, final Resource relation)
\r
2529 throws NoSingleResultException,
\r
2530 ManyObjectsForFunctionalRelationException, ServiceException {
\r
2532 return session.syncRequest(new Read<Resource>() {
\r
2535 public Resource perform(ReadGraph graph) throws DatabaseException {
\r
2536 return graph.getSingleObject(subject, relation);
\r
2539 } catch (DatabaseException e) {
\r
2540 throw new ServiceException(e);
\r
2545 public Statement getSingleStatement(final Resource subject, final Resource relation)
\r
2546 throws NoSingleResultException,
\r
2547 ManyObjectsForFunctionalRelationException, ServiceException {
\r
2549 return session.syncRequest(new Read<Statement>() {
\r
2552 public Statement perform(ReadGraph graph) throws DatabaseException {
\r
2553 return graph.getSingleStatement(subject, relation);
\r
2556 } catch (DatabaseException e) {
\r
2557 throw new ServiceException(e);
\r
2562 public Resource getSingleType(final Resource subject)
\r
2563 throws NoSingleResultException, ServiceException {
\r
2565 return session.syncRequest(new Read<Resource>() {
\r
2568 public Resource perform(ReadGraph graph) throws DatabaseException {
\r
2569 return graph.getSingleType(subject);
\r
2572 } catch (DatabaseException e) {
\r
2573 throw new ServiceException(e);
\r
2578 public Resource getSingleType(final Resource subject, final Resource baseType)
\r
2579 throws NoSingleResultException, ServiceException {
\r
2581 return session.syncRequest(new Read<Resource>() {
\r
2584 public Resource perform(ReadGraph graph) throws DatabaseException {
\r
2585 return graph.getSingleType(subject, baseType);
\r
2588 } catch (DatabaseException e) {
\r
2589 throw new ServiceException(e);
\r
2594 public <T> T getValue(final Resource subject)
\r
2595 throws DoesNotContainValueException, ServiceException {
\r
2597 return session.syncRequest(new Read<T>() {
\r
2600 public T perform(ReadGraph graph) throws DatabaseException {
\r
2601 return graph.getValue(subject);
\r
2604 } catch (DatabaseException e) {
\r
2605 throw new ServiceException(e);
\r
2610 public <T> T getValue(final Resource subject, final Binding binding)
\r
2611 throws DoesNotContainValueException, BindingException,
\r
2612 ServiceException {
\r
2614 return session.syncRequest(new Read<T>() {
\r
2617 public T perform(ReadGraph graph) throws DatabaseException {
\r
2618 return graph.getValue(subject, binding);
\r
2621 } catch (DatabaseException e) {
\r
2622 throw new ServiceException(e);
\r
2627 public <T> T getRelatedValue(final Resource subject, final Resource relation)
\r
2628 throws NoSingleResultException, DoesNotContainValueException,
\r
2629 ServiceException {
\r
2631 return session.syncRequest(new Read<T>() {
\r
2634 public T perform(ReadGraph graph) throws DatabaseException {
\r
2635 return graph.getRelatedValue(subject, relation);
\r
2638 } catch (DatabaseException e) {
\r
2639 throw new ServiceException(e);
\r
2644 public <T> T getRelatedValue(final Resource subject, final Resource relation,
\r
2645 final Binding binding) throws NoSingleResultException,
\r
2646 DoesNotContainValueException, BindingException,
\r
2647 ServiceException {
\r
2649 return session.syncRequest(new Read<T>() {
\r
2652 public T perform(ReadGraph graph) throws DatabaseException {
\r
2653 return graph.getRelatedValue(subject, relation, binding);
\r
2656 } catch (DatabaseException e) {
\r
2657 throw new ServiceException(e);
\r
2662 public Resource getPossibleInverse(final Resource relation)
\r
2663 throws ManyObjectsForFunctionalRelationException,
\r
2664 ServiceException {
\r
2666 return session.syncRequest(new Read<Resource>() {
\r
2669 public Resource perform(ReadGraph graph) throws DatabaseException {
\r
2670 return graph.getPossibleInverse(relation);
\r
2673 } catch (DatabaseException e) {
\r
2674 throw new ServiceException(e);
\r
2679 public Resource getPossibleObject(final Resource subject, final Resource relation)
\r
2680 throws ManyObjectsForFunctionalRelationException,
\r
2681 ServiceException {
\r
2683 return session.syncRequest(new Read<Resource>() {
\r
2686 public Resource perform(ReadGraph graph) throws DatabaseException {
\r
2687 return graph.getPossibleObject(subject, relation);
\r
2690 } catch (DatabaseException e) {
\r
2691 throw new ServiceException(e);
\r
2696 public Statement getPossibleStatement(final Resource subject,
\r
2697 final Resource relation)
\r
2698 throws ManyObjectsForFunctionalRelationException,
\r
2699 ServiceException {
\r
2701 return session.syncRequest(new Read<Statement>() {
\r
2704 public Statement perform(ReadGraph graph) throws DatabaseException {
\r
2705 return graph.getPossibleStatement(subject, relation);
\r
2708 } catch (DatabaseException e) {
\r
2709 throw new ServiceException(e);
\r
2714 public Resource getPossibleType(final Resource subject, final Resource baseType)
\r
2715 throws ServiceException {
\r
2717 return session.syncRequest(new Read<Resource>() {
\r
2720 public Resource perform(ReadGraph graph) throws DatabaseException {
\r
2721 return graph.getPossibleType(subject, baseType);
\r
2724 } catch (DatabaseException e) {
\r
2725 throw new ServiceException(e);
\r
2730 public <T> T getPossibleValue(final Resource subject) throws ServiceException {
\r
2732 return session.syncRequest(new Read<T>() {
\r
2735 public T perform(ReadGraph graph) throws DatabaseException {
\r
2736 return graph.getPossibleValue(subject);
\r
2739 } catch (DatabaseException e) {
\r
2740 throw new ServiceException(e);
\r
2745 public <T> T getPossibleValue(final Resource subject, final Binding binding)
\r
2746 throws BindingException, ServiceException {
\r
2748 return session.syncRequest(new Read<T>() {
\r
2751 public T perform(ReadGraph graph) throws DatabaseException {
\r
2752 return graph.getPossibleValue(subject, binding);
\r
2755 } catch (DatabaseException e) {
\r
2756 throw new ServiceException(e);
\r
2761 public <T> T getPossibleRelatedValue(final Resource subject, final Resource relation)
\r
2762 throws ManyObjectsForFunctionalRelationException,
\r
2763 ServiceException {
\r
2765 return session.syncRequest(new Read<T>() {
\r
2768 public T perform(ReadGraph graph) throws DatabaseException {
\r
2769 return graph.getPossibleRelatedValue(subject, relation);
\r
2772 } catch (DatabaseException e) {
\r
2773 throw new ServiceException(e);
\r
2778 public <T> T getPossibleRelatedValue(final Resource subject,
\r
2779 final Resource relation, final Binding binding)
\r
2780 throws ManyObjectsForFunctionalRelationException,
\r
2781 BindingException, ServiceException {
\r
2783 return session.syncRequest(new Read<T>() {
\r
2786 public T perform(ReadGraph graph) throws DatabaseException {
\r
2787 return graph.getPossibleRelatedValue(subject, relation, binding);
\r
2790 } catch (DatabaseException e) {
\r
2791 throw new ServiceException(e);
\r
2796 public <T> T getPossibleAdapter(final Resource resource, final Class<T> clazz)
\r
2797 throws ValidationException, ServiceException {
\r
2799 return session.syncRequest(new Read<T>() {
\r
2802 public T perform(ReadGraph graph) throws DatabaseException {
\r
2803 return graph.getPossibleAdapter(resource, clazz);
\r
2806 } catch (DatabaseException e) {
\r
2807 throw new ServiceException(e);
\r
2812 public <T> T getPossibleUniqueAdapter(final Resource resource, final Class<T> clazz)
\r
2813 throws ValidationException, ServiceException {
\r
2815 return session.syncRequest(new Read<T>() {
\r
2818 public T perform(ReadGraph graph) throws DatabaseException {
\r
2819 return graph.getPossibleUniqueAdapter(resource, clazz);
\r
2822 } catch (DatabaseException e) {
\r
2823 throw new ServiceException(e);
\r
2828 public boolean isInstanceOf(final Resource resource, final Resource type)
\r
2829 throws ServiceException {
\r
2831 return session.syncRequest(new Read<Boolean>() {
\r
2834 public Boolean perform(ReadGraph graph) throws DatabaseException {
\r
2835 return graph.isInstanceOf(resource, type);
\r
2838 } catch (DatabaseException e) {
\r
2839 throw new ServiceException(e);
\r
2844 public boolean isInheritedFrom(final Resource resource, final Resource type)
\r
2845 throws ServiceException {
\r
2847 return session.syncRequest(new Read<Boolean>() {
\r
2850 public Boolean perform(ReadGraph graph) throws DatabaseException {
\r
2851 return graph.isInheritedFrom(resource, type);
\r
2854 } catch (DatabaseException e) {
\r
2855 throw new ServiceException(e);
\r
2860 public boolean isSubrelationOf(final Resource resource, final Resource relation)
\r
2861 throws ServiceException {
\r
2863 return session.syncRequest(new Read<Boolean>() {
\r
2866 public Boolean perform(ReadGraph graph) throws DatabaseException {
\r
2867 return graph.isSubrelationOf(resource, relation);
\r
2870 } catch (DatabaseException e) {
\r
2871 throw new ServiceException(e);
\r
2876 public boolean hasStatement(final Resource subject) throws ServiceException {
\r
2878 return session.syncRequest(new Read<Boolean>() {
\r
2881 public Boolean perform(ReadGraph graph) throws DatabaseException {
\r
2882 return graph.hasStatement(subject);
\r
2885 } catch (DatabaseException e) {
\r
2886 throw new ServiceException(e);
\r
2891 public boolean hasStatement(final Resource subject, final Resource relation)
\r
2892 throws ServiceException {
\r
2894 return session.syncRequest(new Read<Boolean>() {
\r
2897 public Boolean perform(ReadGraph graph) throws DatabaseException {
\r
2898 return graph.hasStatement(subject, relation);
\r
2901 } catch (DatabaseException e) {
\r
2902 throw new ServiceException(e);
\r
2907 public boolean hasStatement(final Resource subject, final Resource relation,
\r
2908 final Resource object) throws ServiceException {
\r
2910 return session.syncRequest(new Read<Boolean>() {
\r
2913 public Boolean perform(ReadGraph graph) throws DatabaseException {
\r
2914 return graph.hasStatement(subject, relation, object);
\r
2917 } catch (DatabaseException e) {
\r
2918 throw new ServiceException(e);
\r
2923 public boolean hasValue(final Resource subject) throws ServiceException {
\r
2925 return session.syncRequest(new Read<Boolean>() {
\r
2928 public Boolean perform(ReadGraph graph) throws DatabaseException {
\r
2929 return graph.hasValue(subject);
\r
2932 } catch (DatabaseException e) {
\r
2933 throw new ServiceException(e);
\r
2938 public Datatype getDataType(final Resource subject) throws DatabaseException {
\r
2940 return session.syncRequest(new Read<Datatype>() {
\r
2943 public Datatype perform(ReadGraph graph) throws DatabaseException {
\r
2944 return graph.getDataType(subject);
\r
2947 } catch (DatabaseException e) {
\r
2948 throw new ServiceException(e);
\r
2953 public <T extends Accessor> T getAccessor(final Resource subject)
\r
2954 throws DatabaseException {
\r
2956 return session.syncRequest(new Read<T>() {
\r
2959 public T perform(ReadGraph graph) throws DatabaseException {
\r
2960 return graph.getAccessor(subject);
\r
2963 } catch (DatabaseException e) {
\r
2964 throw new ServiceException(e);
\r
2969 public RandomAccessBinary getRandomAccessBinary(final Resource subject)
\r
2970 throws DatabaseException {
\r
2972 return session.syncRequest(new Read<RandomAccessBinary>() {
\r
2974 public RandomAccessBinary perform(ReadGraph graph) throws DatabaseException {
\r
2975 return graph.getRandomAccessBinary(subject);
\r
2978 } catch (DatabaseException e) {
\r
2979 throw new ServiceException(e);
\r
2984 public <T> T syncRequest(Read<T> request) throws DatabaseException {
\r
2985 return session.syncRequest(request);
\r
2989 public <T> T syncRequest(Read<T> request, AsyncListener<T> procedure)
\r
2990 throws DatabaseException {
\r
2991 return session.syncRequest(request, procedure);
\r
2995 public <T> T syncRequest(Read<T> request, SyncListener<T> procedure)
\r
2996 throws DatabaseException {
\r
2997 return session.syncRequest(request, procedure);
\r
3001 public <T> T syncRequest(Read<T> request, Listener<T> procedure)
\r
3002 throws DatabaseException {
\r
3003 return session.syncRequest(request, procedure);
\r
3007 public <T> T syncRequest(Read<T> request, AsyncProcedure<T> procedure)
\r
3008 throws DatabaseException {
\r
3009 return session.syncRequest(request, procedure);
\r
3013 public <T> T syncRequest(Read<T> request, SyncProcedure<T> procedure)
\r
3014 throws DatabaseException {
\r
3015 return session.syncRequest(request, procedure);
\r
3019 public <T> T syncRequest(Read<T> request, Procedure<T> procedure)
\r
3020 throws DatabaseException {
\r
3021 return session.syncRequest(request, procedure);
\r
3025 public <T> T syncRequest(AsyncRead<T> request) throws DatabaseException {
\r
3026 return session.syncRequest(request);
\r
3030 public <T> T syncRequest(AsyncRead<T> request,
\r
3031 AsyncListener<T> procedure) throws DatabaseException {
\r
3032 return session.syncRequest(request, procedure);
\r
3036 public <T> T syncRequest(AsyncRead<T> request, SyncListener<T> procedure)
\r
3037 throws DatabaseException {
\r
3038 return session.syncRequest(request, procedure);
\r
3042 public <T> T syncRequest(AsyncRead<T> request, Listener<T> procedure)
\r
3043 throws DatabaseException {
\r
3044 return session.syncRequest(request, procedure);
\r
3048 public <T> T syncRequest(AsyncRead<T> request,
\r
3049 AsyncProcedure<T> procedure) throws DatabaseException {
\r
3050 return session.syncRequest(request, procedure);
\r
3054 public <T> T syncRequest(AsyncRead<T> request,
\r
3055 SyncProcedure<T> procedure) throws DatabaseException {
\r
3056 return session.syncRequest(request, procedure);
\r
3060 public <T> T syncRequest(AsyncRead<T> request, Procedure<T> procedure)
\r
3061 throws DatabaseException {
\r
3062 return session.syncRequest(request, procedure);
\r
3066 public <T> Collection<T> syncRequest(MultiRead<T> request)
\r
3067 throws DatabaseException {
\r
3068 return session.syncRequest(request);
\r
3072 public <T> Collection<T> syncRequest(MultiRead<T> request,
\r
3073 AsyncMultiListener<T> procedure) throws DatabaseException {
\r
3074 return session.syncRequest(request, procedure);
\r
3078 public <T> Collection<T> syncRequest(MultiRead<T> request,
\r
3079 SyncMultiListener<T> procedure) throws DatabaseException {
\r
3080 return session.syncRequest(request, procedure);
\r
3084 public <T> Collection<T> syncRequest(MultiRead<T> request,
\r
3085 MultiListener<T> procedure) throws DatabaseException {
\r
3086 return session.syncRequest(request, procedure);
\r
3090 public <T> Collection<T> syncRequest(MultiRead<T> request,
\r
3091 AsyncMultiProcedure<T> procedure) throws DatabaseException {
\r
3092 return session.syncRequest(request, procedure);
\r
3096 public <T> Collection<T> syncRequest(MultiRead<T> request,
\r
3097 SyncMultiProcedure<T> procedure) throws DatabaseException {
\r
3098 return session.syncRequest(request, procedure);
\r
3102 public <T> Collection<T> syncRequest(MultiRead<T> request,
\r
3103 MultiProcedure<T> procedure) throws DatabaseException {
\r
3104 return session.syncRequest(request, procedure);
\r
3108 public <T> Collection<T> syncRequest(AsyncMultiRead<T> request)
\r
3109 throws DatabaseException {
\r
3110 return session.syncRequest(request);
\r
3114 public <T> Collection<T> syncRequest(AsyncMultiRead<T> request,
\r
3115 AsyncMultiListener<T> procedure) throws DatabaseException {
\r
3116 return session.syncRequest(request, procedure);
\r
3120 public <T> Collection<T> syncRequest(AsyncMultiRead<T> request,
\r
3121 SyncMultiListener<T> procedure) throws DatabaseException {
\r
3122 return session.syncRequest(request, procedure);
\r
3126 public <T> Collection<T> syncRequest(AsyncMultiRead<T> request,
\r
3127 MultiListener<T> procedure) throws DatabaseException {
\r
3128 return session.syncRequest(request, procedure);
\r
3132 public <T> Collection<T> syncRequest(AsyncMultiRead<T> request,
\r
3133 AsyncMultiProcedure<T> procedure) throws DatabaseException {
\r
3134 return session.syncRequest(request, procedure);
\r
3138 public <T> Collection<T> syncRequest(AsyncMultiRead<T> request,
\r
3139 SyncMultiProcedure<T> procedure) throws DatabaseException {
\r
3140 return session.syncRequest(request, procedure);
\r
3144 public <T> Collection<T> syncRequest(AsyncMultiRead<T> request,
\r
3145 MultiProcedure<T> procedure) throws DatabaseException {
\r
3146 return session.syncRequest(request, procedure);
\r
3150 public <T> T syncRequest(ExternalRead<T> request)
\r
3151 throws DatabaseException {
\r
3152 return session.syncRequest(request);
\r
3156 public <T> T syncRequest(ExternalRead<T> request, Listener<T> procedure)
\r
3157 throws DatabaseException {
\r
3158 return session.syncRequest(request, procedure);
\r
3162 public <T> T syncRequest(ExternalRead<T> request, Procedure<T> procedure)
\r
3163 throws DatabaseException {
\r
3164 return session.syncRequest(request, procedure);
\r
3168 public void syncRequest(Write request) throws DatabaseException {
\r
3169 session.syncRequest(request);
\r
3173 public void syncRequest(DelayedWrite request) throws DatabaseException {
\r
3174 session.syncRequest(request);
\r
3178 public void syncRequest(WriteOnly r) throws DatabaseException {
\r
3179 session.syncRequest(r);
\r
3183 public <T> T syncRequest(WriteResult<T> request)
\r
3184 throws DatabaseException {
\r
3185 return session.syncRequest(request);
\r
3189 public <T> T syncRequest(DelayedWriteResult<T> request)
\r
3190 throws DatabaseException {
\r
3191 return session.syncRequest(request);
\r
3195 public <T> T syncRequest(WriteOnlyResult<T> r) throws DatabaseException {
\r
3196 return session.syncRequest(r);
\r
3200 public void forURI(final Resource resource, final AsyncListener<String> procedure) {
\r
3202 session.syncRequest(new ReadRequest() {
\r
3205 public void run(ReadGraph graph) throws DatabaseException {
\r
3206 graph.forURI(resource, procedure);
\r
3209 } catch (DatabaseException e) {
\r
3215 public void forURI(final Resource resource, final SyncListener<String> procedure) {
\r
3217 session.syncRequest(new ReadRequest() {
\r
3220 public void run(ReadGraph graph) throws DatabaseException {
\r
3221 graph.forURI(resource, procedure);
\r
3224 } catch (DatabaseException e) {
\r
3230 public void forURI(final Resource resource, final Listener<String> procedure) {
\r
3232 session.syncRequest(new ReadRequest() {
\r
3235 public void run(ReadGraph graph) throws DatabaseException {
\r
3236 graph.forURI(resource, procedure);
\r
3239 } catch (DatabaseException e) {
\r
3245 public void forURI(final Resource resource, final AsyncProcedure<String> procedure) {
\r
3247 session.syncRequest(new ReadRequest() {
\r
3250 public void run(ReadGraph graph) throws DatabaseException {
\r
3251 graph.forURI(resource, procedure);
\r
3254 } catch (DatabaseException e) {
\r
3260 public void forURI(final Resource resource, final SyncProcedure<String> procedure) {
\r
3262 session.syncRequest(new ReadRequest() {
\r
3265 public void run(ReadGraph graph) throws DatabaseException {
\r
3266 graph.forURI(resource, procedure);
\r
3269 } catch (DatabaseException e) {
\r
3275 public void forURI(final Resource resource, final Procedure<String> procedure) {
\r
3277 session.syncRequest(new ReadRequest() {
\r
3280 public void run(ReadGraph graph) throws DatabaseException {
\r
3281 graph.forURI(resource, procedure);
\r
3284 } catch (DatabaseException e) {
\r
3290 public void forResource(final String id, final AsyncListener<Resource> procedure) {
\r
3292 session.syncRequest(new ReadRequest() {
\r
3295 public void run(ReadGraph graph) throws DatabaseException {
\r
3296 graph.forResource(id, procedure);
\r
3299 } catch (DatabaseException e) {
\r
3305 public void forResource(final String id, final SyncListener<Resource> procedure) {
\r
3307 session.syncRequest(new ReadRequest() {
\r
3310 public void run(ReadGraph graph) throws DatabaseException {
\r
3311 graph.forResource(id, procedure);
\r
3314 } catch (DatabaseException e) {
\r
3320 public void forResource(final String id, final Listener<Resource> procedure) {
\r
3322 session.syncRequest(new ReadRequest() {
\r
3325 public void run(ReadGraph graph) throws DatabaseException {
\r
3326 graph.forResource(id, procedure);
\r
3329 } catch (DatabaseException e) {
\r
3335 public void forResource(final String id, final AsyncProcedure<Resource> procedure) {
\r
3337 session.syncRequest(new ReadRequest() {
\r
3340 public void run(ReadGraph graph) throws DatabaseException {
\r
3341 graph.forResource(id, procedure);
\r
3344 } catch (DatabaseException e) {
\r
3350 public void forResource(final String id, final SyncProcedure<Resource> procedure) {
\r
3352 session.syncRequest(new ReadRequest() {
\r
3355 public void run(ReadGraph graph) throws DatabaseException {
\r
3356 graph.forResource(id, procedure);
\r
3359 } catch (DatabaseException e) {
\r
3365 public void forResource(final String id, final Procedure<Resource> procedure) {
\r
3367 session.syncRequest(new ReadRequest() {
\r
3370 public void run(ReadGraph graph) throws DatabaseException {
\r
3371 graph.forResource(id, procedure);
\r
3374 } catch (DatabaseException e) {
\r
3380 public void forStatementSet(final Resource subject, final Resource relation,
\r
3381 final AsyncSetListener<Statement> procedure) {
\r
3383 session.syncRequest(new ReadRequest() {
\r
3386 public void run(ReadGraph graph) throws DatabaseException {
\r
3387 graph.forStatementSet(subject, relation, procedure);
\r
3390 } catch (DatabaseException e) {
\r
3396 public void forStatementSet(final Resource subject, final Resource relation,
\r
3397 final SyncSetListener<Statement> procedure) {
\r
3400 session.syncRequest(new ReadRequest() {
\r
3403 public void run(ReadGraph graph) throws DatabaseException {
\r
3404 graph.forStatementSet(subject, relation, procedure);
\r
3407 } catch (DatabaseException e) {
\r
3413 public void forStatementSet(final Resource subject, final Resource relation,
\r
3414 final SetListener<Statement> procedure) {
\r
3416 session.syncRequest(new ReadRequest() {
\r
3419 public void run(ReadGraph graph) throws DatabaseException {
\r
3420 graph.forStatementSet(subject, relation, procedure);
\r
3423 } catch (DatabaseException e) {
\r
3429 public void forPredicateSet(final Resource subject,
\r
3430 final AsyncSetListener<Resource> procedure) {
\r
3432 session.syncRequest(new ReadRequest() {
\r
3435 public void run(ReadGraph graph) throws DatabaseException {
\r
3436 graph.forPredicateSet(subject, procedure);
\r
3439 } catch (DatabaseException e) {
\r
3445 public void forPredicateSet(final Resource subject,
\r
3446 final SyncSetListener<Resource> procedure) {
\r
3448 session.syncRequest(new ReadRequest() {
\r
3451 public void run(ReadGraph graph) throws DatabaseException {
\r
3452 graph.forPredicateSet(subject, procedure);
\r
3455 } catch (DatabaseException e) {
\r
3461 public void forPredicateSet(final Resource subject,
\r
3462 final SetListener<Resource> procedure) {
\r
3464 session.syncRequest(new ReadRequest() {
\r
3467 public void run(ReadGraph graph) throws DatabaseException {
\r
3468 graph.forPredicateSet(subject, procedure);
\r
3471 } catch (DatabaseException e) {
\r
3477 public void forPrincipalTypeSet(final Resource subject,
\r
3478 final AsyncSetListener<Resource> procedure) {
\r
3480 session.syncRequest(new ReadRequest() {
\r
3483 public void run(ReadGraph graph) throws DatabaseException {
\r
3484 graph.forPrincipalTypeSet(subject, procedure);
\r
3487 } catch (DatabaseException e) {
\r
3493 public void forPrincipalTypeSet(final Resource subject,
\r
3494 final SyncSetListener<Resource> procedure) {
\r
3496 session.syncRequest(new ReadRequest() {
\r
3499 public void run(ReadGraph graph) throws DatabaseException {
\r
3500 graph.forPrincipalTypeSet(subject, procedure);
\r
3503 } catch (DatabaseException e) {
\r
3509 public void forPrincipalTypeSet(final Resource subject,
\r
3510 final SetListener<Resource> procedure) {
\r
3512 session.syncRequest(new ReadRequest() {
\r
3515 public void run(ReadGraph graph) throws DatabaseException {
\r
3516 graph.forPrincipalTypeSet(subject, procedure);
\r
3519 } catch (DatabaseException e) {
\r
3525 public void forTypes(final Resource subject,
\r
3526 final AsyncListener<Set<Resource>> procedure) {
\r
3528 session.syncRequest(new ReadRequest() {
\r
3531 public void run(ReadGraph graph) throws DatabaseException {
\r
3532 graph.forTypes(subject, procedure);
\r
3535 } catch (DatabaseException e) {
\r
3541 public void forTypes(final Resource subject,
\r
3542 final SyncListener<Set<Resource>> procedure) {
\r
3544 session.syncRequest(new ReadRequest() {
\r
3547 public void run(ReadGraph graph) throws DatabaseException {
\r
3548 graph.forTypes(subject, procedure);
\r
3551 } catch (DatabaseException e) {
\r
3557 public void forTypes(final Resource subject, final Listener<Set<Resource>> procedure) {
\r
3559 session.syncRequest(new ReadRequest() {
\r
3562 public void run(ReadGraph graph) throws DatabaseException {
\r
3563 graph.forTypes(subject, procedure);
\r
3566 } catch (DatabaseException e) {
\r
3572 public void forTypes(final Resource subject,
\r
3573 final AsyncProcedure<Set<Resource>> procedure) {
\r
3575 session.syncRequest(new ReadRequest() {
\r
3578 public void run(ReadGraph graph) throws DatabaseException {
\r
3579 graph.forTypes(subject, procedure);
\r
3582 } catch (DatabaseException e) {
\r
3588 public void forTypes(final Resource subject,
\r
3589 final SyncProcedure<Set<Resource>> procedure) {
\r
3591 session.syncRequest(new ReadRequest() {
\r
3594 public void run(ReadGraph graph) throws DatabaseException {
\r
3595 graph.forTypes(subject, procedure);
\r
3598 } catch (DatabaseException e) {
\r
3604 public void forTypes(final Resource subject,
\r
3605 final Procedure<Set<Resource>> procedure) {
\r
3607 session.syncRequest(new ReadRequest() {
\r
3610 public void run(ReadGraph graph) throws DatabaseException {
\r
3611 graph.forTypes(subject, procedure);
\r
3614 } catch (DatabaseException e) {
\r
3620 public void forSupertypes(final Resource subject,
\r
3621 final AsyncListener<Set<Resource>> procedure) {
\r
3623 session.syncRequest(new ReadRequest() {
\r
3626 public void run(ReadGraph graph) throws DatabaseException {
\r
3627 graph.forSupertypes(subject, procedure);
\r
3630 } catch (DatabaseException e) {
\r
3636 public void forSupertypes(final Resource subject,
\r
3637 final SyncListener<Set<Resource>> procedure) {
\r
3639 session.syncRequest(new ReadRequest() {
\r
3642 public void run(ReadGraph graph) throws DatabaseException {
\r
3643 graph.forSupertypes(subject, procedure);
\r
3646 } catch (DatabaseException e) {
\r
3652 public void forSupertypes(final Resource subject,
\r
3653 final Listener<Set<Resource>> procedure) {
\r
3655 session.syncRequest(new ReadRequest() {
\r
3658 public void run(ReadGraph graph) throws DatabaseException {
\r
3659 graph.forSupertypes(subject, procedure);
\r
3662 } catch (DatabaseException e) {
\r
3668 public void forSupertypes(final Resource subject,
\r
3669 final AsyncProcedure<Set<Resource>> procedure) {
\r
3671 session.syncRequest(new ReadRequest() {
\r
3674 public void run(ReadGraph graph) throws DatabaseException {
\r
3675 graph.forSupertypes(subject, procedure);
\r
3678 } catch (DatabaseException e) {
\r
3684 public void forSupertypes(final Resource subject,
\r
3685 final SyncProcedure<Set<Resource>> procedure) {
\r
3687 session.syncRequest(new ReadRequest() {
\r
3690 public void run(ReadGraph graph) throws DatabaseException {
\r
3691 graph.forSupertypes(subject, procedure);
\r
3694 } catch (DatabaseException e) {
\r
3700 public void forSupertypes(final Resource subject,
\r
3701 final Procedure<Set<Resource>> procedure) {
\r
3703 session.syncRequest(new ReadRequest() {
\r
3706 public void run(ReadGraph graph) throws DatabaseException {
\r
3707 graph.forSupertypes(subject, procedure);
\r
3710 } catch (DatabaseException e) {
\r
3716 public void forPossibleSuperrelation(final Resource subject,
\r
3717 final AsyncProcedure<Resource> procedure) {
\r
3719 session.syncRequest(new ReadRequest() {
\r
3722 public void run(ReadGraph graph) throws DatabaseException {
\r
3723 graph.forPossibleSuperrelation(subject, procedure);
\r
3726 } catch (DatabaseException e) {
\r
3732 public void forSuperrelations(final Resource subject,
\r
3733 final AsyncListener<Set<Resource>> procedure) {
\r
3735 session.syncRequest(new ReadRequest() {
\r
3738 public void run(ReadGraph graph) throws DatabaseException {
\r
3739 graph.forSuperrelations(subject, procedure);
\r
3742 } catch (DatabaseException e) {
\r
3748 public void forSuperrelations(final Resource subject,
\r
3749 final SyncListener<Set<Resource>> procedure) {
\r
3751 session.syncRequest(new ReadRequest() {
\r
3754 public void run(ReadGraph graph) throws DatabaseException {
\r
3755 graph.forSuperrelations(subject, procedure);
\r
3758 } catch (DatabaseException e) {
\r
3764 public void forSuperrelations(final Resource subject,
\r
3765 final Listener<Set<Resource>> procedure) {
\r
3767 session.syncRequest(new ReadRequest() {
\r
3770 public void run(ReadGraph graph) throws DatabaseException {
\r
3771 graph.forSuperrelations(subject, procedure);
\r
3774 } catch (DatabaseException e) {
\r
3780 public void forSuperrelations(final Resource subject,
\r
3781 final AsyncProcedure<Set<Resource>> procedure) {
\r
3783 session.syncRequest(new ReadRequest() {
\r
3786 public void run(ReadGraph graph) throws DatabaseException {
\r
3787 graph.forSuperrelations(subject, procedure);
\r
3790 } catch (DatabaseException e) {
\r
3796 public void forSuperrelations(final Resource subject,
\r
3797 final SyncProcedure<Set<Resource>> procedure) {
\r
3799 session.syncRequest(new ReadRequest() {
\r
3802 public void run(ReadGraph graph) throws DatabaseException {
\r
3803 graph.forSuperrelations(subject, procedure);
\r
3806 } catch (DatabaseException e) {
\r
3812 public void forSuperrelations(final Resource subject,
\r
3813 final Procedure<Set<Resource>> procedure) {
\r
3815 session.syncRequest(new ReadRequest() {
\r
3818 public void run(ReadGraph graph) throws DatabaseException {
\r
3819 graph.forSuperrelations(subject, procedure);
\r
3822 } catch (DatabaseException e) {
\r
3828 public void forObjectSet(final Resource subject, final Resource relation,
\r
3829 final AsyncSetListener<Resource> procedure) {
\r
3831 session.syncRequest(new ReadRequest() {
\r
3834 public void run(ReadGraph graph) throws DatabaseException {
\r
3835 graph.forObjectSet(subject, relation, procedure);
\r
3838 } catch (DatabaseException e) {
\r
3844 public void forObjectSet(final Resource subject, final Resource relation,
\r
3845 final SyncSetListener<Resource> procedure) {
\r
3847 session.syncRequest(new ReadRequest() {
\r
3850 public void run(ReadGraph graph) throws DatabaseException {
\r
3851 graph.forObjectSet(subject, relation, procedure);
\r
3854 } catch (DatabaseException e) {
\r
3860 public void forObjectSet(final Resource subject, final Resource relation,
\r
3861 final SetListener<Resource> procedure) {
\r
3863 session.syncRequest(new ReadRequest() {
\r
3866 public void run(ReadGraph graph) throws DatabaseException {
\r
3867 graph.forObjectSet(subject, relation, procedure);
\r
3870 } catch (DatabaseException e) {
\r
3876 public void forInverse(final Resource relation,
\r
3877 final SyncListener<Resource> procedure) {
\r
3879 session.syncRequest(new ReadRequest() {
\r
3882 public void run(ReadGraph graph) throws DatabaseException {
\r
3883 graph.forInverse(relation, procedure);
\r
3886 } catch (DatabaseException e) {
\r
3892 public void forInverse(final Resource relation, final Listener<Resource> procedure) {
\r
3894 session.syncRequest(new ReadRequest() {
\r
3897 public void run(ReadGraph graph) throws DatabaseException {
\r
3898 graph.forInverse(relation, procedure);
\r
3901 } catch (DatabaseException e) {
\r
3907 public void forInverse(final Resource relation,
\r
3908 final AsyncProcedure<Resource> procedure) {
\r
3910 session.syncRequest(new ReadRequest() {
\r
3913 public void run(ReadGraph graph) throws DatabaseException {
\r
3914 graph.forInverse(relation, procedure);
\r
3917 } catch (DatabaseException e) {
\r
3923 public void forInverse(final Resource relation,
\r
3924 final SyncProcedure<Resource> procedure) {
\r
3926 session.syncRequest(new ReadRequest() {
\r
3929 public void run(ReadGraph graph) throws DatabaseException {
\r
3930 graph.forInverse(relation, procedure);
\r
3933 } catch (DatabaseException e) {
\r
3939 public void forInverse(final Resource relation, final Procedure<Resource> procedure) {
\r
3941 session.syncRequest(new ReadRequest() {
\r
3944 public void run(ReadGraph graph) throws DatabaseException {
\r
3945 graph.forInverse(relation, procedure);
\r
3948 } catch (DatabaseException e) {
\r
3954 public void forSingleObject(final Resource subject, final Resource relation,
\r
3955 final AsyncListener<Resource> procedure) {
\r
3957 session.syncRequest(new ReadRequest() {
\r
3960 public void run(ReadGraph graph) throws DatabaseException {
\r
3961 graph.forSingleObject(subject, relation, procedure);
\r
3964 } catch (DatabaseException e) {
\r
3970 public void forSingleObject(final Resource subject, final Resource relation,
\r
3971 final SyncListener<Resource> procedure) {
\r
3973 session.syncRequest(new ReadRequest() {
\r
3976 public void run(ReadGraph graph) throws DatabaseException {
\r
3977 graph.forSingleObject(subject, relation, procedure);
\r
3980 } catch (DatabaseException e) {
\r
3986 public void forSingleObject(final Resource subject, final Resource relation,
\r
3987 final Listener<Resource> procedure) {
\r
3989 session.syncRequest(new ReadRequest() {
\r
3992 public void run(ReadGraph graph) throws DatabaseException {
\r
3993 graph.forSingleObject(subject, relation, procedure);
\r
3996 } catch (DatabaseException e) {
\r
4002 public void forSingleObject(final Resource subject, final Resource relation,
\r
4003 final AsyncProcedure<Resource> procedure) {
\r
4005 session.syncRequest(new ReadRequest() {
\r
4008 public void run(ReadGraph graph) throws DatabaseException {
\r
4009 graph.forSingleObject(subject, relation, procedure);
\r
4012 } catch (DatabaseException e) {
\r
4018 public void forSingleObject(final Resource subject, final Resource relation,
\r
4019 final SyncProcedure<Resource> procedure) {
\r
4021 session.syncRequest(new ReadRequest() {
\r
4024 public void run(ReadGraph graph) throws DatabaseException {
\r
4025 graph.forSingleObject(subject, relation, procedure);
\r
4028 } catch (DatabaseException e) {
\r
4034 public void forSingleObject(final Resource subject, final Resource relation,
\r
4035 final Procedure<Resource> procedure) {
\r
4037 session.syncRequest(new ReadRequest() {
\r
4040 public void run(ReadGraph graph) throws DatabaseException {
\r
4041 graph.forSingleObject(subject, relation, procedure);
\r
4044 } catch (DatabaseException e) {
\r
4050 public void forSingleStatement(final Resource subject, final Resource relation,
\r
4051 final AsyncListener<Statement> procedure) {
\r
4053 session.syncRequest(new ReadRequest() {
\r
4056 public void run(ReadGraph graph) throws DatabaseException {
\r
4057 graph.forSingleStatement(subject, relation, procedure);
\r
4060 } catch (DatabaseException e) {
\r
4066 public void forSingleStatement(final Resource subject, final Resource relation,
\r
4067 final SyncListener<Statement> procedure) {
\r
4069 session.syncRequest(new ReadRequest() {
\r
4072 public void run(ReadGraph graph) throws DatabaseException {
\r
4073 graph.forSingleStatement(subject, relation, procedure);
\r
4076 } catch (DatabaseException e) {
\r
4082 public void forSingleStatement(final Resource subject, final Resource relation,
\r
4083 final Listener<Statement> procedure) {
\r
4085 session.syncRequest(new ReadRequest() {
\r
4088 public void run(ReadGraph graph) throws DatabaseException {
\r
4089 graph.forSingleStatement(subject, relation, procedure);
\r
4092 } catch (DatabaseException e) {
\r
4099 public void forSingleStatement(final Resource subject, final Resource relation,
\r
4100 final AsyncProcedure<Statement> procedure) {
\r
4102 session.syncRequest(new ReadRequest() {
\r
4105 public void run(ReadGraph graph) throws DatabaseException {
\r
4106 graph.forSingleStatement(subject, relation, procedure);
\r
4109 } catch (DatabaseException e) {
\r
4115 public void forSingleStatement(final Resource subject, final Resource relation,
\r
4116 final SyncProcedure<Statement> procedure) {
\r
4118 session.syncRequest(new ReadRequest() {
\r
4121 public void run(ReadGraph graph) throws DatabaseException {
\r
4122 graph.forSingleStatement(subject, relation, procedure);
\r
4125 } catch (DatabaseException e) {
\r
4131 public void forSingleStatement(final Resource subject, final Resource relation,
\r
4132 final Procedure<Statement> procedure) {
\r
4134 session.syncRequest(new ReadRequest() {
\r
4137 public void run(ReadGraph graph) throws DatabaseException {
\r
4138 graph.forSingleStatement(subject, relation, procedure);
\r
4141 } catch (DatabaseException e) {
\r
4147 public void forSingleType(final Resource subject,
\r
4148 final AsyncListener<Resource> procedure) {
\r
4150 session.syncRequest(new ReadRequest() {
\r
4153 public void run(ReadGraph graph) throws DatabaseException {
\r
4154 graph.forSingleType(subject, procedure);
\r
4157 } catch (DatabaseException e) {
\r
4163 public void forSingleType(final Resource subject,
\r
4164 final SyncListener<Resource> procedure) {
\r
4166 session.syncRequest(new ReadRequest() {
\r
4169 public void run(ReadGraph graph) throws DatabaseException {
\r
4170 graph.forSingleType(subject, procedure);
\r
4173 } catch (DatabaseException e) {
\r
4179 public void forSingleType(final Resource subject, final Listener<Resource> procedure) {
\r
4181 session.syncRequest(new ReadRequest() {
\r
4184 public void run(ReadGraph graph) throws DatabaseException {
\r
4185 graph.forSingleType(subject, procedure);
\r
4188 } catch (DatabaseException e) {
\r
4194 public void forSingleType(final Resource subject,
\r
4195 final AsyncProcedure<Resource> procedure) {
\r
4197 session.syncRequest(new ReadRequest() {
\r
4200 public void run(ReadGraph graph) throws DatabaseException {
\r
4201 graph.forSingleType(subject, procedure);
\r
4204 } catch (DatabaseException e) {
\r
4210 public void forSingleType(final Resource subject,
\r
4211 final SyncProcedure<Resource> procedure) {
\r
4213 session.syncRequest(new ReadRequest() {
\r
4216 public void run(ReadGraph graph) throws DatabaseException {
\r
4217 graph.forSingleType(subject, procedure);
\r
4220 } catch (DatabaseException e) {
\r
4226 public void forSingleType(final Resource subject,
\r
4227 final Procedure<Resource> procedure) {
\r
4229 session.syncRequest(new ReadRequest() {
\r
4232 public void run(ReadGraph graph) throws DatabaseException {
\r
4233 graph.forSingleType(subject, procedure);
\r
4236 } catch (DatabaseException e) {
\r
4242 public void forSingleType(final Resource subject, final Resource baseType,
\r
4243 final AsyncListener<Resource> procedure) {
\r
4245 session.syncRequest(new ReadRequest() {
\r
4248 public void run(ReadGraph graph) throws DatabaseException {
\r
4249 graph.forSingleType(subject, baseType, procedure);
\r
4252 } catch (DatabaseException e) {
\r
4258 public void forSingleType(final Resource subject, final Resource baseType,
\r
4259 final SyncListener<Resource> procedure) {
\r
4261 session.syncRequest(new ReadRequest() {
\r
4264 public void run(ReadGraph graph) throws DatabaseException {
\r
4265 graph.forSingleType(subject, baseType, procedure);
\r
4268 } catch (DatabaseException e) {
\r
4274 public void forSingleType(final Resource subject, final Resource baseType,
\r
4275 final Listener<Resource> procedure) {
\r
4277 session.syncRequest(new ReadRequest() {
\r
4280 public void run(ReadGraph graph) throws DatabaseException {
\r
4281 graph.forSingleType(subject, baseType, procedure);
\r
4284 } catch (DatabaseException e) {
\r
4290 public void forSingleType(final Resource subject, final Resource baseType,
\r
4291 final AsyncProcedure<Resource> procedure) {
\r
4293 session.syncRequest(new ReadRequest() {
\r
4296 public void run(ReadGraph graph) throws DatabaseException {
\r
4297 graph.forSingleType(subject, baseType, procedure);
\r
4300 } catch (DatabaseException e) {
\r
4306 public void forSingleType(final Resource subject, final Resource baseType,
\r
4307 final SyncProcedure<Resource> procedure) {
\r
4309 session.syncRequest(new ReadRequest() {
\r
4312 public void run(ReadGraph graph) throws DatabaseException {
\r
4313 graph.forSingleType(subject, baseType, procedure);
\r
4316 } catch (DatabaseException e) {
\r
4322 public void forSingleType(final Resource subject, final Resource baseType,
\r
4323 final Procedure<Resource> procedure) {
\r
4325 session.syncRequest(new ReadRequest() {
\r
4328 public void run(ReadGraph graph) throws DatabaseException {
\r
4329 graph.forSingleType(subject, baseType, procedure);
\r
4332 } catch (DatabaseException e) {
\r
4338 public <T> void forValue(final Resource subject, final AsyncListener<T> procedure) {
\r
4340 session.syncRequest(new ReadRequest() {
\r
4343 public void run(ReadGraph graph) throws DatabaseException {
\r
4344 graph.forValue(subject, procedure);
\r
4347 } catch (DatabaseException e) {
\r
4353 public <T> void forValue(final Resource subject, final SyncListener<T> procedure) {
\r
4355 session.syncRequest(new ReadRequest() {
\r
4358 public void run(ReadGraph graph) throws DatabaseException {
\r
4359 graph.forValue(subject, procedure);
\r
4362 } catch (DatabaseException e) {
\r
4368 public <T> void forValue(final Resource subject, final Listener<T> procedure) {
\r
4370 session.syncRequest(new ReadRequest() {
\r
4373 public void run(ReadGraph graph) throws DatabaseException {
\r
4374 graph.forValue(subject, procedure);
\r
4377 } catch (DatabaseException e) {
\r
4383 public <T> void forValue(final Resource subject, final AsyncProcedure<T> procedure) {
\r
4385 session.syncRequest(new ReadRequest() {
\r
4388 public void run(ReadGraph graph) throws DatabaseException {
\r
4389 graph.forValue(subject, procedure);
\r
4392 } catch (DatabaseException e) {
\r
4398 public <T> void forValue(final Resource subject, final SyncProcedure<T> procedure) {
\r
4400 session.syncRequest(new ReadRequest() {
\r
4403 public void run(ReadGraph graph) throws DatabaseException {
\r
4404 graph.forValue(subject, procedure);
\r
4407 } catch (DatabaseException e) {
\r
4413 public <T> void forValue(final Resource subject, final Procedure<T> procedure) {
\r
4415 session.syncRequest(new ReadRequest() {
\r
4418 public void run(ReadGraph graph) throws DatabaseException {
\r
4419 graph.forValue(subject, procedure);
\r
4422 } catch (DatabaseException e) {
\r
4428 public <T> void forValue(final Resource subject, final Binding binding,
\r
4429 final AsyncListener<T> procedure) {
\r
4431 session.syncRequest(new ReadRequest() {
\r
4434 public void run(ReadGraph graph) throws DatabaseException {
\r
4435 graph.forValue(subject, binding, procedure);
\r
4438 } catch (DatabaseException e) {
\r
4444 public <T> void forValue(final Resource subject, final Binding binding,
\r
4445 final SyncListener<T> procedure) {
\r
4447 session.syncRequest(new ReadRequest() {
\r
4450 public void run(ReadGraph graph) throws DatabaseException {
\r
4451 graph.forValue(subject, binding, procedure);
\r
4454 } catch (DatabaseException e) {
\r
4460 public <T> void forValue(final Resource subject, final Binding binding,
\r
4461 final Listener<T> procedure) {
\r
4463 session.syncRequest(new ReadRequest() {
\r
4466 public void run(ReadGraph graph) throws DatabaseException {
\r
4467 graph.forValue(subject, binding, procedure);
\r
4470 } catch (DatabaseException e) {
\r
4476 public <T> void forValue(final Resource subject, final Binding binding,
\r
4477 final AsyncProcedure<T> procedure) {
\r
4479 session.syncRequest(new ReadRequest() {
\r
4482 public void run(ReadGraph graph) throws DatabaseException {
\r
4483 graph.forValue(subject, binding, procedure);
\r
4486 } catch (DatabaseException e) {
\r
4492 public <T> void forValue(final Resource subject, final Binding binding,
\r
4493 final SyncProcedure<T> procedure) {
\r
4495 session.syncRequest(new ReadRequest() {
\r
4498 public void run(ReadGraph graph) throws DatabaseException {
\r
4499 graph.forValue(subject, binding, procedure);
\r
4502 } catch (DatabaseException e) {
\r
4508 public <T> void forValue(final Resource subject, final Binding binding,
\r
4509 final Procedure<T> procedure) {
\r
4511 session.syncRequest(new ReadRequest() {
\r
4514 public void run(ReadGraph graph) throws DatabaseException {
\r
4515 graph.forValue(subject, binding, procedure);
\r
4518 } catch (DatabaseException e) {
\r
4524 public <T> void forRelatedValue(final Resource subject, final Resource relation,
\r
4525 final AsyncListener<T> procedure) {
\r
4527 session.syncRequest(new ReadRequest() {
\r
4530 public void run(ReadGraph graph) throws DatabaseException {
\r
4531 graph.forRelatedValue(subject, relation, procedure);
\r
4534 } catch (DatabaseException e) {
\r
4540 public <T> void forRelatedValue(final Resource subject, final Resource relation,
\r
4541 final SyncListener<T> procedure) {
\r
4543 session.syncRequest(new ReadRequest() {
\r
4546 public void run(ReadGraph graph) throws DatabaseException {
\r
4547 graph.forRelatedValue(subject, relation, procedure);
\r
4550 } catch (DatabaseException e) {
\r
4556 public <T> void forRelatedValue(final Resource subject, final Resource relation,
\r
4557 final Listener<T> procedure) {
\r
4559 session.syncRequest(new ReadRequest() {
\r
4562 public void run(ReadGraph graph) throws DatabaseException {
\r
4563 graph.forRelatedValue(subject, relation, procedure);
\r
4566 } catch (DatabaseException e) {
\r
4572 public <T> void forRelatedValue(final Resource subject, final Resource relation,
\r
4573 final AsyncProcedure<T> procedure) {
\r
4575 session.syncRequest(new ReadRequest() {
\r
4578 public void run(ReadGraph graph) throws DatabaseException {
\r
4579 graph.forRelatedValue(subject, relation, procedure);
\r
4582 } catch (DatabaseException e) {
\r
4588 public <T> void forRelatedValue(final Resource subject, final Resource relation,
\r
4589 final SyncProcedure<T> procedure) {
\r
4591 session.syncRequest(new ReadRequest() {
\r
4594 public void run(ReadGraph graph) throws DatabaseException {
\r
4595 graph.forRelatedValue(subject, relation, procedure);
\r
4598 } catch (DatabaseException e) {
\r
4604 public <T> void forRelatedValue(final Resource subject, final Resource relation,
\r
4605 final Procedure<T> procedure) {
\r
4607 session.syncRequest(new ReadRequest() {
\r
4610 public void run(ReadGraph graph) throws DatabaseException {
\r
4611 graph.forRelatedValue(subject, relation, procedure);
\r
4614 } catch (DatabaseException e) {
\r
4620 public <T> void forRelatedValue(final Resource subject, final Resource relation,
\r
4621 final Binding binding, final AsyncListener<T> procedure) {
\r
4623 session.syncRequest(new ReadRequest() {
\r
4626 public void run(ReadGraph graph) throws DatabaseException {
\r
4627 graph.forRelatedValue(subject, relation, binding, procedure);
\r
4630 } catch (DatabaseException e) {
\r
4636 public <T> void forRelatedValue(final Resource subject, final Resource relation,
\r
4637 final Binding binding, final SyncListener<T> procedure) {
\r
4639 session.syncRequest(new ReadRequest() {
\r
4642 public void run(ReadGraph graph) throws DatabaseException {
\r
4643 graph.forRelatedValue(subject, relation, binding, procedure);
\r
4646 } catch (DatabaseException e) {
\r
4652 public <T> void forRelatedValue(final Resource subject, final Resource relation,
\r
4653 final Binding binding, final Listener<T> procedure) {
\r
4655 session.syncRequest(new ReadRequest() {
\r
4658 public void run(ReadGraph graph) throws DatabaseException {
\r
4659 graph.forRelatedValue(subject, relation, binding, procedure);
\r
4662 } catch (DatabaseException e) {
\r
4668 public <T> void forRelatedValue(final Resource subject, final Resource relation,
\r
4669 final Binding binding, final AsyncProcedure<T> procedure) {
\r
4671 session.syncRequest(new ReadRequest() {
\r
4674 public void run(ReadGraph graph) throws DatabaseException {
\r
4675 graph.forRelatedValue(subject, relation, binding, procedure);
\r
4678 } catch (DatabaseException e) {
\r
4684 public <T> void forRelatedValue(final Resource subject, final Resource relation,
\r
4685 final Binding binding, final SyncProcedure<T> procedure) {
\r
4687 session.syncRequest(new ReadRequest() {
\r
4690 public void run(ReadGraph graph) throws DatabaseException {
\r
4691 graph.forRelatedValue(subject, relation, binding, procedure);
\r
4694 } catch (DatabaseException e) {
\r
4700 public <T> void forRelatedValue(final Resource subject, final Resource relation,
\r
4701 final Binding binding, final Procedure<T> procedure) {
\r
4703 session.syncRequest(new ReadRequest() {
\r
4706 public void run(ReadGraph graph) throws DatabaseException {
\r
4707 graph.forRelatedValue(subject, relation, binding, procedure);
\r
4710 } catch (DatabaseException e) {
\r
4716 public <T> void forUniqueAdapted(final Resource resource, final Class<T> clazz,
\r
4717 final AsyncListener<T> procedure) {
\r
4719 session.syncRequest(new ReadRequest() {
\r
4722 public void run(ReadGraph graph) throws DatabaseException {
\r
4723 graph.forUniqueAdapted(resource, clazz, procedure);
\r
4726 } catch (DatabaseException e) {
\r
4732 public <T> void forUniqueAdapted(final Resource resource, final Class<T> clazz,
\r
4733 final SyncListener<T> procedure) {
\r
4735 session.syncRequest(new ReadRequest() {
\r
4738 public void run(ReadGraph graph) throws DatabaseException {
\r
4739 graph.forUniqueAdapted(resource, clazz, procedure);
\r
4742 } catch (DatabaseException e) {
\r
4748 public <T> void forUniqueAdapted(final Resource resource, final Class<T> clazz,
\r
4749 final Listener<T> procedure) {
\r
4751 session.syncRequest(new ReadRequest() {
\r
4754 public void run(ReadGraph graph) throws DatabaseException {
\r
4755 graph.forUniqueAdapted(resource, clazz, procedure);
\r
4758 } catch (DatabaseException e) {
\r
4764 public <T> void forUniqueAdapted(final Resource resource, final Class<T> clazz,
\r
4765 final AsyncProcedure<T> procedure) {
\r
4767 session.syncRequest(new ReadRequest() {
\r
4770 public void run(ReadGraph graph) throws DatabaseException {
\r
4771 graph.forUniqueAdapted(resource, clazz, procedure);
\r
4774 } catch (DatabaseException e) {
\r
4780 public <T> void forUniqueAdapted(final Resource resource, final Class<T> clazz,
\r
4781 final SyncProcedure<T> procedure) {
\r
4783 session.syncRequest(new ReadRequest() {
\r
4786 public void run(ReadGraph graph) throws DatabaseException {
\r
4787 graph.forUniqueAdapted(resource, clazz, procedure);
\r
4790 } catch (DatabaseException e) {
\r
4796 public <T> void forUniqueAdapted(final Resource resource, final Class<T> clazz,
\r
4797 final Procedure<T> procedure) {
\r
4799 session.syncRequest(new ReadRequest() {
\r
4802 public void run(ReadGraph graph) throws DatabaseException {
\r
4803 graph.forUniqueAdapted(resource, clazz, procedure);
\r
4806 } catch (DatabaseException e) {
\r
4812 public void forPossibleInverse(final Resource relation,
\r
4813 final AsyncListener<Resource> procedure) {
\r
4815 session.syncRequest(new ReadRequest() {
\r
4818 public void run(ReadGraph graph) throws DatabaseException {
\r
4819 graph.forPossibleInverse(relation, procedure);
\r
4822 } catch (DatabaseException e) {
\r
4828 public void forPossibleInverse(final Resource relation,
\r
4829 final SyncListener<Resource> procedure) {
\r
4831 session.syncRequest(new ReadRequest() {
\r
4834 public void run(ReadGraph graph) throws DatabaseException {
\r
4835 graph.forPossibleInverse(relation, procedure);
\r
4838 } catch (DatabaseException e) {
\r
4844 public void forPossibleInverse(final Resource relation,
\r
4845 final Listener<Resource> procedure) {
\r
4847 session.syncRequest(new ReadRequest() {
\r
4850 public void run(ReadGraph graph) throws DatabaseException {
\r
4851 graph.forPossibleInverse(relation, procedure);
\r
4854 } catch (DatabaseException e) {
\r
4860 public void forPossibleInverse(final Resource relation,
\r
4861 final AsyncProcedure<Resource> procedure) {
\r
4863 session.syncRequest(new ReadRequest() {
\r
4866 public void run(ReadGraph graph) throws DatabaseException {
\r
4867 graph.forPossibleInverse(relation, procedure);
\r
4870 } catch (DatabaseException e) {
\r
4876 public void forPossibleInverse(final Resource relation,
\r
4877 final SyncProcedure<Resource> procedure) {
\r
4879 session.syncRequest(new ReadRequest() {
\r
4882 public void run(ReadGraph graph) throws DatabaseException {
\r
4883 graph.forPossibleInverse(relation, procedure);
\r
4886 } catch (DatabaseException e) {
\r
4892 public void forPossibleInverse(final Resource relation,
\r
4893 final Procedure<Resource> procedure) {
\r
4895 session.syncRequest(new ReadRequest() {
\r
4898 public void run(ReadGraph graph) throws DatabaseException {
\r
4899 graph.forPossibleInverse(relation, procedure);
\r
4902 } catch (DatabaseException e) {
\r
4908 public void forPossibleObject(final Resource subject, final Resource relation,
\r
4909 final AsyncListener<Resource> procedure) {
\r
4911 session.syncRequest(new ReadRequest() {
\r
4914 public void run(ReadGraph graph) throws DatabaseException {
\r
4915 graph.forPossibleObject(subject, relation, procedure);
\r
4918 } catch (DatabaseException e) {
\r
4924 public void forPossibleObject(final Resource subject, final Resource relation,
\r
4925 final SyncListener<Resource> procedure) {
\r
4927 session.syncRequest(new ReadRequest() {
\r
4930 public void run(ReadGraph graph) throws DatabaseException {
\r
4931 graph.forPossibleObject(subject, relation, procedure);
\r
4934 } catch (DatabaseException e) {
\r
4940 public void forPossibleObject(final Resource subject, final Resource relation,
\r
4941 final Listener<Resource> procedure) {
\r
4943 session.syncRequest(new ReadRequest() {
\r
4946 public void run(ReadGraph graph) throws DatabaseException {
\r
4947 graph.forPossibleObject(subject, relation, procedure);
\r
4950 } catch (DatabaseException e) {
\r
4956 public void forPossibleObject(final Resource subject, final Resource relation,
\r
4957 final AsyncProcedure<Resource> procedure) {
\r
4959 session.syncRequest(new ReadRequest() {
\r
4962 public void run(ReadGraph graph) throws DatabaseException {
\r
4963 graph.forPossibleObject(subject, relation, procedure);
\r
4966 } catch (DatabaseException e) {
\r
4972 public void forPossibleObject(final Resource subject, final Resource relation,
\r
4973 final SyncProcedure<Resource> procedure) {
\r
4975 session.syncRequest(new ReadRequest() {
\r
4978 public void run(ReadGraph graph) throws DatabaseException {
\r
4979 graph.forPossibleObject(subject, relation, procedure);
\r
4982 } catch (DatabaseException e) {
\r
4988 public void forPossibleObject(final Resource subject, final Resource relation,
\r
4989 final Procedure<Resource> procedure) {
\r
4991 session.syncRequest(new ReadRequest() {
\r
4994 public void run(ReadGraph graph) throws DatabaseException {
\r
4995 graph.forPossibleObject(subject, relation, procedure);
\r
4998 } catch (DatabaseException e) {
\r
5004 public void forPossibleStatement(final Resource subject, final Resource relation,
\r
5005 final AsyncListener<Statement> procedure) {
\r
5007 session.syncRequest(new ReadRequest() {
\r
5010 public void run(ReadGraph graph) throws DatabaseException {
\r
5011 graph.forPossibleStatement(subject, relation, procedure);
\r
5014 } catch (DatabaseException e) {
\r
5020 public void forPossibleStatement(final Resource subject, final Resource relation,
\r
5021 final SyncListener<Statement> procedure) {
\r
5023 session.syncRequest(new ReadRequest() {
\r
5026 public void run(ReadGraph graph) throws DatabaseException {
\r
5027 graph.forPossibleStatement(subject, relation, procedure);
\r
5030 } catch (DatabaseException e) {
\r
5036 public void forPossibleStatement(final Resource subject, final Resource relation,
\r
5037 final Listener<Statement> procedure) {
\r
5039 session.syncRequest(new ReadRequest() {
\r
5042 public void run(ReadGraph graph) throws DatabaseException {
\r
5043 graph.forPossibleStatement(subject, relation, procedure);
\r
5046 } catch (DatabaseException e) {
\r
5052 public void forPossibleStatement(final Resource subject, final Resource relation,
\r
5053 final AsyncProcedure<Statement> procedure) {
\r
5055 session.syncRequest(new ReadRequest() {
\r
5058 public void run(ReadGraph graph) throws DatabaseException {
\r
5059 graph.forPossibleStatement(subject, relation, procedure);
\r
5062 } catch (DatabaseException e) {
\r
5068 public void forPossibleStatement(final Resource subject, final Resource relation,
\r
5069 final SyncProcedure<Statement> procedure) {
\r
5071 session.syncRequest(new ReadRequest() {
\r
5074 public void run(ReadGraph graph) throws DatabaseException {
\r
5075 graph.forPossibleStatement(subject, relation, procedure);
\r
5078 } catch (DatabaseException e) {
\r
5084 public void forPossibleStatement(final Resource subject, final Resource relation,
\r
5085 final Procedure<Statement> procedure) {
\r
5087 session.syncRequest(new ReadRequest() {
\r
5090 public void run(ReadGraph graph) throws DatabaseException {
\r
5091 graph.forPossibleStatement(subject, relation, procedure);
\r
5094 } catch (DatabaseException e) {
\r
5100 public void forPossibleType(final Resource subject, final Resource baseType,
\r
5101 final AsyncListener<Resource> procedure) {
\r
5103 session.syncRequest(new ReadRequest() {
\r
5106 public void run(ReadGraph graph) throws DatabaseException {
\r
5107 graph.forPossibleType(subject, baseType, procedure);
\r
5110 } catch (DatabaseException e) {
\r
5116 public void forPossibleType(final Resource subject, final Resource baseType,
\r
5117 final SyncListener<Resource> procedure) {
\r
5119 session.syncRequest(new ReadRequest() {
\r
5122 public void run(ReadGraph graph) throws DatabaseException {
\r
5123 graph.forPossibleType(subject, baseType, procedure);
\r
5126 } catch (DatabaseException e) {
\r
5132 public void forPossibleType(final Resource subject, final Resource baseType,
\r
5133 final Listener<Resource> procedure) {
\r
5135 session.syncRequest(new ReadRequest() {
\r
5138 public void run(ReadGraph graph) throws DatabaseException {
\r
5139 graph.forPossibleType(subject, baseType, procedure);
\r
5142 } catch (DatabaseException e) {
\r
5148 public void forPossibleType(final Resource subject, final Resource baseType,
\r
5149 final AsyncProcedure<Resource> procedure) {
\r
5151 session.syncRequest(new ReadRequest() {
\r
5154 public void run(ReadGraph graph) throws DatabaseException {
\r
5155 graph.forPossibleType(subject, baseType, procedure);
\r
5158 } catch (DatabaseException e) {
\r
5164 public void forPossibleType(final Resource subject, final Resource baseType,
\r
5165 final SyncProcedure<Resource> procedure) {
\r
5167 session.syncRequest(new ReadRequest() {
\r
5170 public void run(ReadGraph graph) throws DatabaseException {
\r
5171 graph.forPossibleType(subject, baseType, procedure);
\r
5174 } catch (DatabaseException e) {
\r
5180 public void forPossibleType(final Resource subject, final Resource baseType,
\r
5181 final Procedure<Resource> procedure) {
\r
5183 session.syncRequest(new ReadRequest() {
\r
5186 public void run(ReadGraph graph) throws DatabaseException {
\r
5187 graph.forPossibleType(subject, baseType, procedure);
\r
5190 } catch (DatabaseException e) {
\r
5196 public <T> void forPossibleValue(final Resource subject,
\r
5197 final AsyncListener<T> procedure) {
\r
5199 session.syncRequest(new ReadRequest() {
\r
5202 public void run(ReadGraph graph) throws DatabaseException {
\r
5203 graph.forPossibleValue(subject, procedure);
\r
5206 } catch (DatabaseException e) {
\r
5212 public <T> void forPossibleValue(final Resource subject,
\r
5213 final SyncListener<T> procedure) {
\r
5215 session.syncRequest(new ReadRequest() {
\r
5218 public void run(ReadGraph graph) throws DatabaseException {
\r
5219 graph.forPossibleValue(subject, procedure);
\r
5222 } catch (DatabaseException e) {
\r
5228 public <T> void forPossibleValue(final Resource subject, final Listener<T> procedure) {
\r
5230 session.syncRequest(new ReadRequest() {
\r
5233 public void run(ReadGraph graph) throws DatabaseException {
\r
5234 graph.forPossibleValue(subject, procedure);
\r
5237 } catch (DatabaseException e) {
\r
5243 public <T> void forPossibleValue(final Resource subject,
\r
5244 final AsyncProcedure<T> procedure) {
\r
5246 session.syncRequest(new ReadRequest() {
\r
5249 public void run(ReadGraph graph) throws DatabaseException {
\r
5250 graph.forPossibleValue(subject, procedure);
\r
5253 } catch (DatabaseException e) {
\r
5259 public <T> void forPossibleValue(final Resource subject,
\r
5260 final SyncProcedure<T> procedure) {
\r
5262 session.syncRequest(new ReadRequest() {
\r
5265 public void run(ReadGraph graph) throws DatabaseException {
\r
5266 graph.forPossibleValue(subject, procedure);
\r
5269 } catch (DatabaseException e) {
\r
5275 public <T> void forPossibleValue(final Resource subject,
\r
5276 final Procedure<T> procedure) {
\r
5278 session.syncRequest(new ReadRequest() {
\r
5281 public void run(ReadGraph graph) throws DatabaseException {
\r
5282 graph.forPossibleValue(subject, procedure);
\r
5285 } catch (DatabaseException e) {
\r
5291 public <T> void forPossibleValue(final Resource subject, final Binding binding,
\r
5292 final AsyncListener<T> procedure) {
\r
5294 session.syncRequest(new ReadRequest() {
\r
5297 public void run(ReadGraph graph) throws DatabaseException {
\r
5298 graph.forPossibleValue(subject, procedure);
\r
5301 } catch (DatabaseException e) {
\r
5307 public <T> void forPossibleValue(final Resource subject, final Binding binding,
\r
5308 final SyncListener<T> procedure) {
\r
5310 session.syncRequest(new ReadRequest() {
\r
5313 public void run(ReadGraph graph) throws DatabaseException {
\r
5314 graph.forPossibleValue(subject, procedure);
\r
5317 } catch (DatabaseException e) {
\r
5323 public <T> void forPossibleValue(final Resource subject, final Binding binding,
\r
5324 final Listener<T> procedure) {
\r
5326 session.syncRequest(new ReadRequest() {
\r
5329 public void run(ReadGraph graph) throws DatabaseException {
\r
5330 graph.forPossibleValue(subject, procedure);
\r
5333 } catch (DatabaseException e) {
\r
5339 public <T> void forPossibleValue(final Resource subject, final Binding binding,
\r
5340 final AsyncProcedure<T> procedure) {
\r
5342 session.syncRequest(new ReadRequest() {
\r
5345 public void run(ReadGraph graph) throws DatabaseException {
\r
5346 graph.forPossibleValue(subject, procedure);
\r
5349 } catch (DatabaseException e) {
\r
5355 public <T> void forPossibleValue(final Resource subject, final Binding binding,
\r
5356 final SyncProcedure<T> procedure) {
\r
5358 session.syncRequest(new ReadRequest() {
\r
5361 public void run(ReadGraph graph) throws DatabaseException {
\r
5362 graph.forPossibleValue(subject, procedure);
\r
5365 } catch (DatabaseException e) {
\r
5371 public <T> void forPossibleValue(final Resource subject, final Binding binding,
\r
5372 final Procedure<T> procedure) {
\r
5374 session.syncRequest(new ReadRequest() {
\r
5377 public void run(ReadGraph graph) throws DatabaseException {
\r
5378 graph.forPossibleValue(subject, procedure);
\r
5381 } catch (DatabaseException e) {
\r
5387 public <T> void forPossibleRelatedValue(final Resource subject,
\r
5388 final Resource relation, final AsyncListener<T> procedure) {
\r
5390 session.syncRequest(new ReadRequest() {
\r
5393 public void run(ReadGraph graph) throws DatabaseException {
\r
5394 graph.forPossibleRelatedValue(subject, relation, procedure);
\r
5397 } catch (DatabaseException e) {
\r
5403 public <T> void forPossibleRelatedValue(final Resource subject,
\r
5404 final Resource relation, final SyncListener<T> procedure) {
\r
5406 session.syncRequest(new ReadRequest() {
\r
5409 public void run(ReadGraph graph) throws DatabaseException {
\r
5410 graph.forPossibleRelatedValue(subject, relation, procedure);
\r
5413 } catch (DatabaseException e) {
\r
5419 public <T> void forPossibleRelatedValue(final Resource subject,
\r
5420 final Resource relation, final Listener<T> procedure) {
\r
5422 session.syncRequest(new ReadRequest() {
\r
5425 public void run(ReadGraph graph) throws DatabaseException {
\r
5426 graph.forPossibleRelatedValue(subject, relation, procedure);
\r
5429 } catch (DatabaseException e) {
\r
5435 public <T> void forPossibleRelatedValue(final Resource subject,
\r
5436 final Resource relation, final AsyncProcedure<T> procedure) {
\r
5438 session.syncRequest(new ReadRequest() {
\r
5441 public void run(ReadGraph graph) throws DatabaseException {
\r
5442 graph.forPossibleRelatedValue(subject, relation, procedure);
\r
5445 } catch (DatabaseException e) {
\r
5451 public <T> void forPossibleRelatedValue(final Resource subject,
\r
5452 final Resource relation, final SyncProcedure<T> procedure) {
\r
5454 session.syncRequest(new ReadRequest() {
\r
5457 public void run(ReadGraph graph) throws DatabaseException {
\r
5458 graph.forPossibleRelatedValue(subject, relation, procedure);
\r
5461 } catch (DatabaseException e) {
\r
5467 public <T> void forPossibleRelatedValue(final Resource subject,
\r
5468 final Resource relation, final Procedure<T> procedure) {
\r
5470 session.syncRequest(new ReadRequest() {
\r
5473 public void run(ReadGraph graph) throws DatabaseException {
\r
5474 graph.forPossibleRelatedValue(subject, relation, procedure);
\r
5477 } catch (DatabaseException e) {
\r
5483 public <T> void forPossibleRelatedValue(final Resource subject,
\r
5484 final Resource relation, final Binding binding, final AsyncListener<T> procedure) {
\r
5486 session.syncRequest(new ReadRequest() {
\r
5489 public void run(ReadGraph graph) throws DatabaseException {
\r
5490 graph.forPossibleRelatedValue(subject, relation, binding, procedure);
\r
5493 } catch (DatabaseException e) {
\r
5499 public <T> void forPossibleRelatedValue(final Resource subject,
\r
5500 final Resource relation, final Binding binding, final SyncListener<T> procedure) {
\r
5502 session.syncRequest(new ReadRequest() {
\r
5505 public void run(ReadGraph graph) throws DatabaseException {
\r
5506 graph.forPossibleRelatedValue(subject, relation, procedure);
\r
5509 } catch (DatabaseException e) {
\r
5515 public <T> void forPossibleRelatedValue(final Resource subject,
\r
5516 final Resource relation, final Binding binding, final Listener<T> procedure) {
\r
5518 session.syncRequest(new ReadRequest() {
\r
5521 public void run(ReadGraph graph) throws DatabaseException {
\r
5522 graph.forPossibleRelatedValue(subject, relation, binding, procedure);
\r
5525 } catch (DatabaseException e) {
\r
5531 public <T> void forPossibleRelatedValue(final Resource subject,
\r
5532 final Resource relation, final Binding binding, final AsyncProcedure<T> procedure) {
\r
5534 session.syncRequest(new ReadRequest() {
\r
5537 public void run(ReadGraph graph) throws DatabaseException {
\r
5538 graph.forPossibleRelatedValue(subject, relation, binding, procedure);
\r
5541 } catch (DatabaseException e) {
\r
5547 public <T> void forPossibleRelatedValue(final Resource subject,
\r
5548 final Resource relation, final Binding binding, final SyncProcedure<T> procedure) {
\r
5550 session.syncRequest(new ReadRequest() {
\r
5553 public void run(ReadGraph graph) throws DatabaseException {
\r
5554 graph.forPossibleRelatedValue(subject, relation, binding, procedure);
\r
5557 } catch (DatabaseException e) {
\r
5563 public <T> void forPossibleRelatedValue(final Resource subject,
\r
5564 final Resource relation, final Binding binding, final Procedure<T> procedure) {
\r
5566 session.syncRequest(new ReadRequest() {
\r
5569 public void run(ReadGraph graph) throws DatabaseException {
\r
5570 graph.forPossibleRelatedValue(subject, relation, binding, procedure);
\r
5573 } catch (DatabaseException e) {
\r
5579 public <T> void forPossibleAdapted(final Resource resource, final Class<T> clazz,
\r
5580 final AsyncListener<T> procedure) {
\r
5582 session.syncRequest(new ReadRequest() {
\r
5585 public void run(ReadGraph graph) throws DatabaseException {
\r
5586 graph.forPossibleAdapted(resource, clazz, procedure);
\r
5589 } catch (DatabaseException e) {
\r
5595 public <T> void forPossibleAdapted(final Resource resource, final Class<T> clazz,
\r
5596 final SyncListener<T> procedure) {
\r
5598 session.syncRequest(new ReadRequest() {
\r
5601 public void run(ReadGraph graph) throws DatabaseException {
\r
5602 graph.forPossibleAdapted(resource, clazz, procedure);
\r
5605 } catch (DatabaseException e) {
\r
5611 public <T> void forPossibleAdapted(final Resource resource, final Class<T> clazz,
\r
5612 final Listener<T> procedure) {
\r
5614 session.syncRequest(new ReadRequest() {
\r
5617 public void run(ReadGraph graph) throws DatabaseException {
\r
5618 graph.forPossibleAdapted(resource, clazz, procedure);
\r
5621 } catch (DatabaseException e) {
\r
5627 public <T> void forPossibleAdapted(final Resource resource, final Class<T> clazz,
\r
5628 final AsyncProcedure<T> procedure) {
\r
5630 session.syncRequest(new ReadRequest() {
\r
5633 public void run(ReadGraph graph) throws DatabaseException {
\r
5634 graph.forPossibleAdapted(resource, clazz, procedure);
\r
5637 } catch (DatabaseException e) {
\r
5643 public <T> void forPossibleAdapted(final Resource resource, final Class<T> clazz,
\r
5644 final SyncProcedure<T> procedure) {
\r
5646 session.syncRequest(new ReadRequest() {
\r
5649 public void run(ReadGraph graph) throws DatabaseException {
\r
5650 graph.forPossibleAdapted(resource, clazz, procedure);
\r
5653 } catch (DatabaseException e) {
\r
5659 public <T> void forPossibleAdapted(final Resource resource, final Class<T> clazz,
\r
5660 final Procedure<T> procedure) {
\r
5662 session.syncRequest(new ReadRequest() {
\r
5665 public void run(ReadGraph graph) throws DatabaseException {
\r
5666 graph.forPossibleAdapted(resource, clazz, procedure);
\r
5669 } catch (DatabaseException e) {
\r
5675 public <T> void forPossibleUniqueAdapted(final Resource resource,
\r
5676 final Class<T> clazz, final AsyncListener<T> procedure) {
\r
5678 session.syncRequest(new ReadRequest() {
\r
5681 public void run(ReadGraph graph) throws DatabaseException {
\r
5682 graph.forPossibleUniqueAdapted(resource, clazz, procedure);
\r
5685 } catch (DatabaseException e) {
\r
5691 public <T> void forPossibleUniqueAdapted(final Resource resource,
\r
5692 final Class<T> clazz, final SyncListener<T> procedure) {
\r
5694 session.syncRequest(new ReadRequest() {
\r
5697 public void run(ReadGraph graph) throws DatabaseException {
\r
5698 graph.forPossibleUniqueAdapted(resource, clazz, procedure);
\r
5701 } catch (DatabaseException e) {
\r
5707 public <T> void forPossibleUniqueAdapted(final Resource resource,
\r
5708 final Class<T> clazz, final Listener<T> procedure) {
\r
5710 session.syncRequest(new ReadRequest() {
\r
5713 public void run(ReadGraph graph) throws DatabaseException {
\r
5714 graph.forPossibleUniqueAdapted(resource, clazz, procedure);
\r
5717 } catch (DatabaseException e) {
\r
5723 public <T> void forPossibleUniqueAdapted(final Resource resource,
\r
5724 final Class<T> clazz, final AsyncProcedure<T> procedure) {
\r
5726 session.syncRequest(new ReadRequest() {
\r
5729 public void run(ReadGraph graph) throws DatabaseException {
\r
5730 graph.forPossibleUniqueAdapted(resource, clazz, procedure);
\r
5733 } catch (DatabaseException e) {
\r
5739 public <T> void forPossibleUniqueAdapted(final Resource resource,
\r
5740 final Class<T> clazz, final SyncProcedure<T> procedure) {
\r
5742 session.syncRequest(new ReadRequest() {
\r
5745 public void run(ReadGraph graph) throws DatabaseException {
\r
5746 graph.forPossibleUniqueAdapted(resource, clazz, procedure);
\r
5749 } catch (DatabaseException e) {
\r
5755 public <T> void forPossibleUniqueAdapted(final Resource resource,
\r
5756 final Class<T> clazz, final Procedure<T> procedure) {
\r
5758 session.syncRequest(new ReadRequest() {
\r
5761 public void run(ReadGraph graph) throws DatabaseException {
\r
5762 graph.forPossibleUniqueAdapted(resource, clazz, procedure);
\r
5765 } catch (DatabaseException e) {
\r
5771 public void forIsInstanceOf(final Resource resource, final Resource type,
\r
5772 final AsyncListener<Boolean> procedure) {
\r
5774 session.syncRequest(new ReadRequest() {
\r
5777 public void run(ReadGraph graph) throws DatabaseException {
\r
5778 graph.forIsInstanceOf(resource, type, procedure);
\r
5781 } catch (DatabaseException e) {
\r
5787 public void forIsInstanceOf(final Resource resource, final Resource type,
\r
5788 final SyncListener<Boolean> procedure) {
\r
5790 session.syncRequest(new ReadRequest() {
\r
5793 public void run(ReadGraph graph) throws DatabaseException {
\r
5794 graph.forIsInstanceOf(resource, type, procedure);
\r
5797 } catch (DatabaseException e) {
\r
5803 public void forIsInstanceOf(final Resource resource, final Resource type,
\r
5804 final Listener<Boolean> procedure) {
\r
5806 session.syncRequest(new ReadRequest() {
\r
5809 public void run(ReadGraph graph) throws DatabaseException {
\r
5810 graph.forIsInstanceOf(resource, type, procedure);
\r
5813 } catch (DatabaseException e) {
\r
5819 public void forIsInstanceOf(final Resource resource, final Resource type,
\r
5820 final AsyncProcedure<Boolean> procedure) {
\r
5822 session.syncRequest(new ReadRequest() {
\r
5825 public void run(ReadGraph graph) throws DatabaseException {
\r
5826 graph.forIsInstanceOf(resource, type, procedure);
\r
5829 } catch (DatabaseException e) {
\r
5835 public void forIsInstanceOf(final Resource resource, final Resource type,
\r
5836 final SyncProcedure<Boolean> procedure) {
\r
5838 session.syncRequest(new ReadRequest() {
\r
5841 public void run(ReadGraph graph) throws DatabaseException {
\r
5842 graph.forIsInstanceOf(resource, type, procedure);
\r
5845 } catch (DatabaseException e) {
\r
5851 public void forIsInstanceOf(final Resource resource, final Resource type,
\r
5852 final Procedure<Boolean> procedure) {
\r
5854 session.syncRequest(new ReadRequest() {
\r
5857 public void run(ReadGraph graph) throws DatabaseException {
\r
5858 graph.forIsInstanceOf(resource, type, procedure);
\r
5861 } catch (DatabaseException e) {
\r
5867 public void forIsInheritedFrom(final Resource resource, final Resource type,
\r
5868 final AsyncListener<Boolean> procedure) {
\r
5870 session.syncRequest(new ReadRequest() {
\r
5873 public void run(ReadGraph graph) throws DatabaseException {
\r
5874 graph.forIsInheritedFrom(resource, type, procedure);
\r
5877 } catch (DatabaseException e) {
\r
5883 public void forIsInheritedFrom(final Resource resource, final Resource type,
\r
5884 final SyncListener<Boolean> procedure) {
\r
5886 session.syncRequest(new ReadRequest() {
\r
5889 public void run(ReadGraph graph) throws DatabaseException {
\r
5890 graph.forIsInheritedFrom(resource, type, procedure);
\r
5893 } catch (DatabaseException e) {
\r
5899 public void forIsInheritedFrom(final Resource resource, final Resource type,
\r
5900 final Listener<Boolean> procedure) {
\r
5902 session.syncRequest(new ReadRequest() {
\r
5905 public void run(ReadGraph graph) throws DatabaseException {
\r
5906 graph.forIsInheritedFrom(resource, type, procedure);
\r
5909 } catch (DatabaseException e) {
\r
5915 public void forIsInheritedFrom(final Resource resource, final Resource type,
\r
5916 final AsyncProcedure<Boolean> procedure) {
\r
5918 session.syncRequest(new ReadRequest() {
\r
5921 public void run(ReadGraph graph) throws DatabaseException {
\r
5922 graph.forIsInheritedFrom(resource, type, procedure);
\r
5925 } catch (DatabaseException e) {
\r
5931 public void forIsInheritedFrom(final Resource resource, final Resource type,
\r
5932 final SyncProcedure<Boolean> procedure) {
\r
5934 session.syncRequest(new ReadRequest() {
\r
5937 public void run(ReadGraph graph) throws DatabaseException {
\r
5938 graph.forIsInheritedFrom(resource, type, procedure);
\r
5941 } catch (DatabaseException e) {
\r
5947 public void forIsInheritedFrom(final Resource resource, final Resource type,
\r
5948 final Procedure<Boolean> procedure) {
\r
5950 session.syncRequest(new ReadRequest() {
\r
5953 public void run(ReadGraph graph) throws DatabaseException {
\r
5954 graph.forIsInheritedFrom(resource, type, procedure);
\r
5957 } catch (DatabaseException e) {
\r
5963 public void forIsSubrelationOf(final Resource resource, final Resource relation,
\r
5964 final AsyncListener<Boolean> procedure) {
\r
5966 session.syncRequest(new ReadRequest() {
\r
5969 public void run(ReadGraph graph) throws DatabaseException {
\r
5970 graph.forIsSubrelationOf(resource, relation, procedure);
\r
5973 } catch (DatabaseException e) {
\r
5979 public void forIsSubrelationOf(final Resource resource, final Resource relation,
\r
5980 final SyncListener<Boolean> procedure) {
\r
5982 session.syncRequest(new ReadRequest() {
\r
5985 public void run(ReadGraph graph) throws DatabaseException {
\r
5986 graph.forIsSubrelationOf(resource, relation, procedure);
\r
5989 } catch (DatabaseException e) {
\r
5995 public void forIsSubrelationOf(final Resource resource, final Resource relation,
\r
5996 final Listener<Boolean> procedure) {
\r
5998 session.syncRequest(new ReadRequest() {
\r
6001 public void run(ReadGraph graph) throws DatabaseException {
\r
6002 graph.forIsSubrelationOf(resource, relation, procedure);
\r
6005 } catch (DatabaseException e) {
\r
6011 public void forIsSubrelationOf(final Resource resource, final Resource relation,
\r
6012 final AsyncProcedure<Boolean> procedure) {
\r
6014 session.syncRequest(new ReadRequest() {
\r
6017 public void run(ReadGraph graph) throws DatabaseException {
\r
6018 graph.forIsSubrelationOf(resource, relation, procedure);
\r
6021 } catch (DatabaseException e) {
\r
6027 public void forIsSubrelationOf(final Resource resource, final Resource relation,
\r
6028 final SyncProcedure<Boolean> procedure) {
\r
6030 session.syncRequest(new ReadRequest() {
\r
6033 public void run(ReadGraph graph) throws DatabaseException {
\r
6034 graph.forIsSubrelationOf(resource, relation, procedure);
\r
6037 } catch (DatabaseException e) {
\r
6043 public void forIsSubrelationOf(final Resource resource, final Resource relation,
\r
6044 final Procedure<Boolean> procedure) {
\r
6046 session.syncRequest(new ReadRequest() {
\r
6049 public void run(ReadGraph graph) throws DatabaseException {
\r
6050 graph.forIsSubrelationOf(resource, relation, procedure);
\r
6053 } catch (DatabaseException e) {
\r
6059 public void forOrderedSet(final Resource subject,
\r
6060 final AsyncMultiListener<Resource> procedure) {
\r
6062 session.syncRequest(new ReadRequest() {
\r
6065 public void run(ReadGraph graph) throws DatabaseException {
\r
6066 graph.forOrderedSet(subject, procedure);
\r
6069 } catch (DatabaseException e) {
\r
6075 public void forOrderedSet(final Resource subject,
\r
6076 final SyncMultiListener<Resource> procedure) {
\r
6078 session.syncRequest(new ReadRequest() {
\r
6081 public void run(ReadGraph graph) throws DatabaseException {
\r
6082 graph.forOrderedSet(subject, procedure);
\r
6085 } catch (DatabaseException e) {
\r
6091 public void forOrderedSet(final Resource subject,
\r
6092 final MultiListener<Resource> procedure) {
\r
6094 session.syncRequest(new ReadRequest() {
\r
6097 public void run(ReadGraph graph) throws DatabaseException {
\r
6098 graph.forOrderedSet(subject, procedure);
\r
6101 } catch (DatabaseException e) {
\r
6107 public void forOrderedSet(final Resource subject,
\r
6108 final AsyncMultiProcedure<Resource> procedure) {
\r
6110 session.syncRequest(new ReadRequest() {
\r
6113 public void run(ReadGraph graph) throws DatabaseException {
\r
6114 graph.forOrderedSet(subject, procedure);
\r
6117 } catch (DatabaseException e) {
\r
6123 public void forOrderedSet(final Resource subject,
\r
6124 final SyncMultiProcedure<Resource> procedure) {
\r
6127 session.syncRequest(new ReadRequest() {
\r
6130 public void run(ReadGraph graph) throws DatabaseException {
\r
6131 graph.forOrderedSet(subject, procedure);
\r
6134 } catch (DatabaseException e) {
\r
6140 public void forOrderedSet(final Resource subject,
\r
6141 final MultiProcedure<Resource> procedure) {
\r
6143 session.syncRequest(new ReadRequest() {
\r
6146 public void run(ReadGraph graph) throws DatabaseException {
\r
6147 graph.forOrderedSet(subject, procedure);
\r
6150 } catch (DatabaseException e) {
\r
6156 public int thread() {
\r
6161 public Session getSession() {
\r
6166 public Resource getBuiltin(final String id) throws ResourceNotFoundException,
\r
6167 ServiceException {
\r
6169 return session.syncRequest(new Read<Resource>() {
\r
6172 public Resource perform(ReadGraph graph) throws DatabaseException {
\r
6173 return graph.getBuiltin(id);
\r
6176 } catch (DatabaseException e) {
\r
6177 throw new ServiceException(e);
\r
6182 public VirtualGraph getProvider() {
\r