1 /*******************************************************************************
2 * Copyright (c) 2007, 2010 Association for Decentralized Information Management
4 * All rights reserved. This program and the accompanying materials
5 * are made available under the terms of the Eclipse Public License v1.0
6 * which accompanies this distribution, and is available at
7 * http://www.eclipse.org/legal/epl-v10.html
10 * VTT Technical Research Centre of Finland - initial API and implementation
11 *******************************************************************************/
12 package org.simantics.db.impl.graph;
14 import java.io.BufferedOutputStream;
16 import java.io.FileOutputStream;
17 import java.io.IOException;
18 import java.io.PrintStream;
19 import java.lang.reflect.Array;
20 import java.lang.reflect.InvocationTargetException;
21 import java.nio.BufferUnderflowException;
22 import java.util.ArrayList;
23 import java.util.Collection;
24 import java.util.Collections;
25 import java.util.IdentityHashMap;
26 import java.util.Iterator;
27 import java.util.List;
28 import java.util.ListIterator;
30 import java.util.function.Consumer;
32 import org.eclipse.core.runtime.Platform;
33 import org.simantics.databoard.Accessors;
34 import org.simantics.databoard.Bindings;
35 import org.simantics.databoard.accessor.Accessor;
36 import org.simantics.databoard.accessor.error.AccessorConstructionException;
37 import org.simantics.databoard.adapter.AdaptException;
38 import org.simantics.databoard.binding.Binding;
39 import org.simantics.databoard.binding.error.RuntimeBindingConstructionException;
40 import org.simantics.databoard.binding.impl.ObjectVariantBinding;
41 import org.simantics.databoard.binding.mutable.Variant;
42 import org.simantics.databoard.serialization.Serializer;
43 import org.simantics.databoard.type.Datatype;
44 import org.simantics.databoard.util.binary.BinaryFile;
45 import org.simantics.databoard.util.binary.RandomAccessBinary;
46 import org.simantics.db.AsyncReadGraph;
47 import org.simantics.db.DevelopmentKeys;
48 import org.simantics.db.ExternalValue;
49 import org.simantics.db.ExternalValueSupport;
50 import org.simantics.db.ReadGraph;
51 import org.simantics.db.RelationContext;
52 import org.simantics.db.Resource;
53 import org.simantics.db.Session;
54 import org.simantics.db.Statement;
55 import org.simantics.db.adaption.AdaptionService;
56 import org.simantics.db.common.primitiverequest.Adapter;
57 import org.simantics.db.common.primitiverequest.Builtin;
58 import org.simantics.db.common.primitiverequest.DatatypeBinding;
59 import org.simantics.db.common.primitiverequest.ForEachAssertedObject;
60 import org.simantics.db.common.primitiverequest.ForEachAssertedStatement;
61 import org.simantics.db.common.primitiverequest.HasStatement;
62 import org.simantics.db.common.primitiverequest.HasStatementSubject;
63 import org.simantics.db.common.primitiverequest.HasStatementSubjectObject;
64 import org.simantics.db.common.primitiverequest.HasValue;
65 import org.simantics.db.common.primitiverequest.Inverse;
66 import org.simantics.db.common.primitiverequest.IsInheritedFrom;
67 import org.simantics.db.common.primitiverequest.IsInstanceOf;
68 import org.simantics.db.common.primitiverequest.IsSubrelationOf;
69 import org.simantics.db.common.primitiverequest.OrderedSet;
70 import org.simantics.db.common.primitiverequest.PossibleAdapter;
71 import org.simantics.db.common.primitiverequest.PossibleInverse;
72 import org.simantics.db.common.primitiverequest.PossibleObject;
73 import org.simantics.db.common.primitiverequest.PossibleRelatedValue;
74 import org.simantics.db.common.primitiverequest.PossibleRelatedValueImplied;
75 import org.simantics.db.common.primitiverequest.PossibleStatement;
76 import org.simantics.db.common.primitiverequest.PossibleType;
77 import org.simantics.db.common.primitiverequest.PossibleUniqueAdapter;
78 import org.simantics.db.common.primitiverequest.PossibleValue;
79 import org.simantics.db.common.primitiverequest.PossibleValueImplied;
80 import org.simantics.db.common.primitiverequest.RelatedValue;
81 import org.simantics.db.common.primitiverequest.RelatedValueImplied;
82 import org.simantics.db.common.primitiverequest.SingleObject;
83 import org.simantics.db.common.primitiverequest.SingleStatement;
84 import org.simantics.db.common.primitiverequest.SingleType;
85 import org.simantics.db.common.primitiverequest.SingleTypeAny;
86 import org.simantics.db.common.primitiverequest.Types;
87 import org.simantics.db.common.primitiverequest.UniqueAdapter;
88 import org.simantics.db.common.primitiverequest.Value;
89 import org.simantics.db.common.primitiverequest.ValueImplied;
90 import org.simantics.db.common.primitiverequest.VariantValueImplied;
91 import org.simantics.db.common.procedure.adapter.AsyncMultiProcedureAdapter;
92 import org.simantics.db.common.procedure.adapter.ProcedureAdapter;
93 import org.simantics.db.common.procedure.adapter.TransientCacheAsyncListener;
94 import org.simantics.db.common.procedure.adapter.TransientCacheListener;
95 import org.simantics.db.common.procedure.single.SyncReadProcedure;
96 import org.simantics.db.common.procedure.single.wrapper.DeepSingleOrErrorProcedure;
97 import org.simantics.db.common.procedure.single.wrapper.DeepSingleOrNullProcedure;
98 import org.simantics.db.common.procedure.single.wrapper.ExceptionToNullProcedure;
99 import org.simantics.db.common.procedure.single.wrapper.NullSingleOrNullProcedure;
100 import org.simantics.db.common.procedure.single.wrapper.SingleFunctionalOrNullProcedure;
101 import org.simantics.db.common.procedure.single.wrapper.SingleOrErrorProcedure;
102 import org.simantics.db.common.procedure.single.wrapper.SingleOrNullProcedure;
103 import org.simantics.db.common.procedure.wrapper.NoneToAsyncListener;
104 import org.simantics.db.common.procedure.wrapper.NoneToAsyncMultiListener;
105 import org.simantics.db.common.procedure.wrapper.NoneToAsyncMultiProcedure;
106 import org.simantics.db.common.procedure.wrapper.NoneToAsyncProcedure;
107 import org.simantics.db.common.procedure.wrapper.NoneToAsyncSetProcedure;
108 import org.simantics.db.common.procedure.wrapper.SyncToAsyncListener;
109 import org.simantics.db.common.procedure.wrapper.SyncToAsyncMultiListener;
110 import org.simantics.db.common.procedure.wrapper.SyncToAsyncMultiProcedure;
111 import org.simantics.db.common.procedure.wrapper.SyncToAsyncProcedure;
112 import org.simantics.db.common.procedure.wrapper.SyncToAsyncSetProcedure;
113 import org.simantics.db.common.request.AdaptValue;
114 import org.simantics.db.common.request.ResourceRead;
115 import org.simantics.db.common.utils.Logger;
116 import org.simantics.db.common.utils.NameUtils;
117 import org.simantics.db.common.validation.L0Validations;
118 import org.simantics.db.exception.AdaptionException;
119 import org.simantics.db.exception.ArgumentException;
120 import org.simantics.db.exception.AssumptionException;
121 import org.simantics.db.exception.BindingException;
122 import org.simantics.db.exception.DatabaseException;
123 import org.simantics.db.exception.DoesNotContainValueException;
124 import org.simantics.db.exception.EmptyResourceException;
125 import org.simantics.db.exception.InternalException;
126 import org.simantics.db.exception.InvalidLiteralException;
127 import org.simantics.db.exception.ManyObjectsForFunctionalRelationException;
128 import org.simantics.db.exception.NoInverseException;
129 import org.simantics.db.exception.NoSingleResultException;
130 import org.simantics.db.exception.ResourceNotFoundException;
131 import org.simantics.db.exception.ServiceException;
132 import org.simantics.db.exception.ValidationException;
133 import org.simantics.db.impl.RelationContextImpl;
134 import org.simantics.db.impl.ResourceImpl;
135 import org.simantics.db.impl.internal.RandomAccessValueSupport;
136 import org.simantics.db.impl.internal.ResourceData;
137 import org.simantics.db.impl.procedure.CallWrappedSingleQueryProcedure4;
138 import org.simantics.db.impl.procedure.ResultCallWrappedQueryProcedure4;
139 import org.simantics.db.impl.procedure.ResultCallWrappedSingleQueryProcedure4;
140 import org.simantics.db.impl.query.CacheEntry;
141 import org.simantics.db.impl.query.QueryCache;
142 import org.simantics.db.impl.query.QueryProcessor;
143 import org.simantics.db.impl.query.QuerySupport;
144 import org.simantics.db.impl.query.TripleIntProcedure;
145 import org.simantics.db.impl.support.ResourceSupport;
146 import org.simantics.db.procedure.AsyncListener;
147 import org.simantics.db.procedure.AsyncMultiListener;
148 import org.simantics.db.procedure.AsyncMultiProcedure;
149 import org.simantics.db.procedure.AsyncProcedure;
150 import org.simantics.db.procedure.AsyncSetListener;
151 import org.simantics.db.procedure.Listener;
152 import org.simantics.db.procedure.ListenerBase;
153 import org.simantics.db.procedure.MultiListener;
154 import org.simantics.db.procedure.MultiProcedure;
155 import org.simantics.db.procedure.Procedure;
156 import org.simantics.db.procedure.SetListener;
157 import org.simantics.db.procedure.StatementProcedure;
158 import org.simantics.db.procedure.SyncListener;
159 import org.simantics.db.procedure.SyncMultiListener;
160 import org.simantics.db.procedure.SyncMultiProcedure;
161 import org.simantics.db.procedure.SyncProcedure;
162 import org.simantics.db.procedure.SyncSetListener;
163 import org.simantics.db.request.AsyncMultiRead;
164 import org.simantics.db.request.AsyncRead;
165 import org.simantics.db.request.DelayedWrite;
166 import org.simantics.db.request.DelayedWriteResult;
167 import org.simantics.db.request.ExternalRead;
168 import org.simantics.db.request.MultiRead;
169 import org.simantics.db.request.Read;
170 import org.simantics.db.request.ReadInterface;
171 import org.simantics.db.request.RequestFlags;
172 import org.simantics.db.request.Write;
173 import org.simantics.db.request.WriteInterface;
174 import org.simantics.db.request.WriteOnly;
175 import org.simantics.db.request.WriteOnlyResult;
176 import org.simantics.db.request.WriteResult;
177 import org.simantics.layer0.Layer0;
178 import org.simantics.scl.compiler.types.Type;
179 import org.simantics.scl.compiler.types.exceptions.SCLTypeParseException;
180 import org.simantics.scl.reflection.ReflectionUtils;
181 import org.simantics.scl.reflection.ValueNotFoundException;
182 import org.simantics.scl.runtime.function.Function3;
183 import org.simantics.utils.DataContainer;
184 import org.simantics.utils.Development;
185 import org.simantics.utils.datastructures.Pair;
186 import org.simantics.utils.datastructures.collections.CollectionUtils;
188 import gnu.trove.map.hash.TObjectIntHashMap;
190 public class ReadGraphImpl implements ReadGraph {
192 final static boolean EMPTY_RESOURCE_CHECK = false;
194 final public CacheEntry parent;
195 final public QueryProcessor processor;
197 final static Binding DATA_TYPE_BINDING_INTERNAL = Bindings.getBindingUnchecked(Datatype.class);
198 final static Serializer DATA_TYPE_SERIALIZER = Bindings.getSerializerUnchecked(DATA_TYPE_BINDING_INTERNAL);
200 final public static TObjectIntHashMap<String> counters = new TObjectIntHashMap<String>();
202 public static void resetCounters() {
206 public static String listCounters(File file) throws IOException {
208 PrintStream b = new PrintStream(new BufferedOutputStream(new FileOutputStream(file)));
210 for(Pair<String,Integer> p : CollectionUtils.valueSortedEntries(counters)) {
211 b.print(-p.second + " " + p.first + "\n");
216 return "Dumped " + counters.size() + " queries.";
221 * Implementation of the interface ReadGraph
223 final public String getURI(final Resource resource) throws AssumptionException, ValidationException, ServiceException {
225 assert (resource != null);
229 return syncRequest(new org.simantics.db.common.uri.ResourceToURI(resource));
231 } catch (AssumptionException e) {
233 throw new AssumptionException(e);
235 } catch (ValidationException e) {
237 throw new ValidationException(e);
239 } catch (ServiceException e) {
241 throw new ServiceException(e);
243 } catch (DatabaseException e) {
245 throw new ServiceException(INTERNAL_ERROR_STRING, e);
251 final public String getPossibleURI(final Resource resource) throws ValidationException, ServiceException {
253 assert (resource != null);
257 return syncRequest(new org.simantics.db.common.uri.ResourceToPossibleURI(resource));
259 } catch (ValidationException e) {
261 throw new ValidationException(e);
263 } catch (ServiceException e) {
265 throw new ServiceException(e);
267 } catch (DatabaseException e) {
269 throw new ServiceException(INTERNAL_ERROR_STRING, e);
275 final public Resource getResource(final String id)
276 throws ResourceNotFoundException, ValidationException,
283 return syncRequest(new org.simantics.db.common.primitiverequest.Resource(
286 } catch (ResourceNotFoundException e) {
288 throw new ResourceNotFoundException(id, e);
290 } catch (ValidationException e) {
292 throw new ValidationException(e);
294 } catch (ServiceException e) {
296 throw new ServiceException(e);
298 } catch (DatabaseException e) {
300 throw new ServiceException(INTERNAL_ERROR_STRING, e);
306 final public Resource getPossibleResource(final String id)
307 throws ResourceNotFoundException, ValidationException,
314 return syncRequest(new org.simantics.db.common.primitiverequest.Resource(
317 } catch (ResourceNotFoundException e) {
321 } catch (ValidationException e) {
323 throw new ValidationException(e);
325 } catch (ServiceException e) {
327 throw new ServiceException(e);
329 } catch (DatabaseException e) {
331 throw new ServiceException(INTERNAL_ERROR_STRING, e);
337 final public Resource getRootLibrary() {
338 return processor.getRootLibraryResource();
341 final public Resource getBuiltin(final String id)
342 throws ResourceNotFoundException, ServiceException {
348 return syncRequest(new Builtin(id));
350 } catch (ResourceNotFoundException e) {
352 throw new ResourceNotFoundException(id, e);
354 } catch (ServiceException e) {
356 throw new ServiceException(e);
358 } catch (DatabaseException e) {
360 throw new ServiceException(INTERNAL_ERROR_STRING, e);
366 static class StatementReadProcedure extends TIntArrayListInternal implements StatementProcedure {
368 private static Throwable DONE = new Throwable();
370 Throwable exception = null;
372 final ResourceSupport support;
374 public StatementReadProcedure(ResourceSupport support) {
375 this.support = support;
379 public synchronized void execute(AsyncReadGraph graph, int s, int p, int o) {
386 public void finished(AsyncReadGraph graph) {
391 public void exception(AsyncReadGraph graph, Throwable t) {
395 public void checkAndThrow() throws DatabaseException {
396 if(exception != DONE) {
397 if (exception instanceof DatabaseException)
398 throw (DatabaseException) exception;
400 throw new DatabaseException(
401 "Unexpected exception in ReadGraph.syncRequest(AsyncMultiRead)",
406 public boolean done() {
407 return exception != null;
411 public boolean contains(Object obj) {
412 if(!(obj instanceof InternalStatement))
414 InternalStatement statement = (InternalStatement)obj;
418 for(int i=0;i<sizeInternal();i+=3)
419 if(s==getQuick(i) && p==getQuick(i+1) && o==getQuick(i+2))
424 @SuppressWarnings("unchecked")
426 public <T> T[] toArray(T[] a) {
427 int length = sizeInternal() / 3;
428 if(length > a.length) {
429 Class<?> arrayType = a.getClass();
430 a = (arrayType == Object[].class)
431 ? (T[]) new Object[length]
432 : (T[]) Array.newInstance(arrayType.getComponentType(), length);
435 for(int i=length;i<a.length;++i)
438 for(int i=0,j=0;i<sizeInternal();i+=3,++j)
439 a[j] = (T)new InternalStatement(support, getQuick(i), getQuick(i+1), getQuick(i+2));
444 public boolean add(Statement e) {
445 throw new UnsupportedOperationException();
449 public boolean remove(Object o) {
450 throw new UnsupportedOperationException();
454 public boolean addAll(Collection<? extends Statement> c) {
455 throw new UnsupportedOperationException();
458 class IteratorImpl implements ListIterator<Statement> {
462 public IteratorImpl(int index) {
467 public boolean hasNext() {
468 return index < sizeInternal();
472 public Statement next() {
473 Statement result = new InternalStatement(support, getQuick(index), getQuick(index+1), getQuick(index+2));
479 public void remove() {
480 throw new Error("Not supported");
484 public boolean hasPrevious() {
489 public Statement previous() {
491 Statement result = new InternalStatement(support, getQuick(index), getQuick(index+1), getQuick(index+2));
496 public int nextIndex() {
501 public int previousIndex() {
506 public void set(Statement e) {
507 throw new UnsupportedOperationException();
511 public void add(Statement e) {
512 throw new UnsupportedOperationException();
518 public Iterator<Statement> iterator() {
519 return new IteratorImpl(0);
524 return sizeInternal() / 3;
528 public Object[] toArray() {
529 Object[] result = new Object[sizeInternal() / 3];
530 for(int i=0,j=0;j<sizeInternal();i++,j+=3)
531 result[i] = new InternalStatement(support, getQuick(j), getQuick(j+1), getQuick(j+2));
536 public boolean addAll(int index, Collection<? extends Statement> c) {
537 throw new UnsupportedOperationException();
541 public Statement get(int index) {
543 if(index < 0 || index >= sizeInternal())
544 throw new IndexOutOfBoundsException();
545 return new InternalStatement(support, getQuick(index), getQuick(index+1), getQuick(index+2));
549 public Statement set(int index, Statement element) {
550 throw new UnsupportedOperationException();
554 public void add(int index, Statement element) {
555 throw new UnsupportedOperationException();
559 public Statement remove(int index) {
560 throw new UnsupportedOperationException();
564 public int indexOf(Object obj) {
565 if(!(obj instanceof InternalStatement))
567 InternalStatement statement = (InternalStatement)obj;
571 for(int i=0;i<sizeInternal();i+=3)
572 if(s==getQuick(i) && p==getQuick(i+1) && o==getQuick(i+2))
578 public int lastIndexOf(Object obj) {
579 if(!(obj instanceof InternalStatement))
581 InternalStatement statement = (InternalStatement)obj;
585 for(int i=sizeInternal()-3;i>=0;i-=3)
586 if(s==getQuick(i) && p==getQuick(i+1) && o==getQuick(i+2))
592 public ListIterator<Statement> listIterator() {
593 return new IteratorImpl(0);
597 public ListIterator<Statement> listIterator(int index) {
598 return new IteratorImpl(index*3);
602 public List<Statement> subList(int fromIndex, int toIndex) {
603 if(fromIndex < 0 || toIndex*3 >= sizeInternal() || fromIndex > toIndex)
604 throw new IndexOutOfBoundsException();
605 return new RandomAccessSubList<Statement>(this, fromIndex, toIndex-fromIndex);
610 final public Collection<Statement> getStatements(final Resource subject,
611 final Resource relation)
612 throws ManyObjectsForFunctionalRelationException, ServiceException {
614 assert (subject != null);
615 assert (relation != null);
619 StatementReadProcedure procedure = new StatementReadProcedure(getResourceSupport());
620 processor.forEachStatement(this, subject, relation, procedure);
621 procedure.checkAndThrow();
624 } catch (DatabaseException e) {
626 System.err.println(INTERNAL_ERROR_STRING + " getStatements " + subject + " " + relation);
628 StatementReadProcedure procedure = new StatementReadProcedure(getResourceSupport());
629 processor.forEachStatement(this, subject, relation, procedure);
631 return Collections.emptyList();
633 // throw new ServiceException(INTERNAL_ERROR_STRING + " getStatements " + subject + " " + relation, e);
640 final public Collection<Statement> getAssertedStatements(final Resource subject, final Resource relation)
641 throws ManyObjectsForFunctionalRelationException, ServiceException {
643 assert (subject != null);
644 assert (relation != null);
648 return syncRequest(new ForEachAssertedStatement(subject, relation));
650 } catch (ManyObjectsForFunctionalRelationException e) {
652 throw new ManyObjectsForFunctionalRelationException(e);
654 } catch (ServiceException e) {
656 throw new ServiceException(e);
658 } catch (DatabaseException e) {
660 throw new ServiceException(INTERNAL_ERROR_STRING, e);
667 final public Collection<Resource> getPredicates(final Resource subject) throws ServiceException {
669 assert (subject != null);
673 return processor.getPredicates(this, subject);
675 // AsyncMultiReadProcedure<Resource> procedure = new AsyncMultiReadProcedure<Resource>();
676 // processor.forEachPredicate(this, subject, procedure);
677 // procedure.checkAndThrow();
680 } catch (ServiceException e) {
682 throw new ServiceException(e);
684 } catch (DatabaseException e) {
686 throw new ServiceException(INTERNAL_ERROR_STRING, e);
688 } catch (Throwable e) {
690 throw new ServiceException(e);
697 final public Collection<Resource> getPrincipalTypes(final Resource subject)
698 throws ServiceException {
700 assert (subject != null);
704 AsyncMultiReadProcedure<Resource> procedure = new AsyncMultiReadProcedure<Resource>();
705 processor.forEachPrincipalType(this, subject, procedure);
706 procedure.checkAndThrow();
709 } catch (ServiceException e) {
711 throw new ServiceException(e);
713 } catch (DatabaseException e) {
715 throw new ServiceException(INTERNAL_ERROR_STRING, e);
722 final public Set<Resource> getTypes(final Resource subject) throws ServiceException {
724 assert (subject != null);
728 return processor.getTypes(this, subject);
730 } catch (ServiceException e) {
732 throw new ServiceException(e);
734 } catch (DatabaseException e) {
736 throw new ServiceException(INTERNAL_ERROR_STRING, e);
738 } catch (Throwable e) {
740 throw new ServiceException(e);
747 final public Set<Resource> getSupertypes(final Resource subject)
748 throws ServiceException {
750 assert (subject != null);
754 SyncReadProcedure<Set<Resource>> procedure = new SyncReadProcedure<Set<Resource>>();
755 processor.forSupertypes(this, subject, procedure);
756 procedure.checkAndThrow();
757 return procedure.result;
759 } catch (ServiceException e) {
761 throw new ServiceException(e);
763 } catch (DatabaseException e) {
765 throw new ServiceException(INTERNAL_ERROR_STRING, e);
772 final public Set<Resource> getSuperrelations(final Resource subject)
773 throws ServiceException {
775 assert (subject != null);
779 SyncReadProcedure<Set<Resource>> procedure = new SyncReadProcedure<Set<Resource>>();
780 processor.forSuperrelations(this, subject, procedure);
781 procedure.checkAndThrow();
782 return procedure.result;
784 } catch (ServiceException e) {
786 throw new ServiceException(e);
788 } catch (DatabaseException e) {
790 throw new ServiceException(INTERNAL_ERROR_STRING, e);
797 public Resource getPossibleSuperrelation(Resource subject) throws ServiceException {
801 SyncReadProcedure<Resource> procedure = new SyncReadProcedure<Resource>();
802 processor.forPossibleSuperrelation(this, subject, procedure);
803 procedure.checkAndThrow();
804 return procedure.result;
806 } catch (ServiceException e) {
808 throw new ServiceException(e);
810 } catch (DatabaseException e) {
812 throw new ServiceException(INTERNAL_ERROR_STRING, e);
819 final public Collection<Resource> getObjects(final Resource subject, final Resource relation)
820 throws ServiceException {
822 assert (subject != null);
823 assert (relation != null);
825 if(Development.DEVELOPMENT) {
826 if(Development.isTrue(DevelopmentKeys.READGRAPH_COUNT)) {
827 counters.adjustOrPutValue("objects $" + subject.getResourceId() + " $" + relation.getResourceId(), 1, 1);
829 //if(subject.getResourceId()==xx && relation.getResourceId()==xx) new Exception().printStackTrace();
834 AsyncMultiReadProcedure<Resource> procedure = new AsyncMultiReadProcedure<Resource>();
835 processor.forEachObject(this, subject, relation, procedure);
836 procedure.checkAndThrow();
839 } catch (DatabaseException e) {
841 throw new ServiceException(INTERNAL_ERROR_STRING, e);
848 final public Collection<Resource> getAssertedObjects(
849 final Resource subject, final Resource relation)
850 throws ManyObjectsForFunctionalRelationException, ServiceException {
853 throw new ArgumentException("Subject must not be null.");
854 if (relation == null)
855 throw new ArgumentException("Relation must not be null. Subject=" + subject);
859 return syncRequest(new ForEachAssertedObject(subject, relation));
861 } catch (ManyObjectsForFunctionalRelationException e) {
863 throw new ManyObjectsForFunctionalRelationException(e);
865 } catch (ServiceException e) {
867 throw new ServiceException(e);
869 } catch (DatabaseException e) {
871 throw new ServiceException(INTERNAL_ERROR_STRING, e);
878 final public Resource getInverse(final Resource relation) throws NoInverseException, ServiceException {
880 assert (relation != null);
884 return getSingleObject(relation, processor.querySupport.getResource(processor.getInverseOf()));
886 } catch (NoSingleResultException e) {
888 throw new NoInverseException(e);
890 } catch (ServiceException e) {
892 throw new ServiceException(e);
899 final public Resource getSingleObject(final Resource subject, final Resource relation) throws NoSingleResultException, ServiceException {
901 if( subject == null) throw new IllegalArgumentException("subject can not be null");
902 if( relation == null) throw new IllegalArgumentException("relation can not be null");
905 int single = processor.getSingleObject(this, subject, relation);
907 if (EMPTY_RESOURCE_CHECK) {
908 if (!hasStatement(subject)) {
909 throw new EmptyResourceException("Resource " + debugString(subject));
912 throw new NoSingleResultException("No single object for subject " + debugString(subject)
913 + " and relation " + debugString(relation), single);
915 return processor.querySupport.getResource(single);
916 } catch (NoSingleResultException e) {
918 } catch (DatabaseException e) {
919 throw new ServiceException(e);
924 final public Statement getSingleStatement(final Resource subject, final Resource relation) throws NoSingleResultException, ManyObjectsForFunctionalRelationException, ServiceException {
925 assert (subject != null);
926 assert (relation != null);
928 Collection<Statement> statements = getStatements(subject, relation);
929 if (statements.size() == 1) {
930 return statements.iterator().next();
932 if (EMPTY_RESOURCE_CHECK)
933 if (!hasStatement(subject))
934 throw new EmptyResourceException("Resource " + debugString(subject));
935 throw new NoSingleResultException("No single statement for subject " + debugString(subject)
936 + " and relation " + debugString(relation), statements.size());
938 } catch (ServiceException e) {
939 throw new ServiceException(e);
944 final public Resource getSingleType(final Resource subject) throws NoSingleResultException, ServiceException {
945 assert (subject != null);
947 ArrayList<Resource> principalTypes = (ArrayList<Resource>)getPrincipalTypes(subject);
948 if (principalTypes.size() == 1) {
949 return principalTypes.get(0);
951 throw new NoSingleResultException("No single type for subject " + debugString(subject), principalTypes.size());
953 } catch (ServiceException e) {
954 throw new ServiceException(e);
959 final public Resource getSingleType(final Resource subject,
960 final Resource baseType) throws NoSingleResultException,
963 assert (subject != null);
964 assert (baseType != null);
967 return syncRequest(new SingleType(subject, baseType));
968 } catch (DatabaseException e) {
969 throw new NoSingleResultException("subject=" + subject + ", baseType=" + baseType, 0, e);
974 final public <T> T getValue(final Resource subject) throws DoesNotContainValueException, ServiceException {
976 assert (subject != null);
980 Layer0 L0 = processor.getL0(this);
981 int object = processor.getSingleObject(this, subject, L0.HasDataType);
982 if(object == 0) throw new DoesNotContainValueException("No data type for " + subject);
984 if(processor.isImmutable(object)) {
985 Binding binding = syncRequest(new DatatypeBinding(processor.querySupport.getResource(object)), TransientCacheListener.<Binding>instance());
986 return getValue(subject, binding);
988 byte[] dt = processor.getValue(this, object);
989 if(dt == null) throw new ServiceException("No data type for " + subject);
990 Datatype datatype = (Datatype)DATA_TYPE_SERIALIZER.deserialize(dt);
991 Binding binding = Bindings.getBinding(datatype);
992 return getValue(subject, binding);
995 } catch (IOException e) {
997 throw new ServiceException(e);
999 } catch (DoesNotContainValueException e) {
1001 throw new DoesNotContainValueException(e, subject);
1003 } catch (ServiceException e) {
1005 throw new ServiceException(e);
1007 } catch (DatabaseException e) {
1009 throw new ServiceException(INTERNAL_ERROR_STRING, e);
1016 final public Variant getVariantValue(final Resource subject) throws DoesNotContainValueException, ServiceException {
1018 assert (subject != null);
1022 Layer0 L0 = processor.getL0(this);
1023 int object = processor.getSingleObject(this, subject, L0.HasDataType);
1024 if(object == 0) throw new DoesNotContainValueException("No data type for " + subject);
1026 if(processor.isImmutable(object)) {
1027 Binding binding = syncRequest(new DatatypeBinding(processor.querySupport.getResource(object)), TransientCacheListener.<Binding>instance());
1028 return new Variant(binding, getValue(subject, binding));
1030 byte[] dt = processor.getValue(this, object);
1031 if(dt == null) throw new ServiceException("No data type for " + subject);
1032 Datatype datatype = (Datatype)DATA_TYPE_SERIALIZER.deserialize(dt);
1033 Binding binding = Bindings.getBinding(datatype);
1034 return new Variant(binding, getValue(subject, binding));
1037 } catch (IOException e) {
1039 throw new ServiceException(e);
1041 } catch (DoesNotContainValueException e) {
1043 throw new DoesNotContainValueException(e, subject);
1045 } catch (ServiceException e) {
1047 throw new ServiceException(e);
1049 } catch (DatabaseException e) {
1051 throw new ServiceException(INTERNAL_ERROR_STRING, e);
1056 static final IdentityHashMap<Binding,Serializer> serializers = new IdentityHashMap<Binding,Serializer>();
1059 serializers.put(Bindings.STRING, Bindings.STRING.serializer());
1062 final protected Serializer getSerializer(Binding binding) {
1063 return binding.serializer();
1067 final public <T> T getValue(final Resource subject, final Binding binding) throws DoesNotContainValueException, BindingException,
1070 assert (subject != null);
1074 byte[] bytes = processor.getValue(this, subject);
1075 if (bytes == null) throw new DoesNotContainValueException("No value for resource " + subject);
1077 Serializer serializer = getSerializer(binding);
1078 return (T)serializer.deserialize(bytes);
1080 } catch (DoesNotContainValueException e) {
1082 throw new DoesNotContainValueException(e);
1084 } catch (IOException e) {
1086 throw new ServiceException(e);
1088 } catch (DatabaseException e) {
1090 throw new ServiceException(e);
1092 } catch (BufferUnderflowException e) {
1093 // This is sometimes thrown when deserialize fails because wrong format.
1094 // For callers of this method this is just an service exception.
1095 throw new ServiceException(e);
1101 final public <T> T getRelatedValue(final Resource subject, final Resource relation) throws NoSingleResultException,
1102 DoesNotContainValueException, ServiceException {
1104 assert (subject != null);
1105 assert (relation != null);
1108 Resource object = getSingleObject(subject, relation);
1109 return getValue(object);
1110 } catch (NoSingleResultException e) {
1111 throw new NoSingleResultException("No single value found for subject " + debugString(subject) + " and relation " + debugString(relation), e.getResultCount(), e);
1112 } catch (DoesNotContainValueException e) {
1114 Layer0 L0 = processor.getL0(this);
1115 Resource object = getPossibleObject(subject, relation);
1116 if(isInstanceOf(object, L0.Value)) {
1117 if(isInstanceOf(object, L0.Literal)) {
1118 throw new DoesNotContainValueException(e);
1120 throw new InvalidLiteralException("The object " + object + " is not an instance of L0.Literal (use getRelatedValue2 instead)", e);
1123 throw new DoesNotContainValueException("The object " + object + " is not an instance of L0.Value", e);
1125 } catch (DoesNotContainValueException e2) {
1127 } catch (DatabaseException e2) {
1128 throw new InternalException("The client failed to analyse the cause of the following exception", e);
1130 } catch (ServiceException e) {
1131 throw new ServiceException(e);
1136 final public Variant getRelatedVariantValue(final Resource subject, final Resource relation) throws NoSingleResultException,
1137 DoesNotContainValueException, ServiceException {
1139 assert (subject != null);
1140 assert (relation != null);
1143 Resource object = getSingleObject(subject, relation);
1144 return getVariantValue(object);
1145 } catch (NoSingleResultException e) {
1146 throw new NoSingleResultException("No single object for subject " + debugString(subject) + " and relation " + debugString(relation), e.getResultCount(), e);
1147 } catch (DoesNotContainValueException e) {
1149 Layer0 L0 = processor.getL0(this);
1150 Resource object = getPossibleObject(subject, relation);
1151 if(isInstanceOf(object, L0.Value)) {
1152 if(isInstanceOf(object, L0.Literal)) {
1153 throw new DoesNotContainValueException(e);
1155 throw new InvalidLiteralException("The object " + object + " is not an instance of L0.Literal (use getRelatedValue2 instead)", e);
1158 throw new DoesNotContainValueException("The object " + object + " is not an instance of L0.Value", e);
1160 } catch (DoesNotContainValueException e2) {
1162 } catch (DatabaseException e2) {
1163 throw new InternalException("The client failed to analyse the cause of the following exception", e);
1165 } catch (ServiceException e) {
1166 throw new ServiceException(e);
1171 final public <T> T getRelatedValue(final Resource subject, final Resource relation, final Binding binding)
1172 throws NoSingleResultException, DoesNotContainValueException, BindingException, ServiceException {
1174 assert (subject != null);
1175 assert (relation != null);
1178 Resource object = getSingleObject(subject, relation);
1179 return getValue(object, binding);
1180 } catch (NoSingleResultException e) {
1181 String message = "";
1183 String subjectName = NameUtils.getSafeName(this, subject, true);
1184 String relationName = NameUtils.getSafeName(this, relation, true);
1185 message = "Subject: " + subjectName + ", Relation: " + relationName;
1186 } catch (DatabaseException e2) {
1189 throw new NoSingleResultException(message, e.getResultCount(), e);
1190 } catch (DoesNotContainValueException e) {
1191 throw new DoesNotContainValueException(e);
1192 } catch (ServiceException e) {
1193 throw new ServiceException(e);
1198 final public <T> T adapt(final Resource resource, final Class<T> clazz)
1199 throws AdaptionException, ValidationException, ServiceException {
1201 assert (resource != null);
1202 assert (clazz != null);
1206 return syncRequest(new Adapter<T>(resource, clazz));
1208 } catch (AdaptionException e) {
1210 throw new AdaptionException(e);
1212 } catch (ValidationException e) {
1214 throw new ValidationException(e);
1216 } catch (ServiceException e) {
1218 throw new ServiceException(e);
1220 } catch (DatabaseException e) {
1222 throw new ServiceException(INTERNAL_ERROR_STRING, e);
1229 final public <T,C> T adaptContextual(final Resource resource, final C context, final Class<C> contextClass, final Class<T> clazz)
1230 throws AdaptionException, ValidationException, ServiceException {
1232 assert (resource != null);
1233 assert (context != null);
1235 class ContextualAdapter implements AsyncRead<T> {
1237 final private Resource resource;
1238 final private C context;
1239 final private Class<T> clazz;
1242 public int hashCode() {
1243 return resource.hashCode() + 31 * (clazz.hashCode() + 41 * context.hashCode());
1247 final public int threadHash() {
1248 return resource.getThreadHash();
1252 public boolean equals(Object object) {
1255 else if (object == null)
1257 else if (getClass() != object.getClass())
1259 ContextualAdapter r = (ContextualAdapter)object;
1260 return resource.equals(r.resource) && context.equals(r.context) && clazz.equals(r.clazz);
1264 public int getFlags() {
1268 public ContextualAdapter(Resource resource, C context, Class<T> clazz) {
1269 this.resource = resource;
1270 this.context = context;
1275 public void perform(AsyncReadGraph graph, AsyncProcedure<T> procedure) {
1277 final AdaptionService service = getSession().peekService(AdaptionService.class);
1278 if (service == null)
1279 procedure.exception(graph, new ServiceException("No AdaptionService available"));
1281 service.adapt(graph, resource, context, contextClass, clazz, false, procedure);
1286 public String toString() {
1287 return "Adapter for (" + resource + "," + context + ") as " + clazz.getName();
1294 return syncRequest(new ContextualAdapter(resource, context, clazz));
1296 } catch (AdaptionException e) {
1298 throw new AdaptionException(e);
1300 } catch (ValidationException e) {
1302 throw new ValidationException(e);
1304 } catch (ServiceException e) {
1306 throw new ServiceException(e);
1308 } catch (DatabaseException e) {
1310 throw new ServiceException(INTERNAL_ERROR_STRING, e);
1317 final public <T> T adaptRelated(final Resource resource, final Resource relation, final Class<T> clazz)
1318 throws AdaptionException, NoSingleResultException, ValidationException, ServiceException {
1320 assert (resource != null);
1321 assert (clazz != null);
1323 Statement stm = getSingleStatement(resource, relation);
1325 return adaptContextual(stm.getObject(), new RelationContextImpl(resource, stm), RelationContext.class, clazz);
1330 final public <T> T getPossibleRelatedAdapter(final Resource resource, final Resource relation, final Class<T> clazz)
1331 throws ValidationException, ServiceException {
1334 return adaptRelated(resource, relation, clazz);
1335 } catch (DatabaseException e) {
1342 final public <T,C> T getPossibleContextualAdapter(final Resource resource, final C context, final Class<C> contextClass, final Class<T> clazz)
1343 throws ValidationException, ServiceException {
1345 assert (resource != null);
1346 assert (context != null);
1348 class PossibleContextualAdapter implements AsyncRead<T> {
1350 final private Resource resource;
1351 final private C context;
1352 final private Class<T> clazz;
1355 public int hashCode() {
1356 return resource.hashCode() + 31 * (clazz.hashCode() + 41 * context.hashCode());
1360 final public int threadHash() {
1361 return resource.getThreadHash();
1365 public boolean equals(Object object) {
1368 else if (object == null)
1370 else if (getClass() != object.getClass())
1372 PossibleContextualAdapter r = (PossibleContextualAdapter)object;
1373 return resource.equals(r.resource) && context.equals(r.context) && clazz.equals(r.clazz);
1377 public int getFlags() {
1381 public PossibleContextualAdapter(Resource resource, C context, Class<T> clazz) {
1382 this.resource = resource;
1383 this.context = context;
1388 public void perform(AsyncReadGraph graph, AsyncProcedure<T> procedure) {
1390 final AdaptionService service = getSession().peekService(AdaptionService.class);
1391 if (service == null)
1392 procedure.exception(graph, new ServiceException("No AdaptionService available"));
1394 service.adapt(graph, resource, context, contextClass, clazz, true, procedure);
1399 public String toString() {
1400 return "Possible adapter for (" + resource + "," + context + ") as " + clazz.getName();
1407 return syncRequest(new PossibleContextualAdapter(resource, context, clazz));
1409 } catch (ValidationException e) {
1411 throw new ValidationException(e);
1413 } catch (ServiceException e) {
1415 throw new ServiceException(e);
1417 } catch (DatabaseException e) {
1419 throw new ServiceException(INTERNAL_ERROR_STRING, e);
1426 final public <T> T adaptUnique(final Resource resource, final Class<T> clazz)
1427 throws AdaptionException, ValidationException, ServiceException {
1429 assert (resource != null);
1430 assert (clazz != null);
1434 return syncRequest(new UniqueAdapter<T>(resource, clazz));
1436 } catch (AdaptionException e) {
1438 throw new AdaptionException(e);
1440 } catch (ValidationException e) {
1442 throw new ValidationException(e);
1444 } catch (ServiceException e) {
1446 throw new ServiceException(e);
1448 } catch (DatabaseException e) {
1450 throw new ServiceException(INTERNAL_ERROR_STRING, e);
1457 final public Resource getPossibleInverse(final Resource relation)
1458 throws ServiceException {
1460 assert (relation != null);
1464 return getPossibleObject(relation, processor.querySupport.getResource(processor.getInverseOf()));
1466 } catch (ServiceException e) {
1468 throw new ServiceException(e);
1470 } catch (DatabaseException e) {
1472 throw new ServiceException(INTERNAL_ERROR_STRING, e);
1479 public Resource getPossibleObject(final Resource subject, final Resource relation)
1480 throws ManyObjectsForFunctionalRelationException, ServiceException {
1482 assert (subject != null);
1483 assert (relation != null);
1487 int result = processor.getSingleObject(this, subject, relation);
1488 if(result == 0) return null;
1490 return processor.querySupport.getResource(result);
1492 } catch (ManyObjectsForFunctionalRelationException e) {
1494 throw new ManyObjectsForFunctionalRelationException("subject=" + subject + ", relation=" + relation, e);
1496 } catch (DatabaseException e) {
1498 throw new ServiceException(e);
1505 final public Statement getPossibleStatement(final Resource subject, final Resource relation)
1506 throws ManyObjectsForFunctionalRelationException, ServiceException {
1508 assert (subject != null);
1509 assert (relation != null);
1513 Collection<Statement> statements = getStatements(subject, relation);
1514 if(statements.size() == 1) return statements.iterator().next();
1517 } catch (ManyObjectsForFunctionalRelationException e) {
1519 throw new ManyObjectsForFunctionalRelationException("Many objects in " + subject + " for functional relation " + relation);
1521 } catch (ServiceException e) {
1523 throw new ServiceException(e);
1530 final public Resource getPossibleType(final Resource subject, final Resource baseType) throws ServiceException {
1532 assert (subject != null);
1533 assert (baseType != null);
1537 AsyncReadProcedure<Resource> procedure = new AsyncReadProcedure<Resource>();
1538 forPossibleType(subject, baseType, procedure);
1539 procedure.checkAndThrow();
1540 return procedure.result;
1542 } catch (ServiceException e) {
1544 throw new ServiceException(e);
1546 } catch (DatabaseException e) {
1548 throw new ServiceException(INTERNAL_ERROR_STRING, e);
1555 final public <T> T getPossibleValue(final Resource subject) throws ServiceException {
1557 assert (subject != null);
1561 int object = processor.getSingleObject(this, subject, processor.getL0(this).HasDataType);
1562 if(object == 0) return null;
1564 if(processor.isImmutable(object)) {
1565 Binding binding = syncRequest(new DatatypeBinding(processor.querySupport.getResource(object)), TransientCacheListener.<Binding>instance());
1566 return getPossibleValue(subject, binding);
1568 byte[] dt = processor.getValue(this, object);
1569 if(dt == null) return null;
1570 Datatype datatype = (Datatype)DATA_TYPE_SERIALIZER.deserialize(dt);
1571 Binding binding = Bindings.getBinding(datatype);
1572 return getPossibleValue(subject, binding);
1575 } catch (IOException e) {
1577 throw new ServiceException(e);
1579 } catch (ServiceException e) {
1581 throw new ServiceException(e);
1583 } catch (DatabaseException e) {
1585 throw new ServiceException(INTERNAL_ERROR_STRING, e);
1592 final public <T> T getPossibleValue(final Resource subject, final Binding binding) throws BindingException, ServiceException {
1594 assert (subject != null);
1595 assert (binding != null);
1599 byte[] dt = processor.getValue(this, subject);
1600 if(dt == null) return null;
1601 Serializer serializer = getSerializer(binding);
1602 return (T)serializer.deserialize(dt);
1604 } catch (IOException e) {
1606 throw new ServiceException(e);
1608 } catch (BindingException e) {
1610 throw new BindingException(e);
1612 } catch (ServiceException e) {
1614 throw new ServiceException(e);
1616 } catch (DatabaseException e) {
1617 e.printStackTrace();
1618 throw new ServiceException(INTERNAL_ERROR_STRING, e);
1624 public <T> T getPossibleRelatedValue(final Resource subject, final Resource relation)
1625 throws ManyObjectsForFunctionalRelationException, ServiceException {
1627 assert (subject != null);
1628 assert (relation != null);
1632 Resource object = getPossibleObject(subject, relation);
1633 if(object == null) return null;
1634 else return getPossibleValue(object);
1636 } catch (ManyObjectsForFunctionalRelationException e) {
1638 throw new ManyObjectsForFunctionalRelationException(e);
1640 } catch (ServiceException e) {
1642 throw new ServiceException(e);
1649 public <T> T getPossibleRelatedValue(final Resource subject, final Resource relation, final Binding binding)
1650 throws ManyObjectsForFunctionalRelationException, BindingException, ServiceException {
1652 assert (subject != null);
1653 assert (relation != null);
1654 assert (binding != null);
1658 Resource object = getPossibleObject(subject, relation);
1659 if(object == null) return null;
1660 else return getPossibleValue(object, binding);
1662 } catch (ManyObjectsForFunctionalRelationException e) {
1664 throw new ManyObjectsForFunctionalRelationException(e);
1666 } catch (BindingException e) {
1668 throw new BindingException(e);
1670 } catch (ServiceException e) {
1672 throw new ServiceException(e);
1679 public <T> T getPossibleAdapter(Resource resource, Class<T> clazz) throws ValidationException, ServiceException {
1681 assert (resource != null);
1682 assert (clazz != null);
1686 return syncRequest(new PossibleAdapter<T>(resource, clazz));
1688 } catch (ValidationException e) {
1690 throw new ValidationException(e);
1692 } catch (AdaptionException e) {
1696 } catch (DatabaseException e) {
1698 throw new ServiceException(INTERNAL_ERROR_STRING, e);
1704 public <T> T getPossibleUniqueAdapter(Resource resource, Class<T> clazz) throws ValidationException, ServiceException {
1706 assert (resource != null);
1707 assert (clazz != null);
1711 return syncRequest(new PossibleUniqueAdapter<T>(resource, clazz));
1713 } catch (AdaptionException e) {
1717 } catch (ValidationException e) {
1719 throw new ValidationException(e);
1721 } catch (DatabaseException e) {
1723 throw new ServiceException(INTERNAL_ERROR_STRING, e);
1730 final public boolean isInstanceOf(final Resource resource, final Resource type) throws ServiceException {
1732 assert (resource != null);
1733 assert (type != null);
1735 Set<Resource> resources = getTypes(resource);
1736 // This check was necessary because some of the callers of this method got stuck when the NPE was thrown from here.
1737 if (null == resources)
1740 if(EMPTY_RESOURCE_CHECK) {
1741 if (resources.isEmpty()) {
1742 if(!hasStatement(resource)) throw new EmptyResourceException("Resource " + debugString(resource));
1746 return resources.contains(type);
1751 final public boolean isInheritedFrom(final Resource resource, final Resource type) throws ServiceException {
1753 assert (resource != null);
1754 assert (type != null);
1758 if(resource.equals(type)) return true;
1760 return getSupertypes(resource).contains(type);
1762 } catch (ServiceException e) {
1764 throw new ServiceException(e);
1771 final public boolean isSubrelationOf(final Resource resource, final Resource type) throws ServiceException {
1773 assert (resource != null);
1774 assert (type != null);
1778 if(resource.equals(type)) return true;
1780 return getSuperrelations(resource).contains(type);
1782 } catch (ServiceException e) {
1784 throw new ServiceException(e);
1791 final public boolean hasStatement(final Resource subject) throws ServiceException {
1793 assert (subject != null);
1797 SyncReadProcedure<Boolean> procedure = new SyncReadProcedure<Boolean>();
1798 processor.forHasStatement(this, subject, procedure);
1799 procedure.checkAndThrow();
1800 return procedure.result;
1802 } catch (ServiceException e) {
1804 throw new ServiceException(e);
1806 } catch (DatabaseException e) {
1808 throw new ServiceException(INTERNAL_ERROR_STRING, e);
1815 final public boolean hasStatement(final Resource subject, final Resource relation) throws ServiceException {
1817 assert (subject != null);
1818 assert (relation != null);
1822 Collection<Resource> objects = getObjects(subject, relation);
1823 return !objects.isEmpty();
1825 } catch (ServiceException e) {
1827 throw new ServiceException(e);
1834 final public boolean hasStatement(final Resource subject, final Resource relation, final Resource object) throws ServiceException {
1836 assert (subject != null);
1837 assert (relation != null);
1838 assert (object != null);
1842 for(Resource o : getObjects(subject, relation)) {
1843 if(object.equals(o)) return true;
1848 } catch (ServiceException e) {
1850 throw new ServiceException(e);
1857 final public boolean hasValue(final Resource subject) throws ServiceException {
1859 assert (subject != null);
1863 SyncReadProcedure<Boolean> procedure = new SyncReadProcedure<Boolean>();
1864 processor.forHasValue(this, subject, procedure);
1865 procedure.checkAndThrow();
1866 return procedure.result;
1868 } catch (ServiceException e) {
1870 throw new ServiceException(e);
1872 } catch (DatabaseException e) {
1874 throw new ServiceException(INTERNAL_ERROR_STRING, e);
1880 final AsyncProcedure<?> NONE = new AsyncProcedure<Object>() {
1883 public void execute(AsyncReadGraph graph, Object result) {
1887 public void exception(AsyncReadGraph graph, Throwable throwable) {
1893 * Implementation of the interface RequestProcessor
1897 public <T> T syncRequest(final Read<T> request) throws DatabaseException {
1899 assert (request != null);
1901 return QueryCache.resultReadEntry(this, request, parent, null, null);
1903 //return processor.query(this, request, parent, null, null);
1905 // if (parent != null) {
1908 // } catch (Throwable e) {
1909 // if(e instanceof DatabaseException) throw (DatabaseException)e;
1910 // else throw new DatabaseException(e);
1917 // return processor.tryQuery(this, request);
1919 // } catch (Throwable throwable) {
1921 // //Logger.defaultLogError("Internal read request failure", throwable);
1923 // if (throwable instanceof DatabaseException)
1924 // throw (DatabaseException) throwable;
1926 // throw new DatabaseException(
1927 // "Unexpected exception in ReadGraph.syncRequest(Read,Procedure)",
1937 public <T> T syncRequest(Read<T> request, SyncListener<T> procedure)
1938 throws DatabaseException {
1939 return syncRequest(request, new SyncToAsyncListener<T>(procedure));
1943 public <T> T syncRequest(Read<T> request, final Listener<T> procedure)
1944 throws DatabaseException {
1945 return syncRequest(request, new NoneToAsyncListener<T>(procedure));
1949 public <T> T syncRequest(final Read<T> request, final AsyncProcedure<T> procedure) throws DatabaseException {
1951 assert (request != null);
1953 ListenerBase listener = procedure != null ? getListenerBase(procedure) : null;
1955 return QueryCache.resultReadEntry(this, request, parent, listener, procedure);
1957 // return processor.query(this, request, parent, procedure, listener);
1960 // if (parent != null || listener != null) {
1963 // } catch (Throwable e) {
1964 // if(e instanceof DatabaseException) throw (DatabaseException)e;
1965 // else throw new DatabaseException(e);
1972 // T t = processor.tryQuery(this, request);
1973 // if(procedure != null)
1974 // procedure.execute(this, t);
1978 // } catch (Throwable throwable) {
1980 // Logger.defaultLogError("Internal read request failure", throwable);
1982 // if(procedure != null)
1983 // procedure.exception(this, throwable);
1985 // if (throwable instanceof DatabaseException)
1986 // throw (DatabaseException) throwable;
1988 // throw new DatabaseException(
1989 // "Unexpected exception in ReadGraph.syncRequest(Read,Procedure)",
1999 public <T> T syncRequest(final Read<T> request,
2000 final SyncProcedure<T> procedure) throws DatabaseException {
2001 return syncRequest(request, new SyncToAsyncProcedure<T>(procedure));
2005 public <T> T syncRequest(Read<T> request, Procedure<T> procedure)
2006 throws DatabaseException {
2007 return syncRequest(request, new NoneToAsyncProcedure<T>(procedure));
2010 static class AsyncReadProcedure<T> implements AsyncProcedure<T> {
2012 private static Throwable DONE = new Throwable();
2015 Throwable exception = null;
2018 public void execute(AsyncReadGraph graph, T t) {
2024 public void exception(AsyncReadGraph graph, Throwable t) {
2028 public void checkAndThrow() throws DatabaseException {
2029 if(exception != DONE) {
2030 if (exception instanceof DatabaseException)
2031 throw (DatabaseException) exception;
2033 throw new DatabaseException(
2034 "Unexpected exception in ReadGraph.syncRequest(AsyncMultiRead)",
2039 public boolean done() {
2040 return exception != null;
2046 public <T> T syncRequest(final AsyncRead<T> request)
2047 throws DatabaseException {
2049 assert (request != null);
2050 AsyncReadProcedure<T> procedure = new AsyncReadProcedure<T>();
2051 syncRequest(request, procedure);
2052 procedure.checkAndThrow();
2053 return procedure.result;
2055 // return syncRequest(request, new AsyncProcedureAdapter<T>());
2060 public <T> T syncRequest(AsyncRead<T> request, AsyncListener<T> procedure)
2061 throws DatabaseException {
2062 return syncRequest(request, (AsyncProcedure<T>) procedure);
2066 public <T> T syncRequest(AsyncRead<T> request, SyncListener<T> procedure)
2067 throws DatabaseException {
2068 return syncRequest(request, new SyncToAsyncListener<T>(procedure));
2072 public <T> T syncRequest(AsyncRead<T> request, Listener<T> procedure)
2073 throws DatabaseException {
2074 return syncRequest(request, new NoneToAsyncListener<T>(procedure));
2078 final public <T> T syncRequest(final AsyncRead<T> request,
2079 final AsyncProcedure<T> procedure) throws DatabaseException {
2081 assert (request != null);
2083 ListenerBase listener = getListenerBase(procedure);
2085 final ResultCallWrappedSingleQueryProcedure4<T> wrapper = new ResultCallWrappedSingleQueryProcedure4<T>(
2086 procedure, request);
2088 QueryCache.runnerAsyncReadEntry(this, request, parent, listener, wrapper);
2090 //processor.query(this, request, parent, wrapper, listener);
2092 return wrapper.getResult();
2094 // if (parent != null || listener != null || ((request.getFlags() & RequestFlags.SCHEDULE) > 0)) {
2096 //// Object syncParent = request;
2098 //// final ReadGraphImpl newGraph = newSync();
2101 //// newGraph.waitAsync(syncParent);
2103 // Throwable e = wrapper.getException();
2105 // // The request was async - produce meaningful stack trace by
2107 // if (e instanceof DatabaseException)
2108 // throw (DatabaseException) e;
2110 // throw new DatabaseException(e);
2113 // return wrapper.getResult();
2117 // // System.out.println("direct call " + request );
2119 // // Do not set the sync state.parent for external threads
2120 //// Object syncParent = request;
2122 //// final ReadGraphImpl newGraph = newSync();
2124 // final ResultCallWrappedSingleQueryProcedure4<T> wrapper = new ResultCallWrappedSingleQueryProcedure4<T>(
2125 // procedure, request);
2129 // processor.tryQuery(this, request, wrapper);
2131 // } catch (Throwable t) {
2133 // wrapper.exception(this, t);
2137 // Throwable e = wrapper.getException();
2139 // // The request was async - produce meaningful stack trace by
2141 // if (e instanceof DatabaseException)
2142 // throw (DatabaseException) e;
2144 // throw new DatabaseException(e);
2147 // return wrapper.getResult();
2153 final private <T> void syncRequest(final AsyncRead<T> request, final AsyncReadProcedure<T> procedure) throws DatabaseException {
2155 assert (request != null);
2157 ListenerBase listener = getListenerBase(procedure);
2158 assert(listener == null);
2160 // final ResultCallWrappedSingleQueryProcedure4<T> wrapper = new ResultCallWrappedSingleQueryProcedure4<T>(
2161 // procedure, request);
2163 QueryCache.runnerAsyncReadEntry(this, request, parent, listener, procedure);
2168 public <T> T syncRequest(AsyncRead<T> request,
2169 final SyncProcedure<T> procedure) throws DatabaseException {
2170 return syncRequest(request, new SyncToAsyncProcedure<T>(procedure));
2174 final public <T> T syncRequest(final AsyncRead<T> request,
2175 final Procedure<T> procedure) throws DatabaseException {
2176 return syncRequest(request, new NoneToAsyncProcedure<T>(procedure));
2180 public <T> Collection<T> syncRequest(final MultiRead<T> request)
2181 throws DatabaseException {
2183 assert (request != null);
2185 final ArrayList<T> result = new ArrayList<T>();
2186 final DataContainer<Throwable> exception = new DataContainer<Throwable>();
2188 syncRequest(request, new AsyncMultiProcedure<T>() {
2191 public void execute(AsyncReadGraph graph, T t) {
2192 synchronized (result) {
2198 public void finished(AsyncReadGraph graph) {
2202 public void exception(AsyncReadGraph graph, Throwable t) {
2207 public String toString() {
2208 return "syncRequest(MultiRead) -> " + request;
2213 Throwable t = exception.get();
2215 if (t instanceof DatabaseException)
2216 throw (DatabaseException) t;
2218 throw new DatabaseException(
2219 "Unexpected exception in ReadGraph.syncRequest(Read)",
2228 public <T> Collection<T> syncRequest(MultiRead<T> request,
2229 AsyncMultiListener<T> procedure) {
2230 return syncRequest(request, (AsyncMultiProcedure<T>) procedure);
2234 public <T> Collection<T> syncRequest(MultiRead<T> request,
2235 SyncMultiListener<T> procedure) {
2236 return syncRequest(request, new SyncToAsyncMultiListener<T>(procedure));
2240 public <T> Collection<T> syncRequest(MultiRead<T> request,
2241 MultiListener<T> procedure) {
2242 return syncRequest(request, new NoneToAsyncMultiListener<T>(procedure));
2246 public <T> Collection<T> syncRequest(MultiRead<T> request,
2247 AsyncMultiProcedure<T> procedure) {
2249 assert (request != null);
2251 ListenerBase listener = getListenerBase(procedure);
2253 if (parent != null || listener != null) {
2255 // Object syncParent = request;
2257 // final ReadGraphImpl newGraph = newSync();
2259 processor.query(this, request, parent, procedure, listener);
2261 // newGraph.waitAsync(syncParent);
2265 // Object syncParent = request;
2267 // final ReadGraphImpl newGraph = newSync();
2269 final ResultCallWrappedQueryProcedure4<T> wrapper = new ResultCallWrappedQueryProcedure4<T>(procedure);
2273 request.perform(this, wrapper);
2275 } catch (Throwable t) {
2277 wrapper.exception(this, t);
2278 // newGraph.waitAsync(syncParent);
2290 public <T> Collection<T> syncRequest(MultiRead<T> request,
2291 SyncMultiProcedure<T> procedure) {
2292 return syncRequest(request, new SyncToAsyncMultiProcedure<T>(procedure));
2296 public <T> Collection<T> syncRequest(MultiRead<T> request,
2297 MultiProcedure<T> procedure) {
2298 return syncRequest(request, new NoneToAsyncMultiProcedure<T>(procedure));
2301 static class AsyncMultiReadProcedure<T> extends ArrayList<T> implements AsyncMultiProcedure<T> {
2303 private static Throwable DONE = new Throwable();
2305 private static final long serialVersionUID = -6494230465108115812L;
2307 Throwable exception = null;
2310 public synchronized void execute(AsyncReadGraph graph, T t) {
2315 public void finished(AsyncReadGraph graph) {
2320 public void exception(AsyncReadGraph graph, Throwable t) {
2324 public void checkAndThrow() throws DatabaseException {
2325 if(exception != DONE) {
2326 if (exception instanceof DatabaseException)
2327 throw (DatabaseException) exception;
2329 throw new DatabaseException(
2330 "Unexpected exception in ReadGraph.syncRequest(AsyncMultiRead)",
2335 public boolean done() {
2336 return exception != null;
2342 final public <T> Collection<T> syncRequest(AsyncMultiRead<T> request)
2343 throws DatabaseException {
2345 assert (request != null);
2347 final AsyncMultiReadProcedure<T> procedure = new AsyncMultiReadProcedure<T>();
2349 syncRequest(request, procedure);
2351 procedure.checkAndThrow();
2357 public <T> Collection<T> syncRequest(AsyncMultiRead<T> request,
2358 AsyncMultiListener<T> procedure) {
2359 return syncRequest(request, (AsyncMultiProcedure<T>) procedure);
2363 public <T> Collection<T> syncRequest(AsyncMultiRead<T> request,
2364 SyncMultiListener<T> procedure) {
2365 return syncRequest(request, new SyncToAsyncMultiListener<T>(procedure));
2369 public <T> Collection<T> syncRequest(AsyncMultiRead<T> request,
2370 MultiListener<T> procedure) {
2371 return syncRequest(request, new NoneToAsyncMultiListener<T>(procedure));
2374 final private <T> void syncRequest(final AsyncMultiRead<T> request,
2375 final AsyncMultiReadProcedure<T> procedure) {
2377 assert (request != null);
2378 assert (procedure != null);
2380 ListenerBase listener = getListenerBase(procedure);
2382 if (parent != null || listener != null) {
2384 // Object syncParent = request;
2386 // final ReadGraphImpl newGraph = newSync();
2388 processor.query(this, request, parent, procedure, listener);
2390 // newGraph.waitAsync(syncParent);
2391 waitAsyncProcedure(procedure);
2395 // Object syncParent = callerThread == Integer.MIN_VALUE ? null
2398 // final ReadGraphImpl newGraph = newSyncAsync(syncParent);
2403 // ReadGraphImpl sync = newSync();
2404 request.perform(this, procedure);
2405 // sync.waitAsync(null);
2406 waitAsyncProcedure(procedure);
2409 } catch (Throwable t) {
2411 waitAsyncProcedure(procedure);
2422 final public <T> Collection<T> syncRequest(final AsyncMultiRead<T> request,
2423 final AsyncMultiProcedure<T> procedure) {
2425 assert (request != null);
2426 assert (procedure != null);
2428 ListenerBase listener = getListenerBase(procedure);
2430 if (parent != null || listener != null) {
2432 // Object syncParent = request;
2434 // final ReadGraphImpl newGraph = newSync();
2436 processor.query(this, request, parent, procedure, listener);
2438 // newGraph.waitAsync(syncParent);
2442 // Object syncParent = request;
2444 // final ReadGraphImpl newGraph = newSync();
2448 request.perform(this, new AsyncMultiProcedure<T>() {
2451 public void execute(AsyncReadGraph graph, T result) {
2452 procedure.execute(graph, result);
2456 public void finished(AsyncReadGraph graph) {
2457 procedure.finished(graph);
2461 public void exception(AsyncReadGraph graph, Throwable t) {
2462 procedure.exception(graph, t);
2466 public String toString() {
2467 return "syncRequest(AsyncMultiRead) -> " + procedure;
2472 } catch (Throwable t) {
2484 public <T> Collection<T> syncRequest(AsyncMultiRead<T> request,
2485 final SyncMultiProcedure<T> procedure) {
2486 return syncRequest(request, new SyncToAsyncMultiProcedure<T>(procedure));
2490 final public <T> Collection<T> syncRequest(final AsyncMultiRead<T> request,
2491 final MultiProcedure<T> procedure) {
2492 return syncRequest(request, new NoneToAsyncMultiProcedure<T>(procedure));
2496 public <T> T syncRequest(final ExternalRead<T> request)
2497 throws DatabaseException {
2499 assert (request != null);
2501 return syncRequest(request, new Procedure<T>() {
2504 public void execute(T t) {
2508 public void exception(Throwable t) {
2512 public String toString() {
2513 return "syncRequest(AsyncRead) -> " + request;
2521 public <T> T syncRequest(ExternalRead<T> request, Listener<T> procedure) throws DatabaseException {
2522 return syncRequest(request, (Procedure<T>) procedure);
2526 final public <T> T syncRequest(final ExternalRead<T> request,
2527 final Procedure<T> procedure) throws DatabaseException {
2529 assert (request != null);
2531 ListenerBase listener = getListenerBase(procedure);
2533 final DataContainer<Throwable> exception = new DataContainer<Throwable>();
2534 final DataContainer<T> result = new DataContainer<T>();
2536 processor.query(this, request, parent, new Procedure<T>() {
2539 public void exception(Throwable throwable) {
2540 exception.set(throwable);
2541 procedure.exception(throwable);
2545 public void execute(T t) {
2547 procedure.execute(t);
2554 // if (parent != null || listener != null) {
2556 //// final ReadGraphImpl newGraph = newSync();
2559 //// newGraph.waitAsync(request);
2565 // T t = processor.tryQuery(this, request);
2567 // procedure.execute(t);
2569 // } catch (Throwable t) {
2571 // if (t instanceof DatabaseException) {
2572 // exception.set((DatabaseException)t);
2573 // procedure.exception(exception.get());
2575 // exception.set(new DatabaseException(
2576 // "Unexpected exception in ReadGraph.syncRequest(Read)",
2578 // procedure.exception(exception.get());
2585 Throwable t = exception.get();
2587 if (t instanceof DatabaseException)
2588 throw (DatabaseException) t;
2590 throw new DatabaseException(
2591 "Unexpected exception in ReadGraph.syncRequest(Read)",
2595 return result.get();
2600 public void syncRequest(final Write request) throws DatabaseException {
2602 assert (request != null);
2604 throw new DatabaseException(
2605 "Write operations are not supported during read transactions!");
2610 public <T> T syncRequest(final WriteResult<T> request) throws DatabaseException {
2612 assert (request != null);
2614 throw new DatabaseException(
2615 "Write operations are not supported during read transactions!");
2620 public void syncRequest(final DelayedWrite request)
2621 throws DatabaseException {
2623 assert (request != null);
2625 throw new DatabaseException(
2626 "Write operations are not supported during read transactions!");
2631 public <T> T syncRequest(final DelayedWriteResult<T> request) throws DatabaseException {
2633 assert (request != null);
2635 throw new DatabaseException(
2636 "Write operations are not supported during read transactions!");
2641 public void syncRequest(final WriteOnly request) throws DatabaseException {
2643 assert (request != null);
2645 throw new DatabaseException(
2646 "Write operations are not supported during read transactions!");
2651 public <T> T syncRequest(final WriteOnlyResult<T> request) throws DatabaseException {
2653 assert (request != null);
2655 throw new DatabaseException(
2656 "Write operations are not supported during read transactions!");
2661 public <T> void async(ReadInterface<T> r, AsyncProcedure<T> procedure) {
2662 r.request(this, procedure);
2666 public <T> void async(ReadInterface<T> r, Procedure<T> procedure) {
2667 r.request(this, procedure);
2671 public <T> void async(ReadInterface<T> r, SyncProcedure<T> procedure) {
2672 r.request(this, procedure);
2676 public <T> void async(ReadInterface<T> r, AsyncListener<T> procedure) {
2677 r.request(this, procedure);
2681 public <T> void async(ReadInterface<T> r, Listener<T> procedure) {
2682 r.request(this, procedure);
2686 public <T> void async(ReadInterface<T> r, SyncListener<T> procedure) {
2687 r.request(this, procedure);
2691 public <T> T sync(ReadInterface<T> r) throws DatabaseException {
2692 return r.request(this);
2696 public <T> T sync(WriteInterface<T> r) throws DatabaseException {
2697 return r.request(this);
2701 public <T> void async(WriteInterface<T> r, Procedure<T> procedure) {
2702 r.request(this, procedure);
2706 public <T> void async(WriteInterface<T> r) {
2707 r.request(this, new ProcedureAdapter<T>());
2711 * Implementation of the interface AsyncReadGraph
2715 public void forURI(Resource resource, AsyncListener<String> listener) {
2716 asyncRequest(new org.simantics.db.common.uri.ResourceToURI(resource),
2721 public void forURI(Resource resource, SyncListener<String> listener) {
2722 asyncRequest(new org.simantics.db.common.uri.ResourceToURI(resource),
2727 public void forURI(Resource resource, Listener<String> listener) {
2728 asyncRequest(new org.simantics.db.common.uri.ResourceToURI(resource),
2733 final public void forURI(final Resource resource,
2734 final AsyncProcedure<String> procedure) {
2736 assert (resource != null);
2737 assert (procedure != null);
2739 asyncRequest(new org.simantics.db.common.uri.ResourceToURI(resource),
2745 public void forURI(Resource resource, SyncProcedure<String> procedure) {
2746 forURI(resource, new SyncToAsyncProcedure<String>(procedure));
2750 public void forURI(Resource resource, Procedure<String> procedure) {
2751 forURI(resource, new NoneToAsyncProcedure<String>(procedure));
2755 public void forResource(String id, AsyncListener<Resource> listener) {
2756 asyncRequest(new org.simantics.db.common.primitiverequest.Resource(id),
2761 public void forResource(String id, SyncListener<Resource> listener) {
2762 asyncRequest(new org.simantics.db.common.primitiverequest.Resource(id),
2767 public void forResource(String id, Listener<Resource> listener) {
2768 asyncRequest(new org.simantics.db.common.primitiverequest.Resource(id),
2773 final public void forResource(final String id,
2774 final AsyncProcedure<Resource> procedure) {
2776 assert (id != null);
2777 assert (procedure != null);
2779 processor.forResource(this, id, procedure);
2784 public void forResource(String id, SyncProcedure<Resource> procedure) {
2785 forResource(id, new SyncToAsyncProcedure<Resource>(procedure));
2789 public void forResource(String id, Procedure<Resource> procedure) {
2790 forResource(id, new NoneToAsyncProcedure<Resource>(procedure));
2794 public void forBuiltin(String id, AsyncListener<Resource> listener) {
2795 asyncRequest(new Builtin(id), listener);
2799 public void forBuiltin(String id, SyncListener<Resource> listener) {
2800 asyncRequest(new Builtin(id), listener);
2804 public void forBuiltin(String id, Listener<Resource> listener) {
2805 asyncRequest(new Builtin(id), listener);
2809 final public void forBuiltin(final String id,
2810 final AsyncProcedure<Resource> procedure) {
2812 assert (id != null);
2813 assert (procedure != null);
2815 processor.forBuiltin(this, id, procedure);
2820 public void forBuiltin(String id, SyncProcedure<Resource> procedure) {
2821 forBuiltin(id, new SyncToAsyncProcedure<Resource>(procedure));
2825 public void forBuiltin(String id, Procedure<Resource> procedure) {
2826 forBuiltin(id, new NoneToAsyncProcedure<Resource>(procedure));
2830 final public void forEachStatement(Resource subject, Resource relation,
2831 AsyncMultiProcedure<Statement> procedure) {
2833 assert (subject != null);
2834 assert (relation != null);
2835 assert (procedure != null);
2837 processor.forEachStatement(this, subject, relation, procedure);
2842 public void forEachStatement(Resource subject, Resource relation,
2843 SyncMultiProcedure<Statement> procedure) {
2844 forEachStatement(subject, relation,
2845 new SyncToAsyncMultiProcedure<Statement>(procedure));
2849 final public void forEachStatement(Resource subject, Resource relation,
2850 MultiProcedure<Statement> procedure) {
2852 assert (subject != null);
2853 assert (relation != null);
2854 assert (procedure != null);
2856 processor.forEachStatement(this, subject, relation, procedure);
2861 final public void forStatementSet(Resource subject, Resource relation,
2862 AsyncSetListener<Statement> procedure) {
2864 assert (subject != null);
2865 assert (relation != null);
2866 assert (procedure != null);
2868 processor.forStatementSet(this, subject, relation, procedure);
2873 final public void forStatementSet(Resource subject, Resource relation,
2874 SyncSetListener<Statement> procedure) {
2875 forStatementSet(subject, relation,
2876 new SyncToAsyncSetProcedure<Statement>(procedure));
2880 public void forStatementSet(Resource subject, Resource relation,
2881 SetListener<Statement> listener) {
2882 forStatementSet(subject, relation,
2883 new NoneToAsyncSetProcedure<Statement>(listener));
2887 final public void forEachAssertedStatement(final Resource subject,
2888 final Resource relation,
2889 final AsyncMultiProcedure<Statement> procedure) {
2891 assert (subject != null);
2892 assert (relation != null);
2893 assert (procedure != null);
2895 processor.forEachAssertedStatement(this, subject, relation, procedure);
2900 public void forEachAssertedStatement(Resource subject, Resource relation,
2901 SyncMultiProcedure<Statement> procedure) {
2902 forEachAssertedStatement(subject, relation,
2903 new SyncToAsyncMultiProcedure<Statement>(procedure));
2907 public void forEachAssertedStatement(Resource subject, Resource relation,
2908 MultiProcedure<Statement> procedure) {
2909 forEachAssertedStatement(subject, relation,
2910 new NoneToAsyncMultiProcedure<Statement>(procedure));
2914 public void forAssertedStatementSet(Resource subject, Resource relation,
2915 AsyncSetListener<Statement> procedure) {
2917 assert (subject != null);
2918 assert (relation != null);
2919 assert (procedure != null);
2921 processor.forAssertedStatementSet(this, subject, relation, procedure);
2926 public void forAssertedStatementSet(Resource subject, Resource relation,
2927 SyncSetListener<Statement> procedure) {
2929 assert (subject != null);
2930 assert (relation != null);
2931 assert (procedure != null);
2933 forAssertedStatementSet(subject, relation,
2934 new SyncToAsyncSetProcedure<Statement>(procedure));
2939 public void forAssertedStatementSet(Resource subject, Resource relation,
2940 SetListener<Statement> procedure) {
2942 assert (subject != null);
2943 assert (relation != null);
2944 assert (procedure != null);
2946 forAssertedStatementSet(subject, relation,
2947 new NoneToAsyncSetProcedure<Statement>(procedure));
2952 final public void forEachPredicate(final Resource subject,
2953 final AsyncMultiProcedure<Resource> procedure) {
2955 assert (subject != null);
2956 assert (procedure != null);
2958 processor.forEachPredicate(this, subject, procedure);
2963 public void forEachPredicate(Resource subject,
2964 SyncMultiProcedure<Resource> procedure) {
2965 forEachPredicate(subject, new SyncToAsyncMultiProcedure<Resource>(
2970 final public void forEachPredicate(final Resource subject,
2971 final MultiProcedure<Resource> procedure) {
2973 assert (subject != null);
2974 assert (procedure != null);
2976 processor.forEachPredicate(this, subject, procedure);
2981 final public void forPredicateSet(final Resource subject,
2982 final AsyncSetListener<Resource> procedure) {
2984 assert (subject != null);
2985 assert (procedure != null);
2987 processor.forPredicateSet(this, subject, procedure);
2992 final public void forPredicateSet(final Resource subject,
2993 final SyncSetListener<Resource> procedure) {
2995 assert (subject != null);
2996 assert (procedure != null);
2998 forPredicateSet(subject, new SyncToAsyncSetProcedure<Resource>(
3004 final public void forPredicateSet(final Resource subject,
3005 final SetListener<Resource> procedure) {
3007 assert (subject != null);
3008 assert (procedure != null);
3010 forPredicateSet(subject, new NoneToAsyncSetProcedure<Resource>(
3016 final public void forEachPrincipalType(final Resource subject,
3017 final AsyncMultiProcedure<Resource> procedure) {
3019 assert (subject != null);
3020 assert (procedure != null);
3022 processor.forEachPrincipalType(this, subject, procedure);
3027 public void forEachPrincipalType(Resource subject,
3028 SyncMultiProcedure<Resource> procedure) {
3029 forEachPrincipalType(subject, new SyncToAsyncMultiProcedure<Resource>(
3034 final public void forEachPrincipalType(final Resource subject,
3035 final MultiProcedure<Resource> procedure) {
3037 assert (subject != null);
3038 assert (procedure != null);
3040 processor.forEachPrincipalType(this, subject, procedure);
3045 final public void forPrincipalTypeSet(final Resource subject,
3046 final AsyncSetListener<Resource> procedure) {
3048 assert (subject != null);
3049 assert (procedure != null);
3051 processor.forPrincipalTypeSet(this, subject, procedure);
3056 final public void forPrincipalTypeSet(final Resource subject,
3057 final SyncSetListener<Resource> procedure) {
3059 assert (subject != null);
3060 assert (procedure != null);
3062 forPrincipalTypeSet(subject, new SyncToAsyncSetProcedure<Resource>(
3068 final public void forPrincipalTypeSet(final Resource subject,
3069 final SetListener<Resource> procedure) {
3071 assert (subject != null);
3072 assert (procedure != null);
3074 forPrincipalTypeSet(subject, new NoneToAsyncSetProcedure<Resource>(
3080 public void forTypes(Resource subject, AsyncListener<Set<Resource>> listener) {
3081 asyncRequest(new Types(subject), listener);
3085 public void forTypes(Resource subject, SyncListener<Set<Resource>> listener) {
3086 asyncRequest(new Types(subject), listener);
3090 public void forTypes(Resource subject, Listener<Set<Resource>> listener) {
3091 asyncRequest(new Types(subject), listener);
3095 final public void forTypes(final Resource subject,
3096 final AsyncProcedure<Set<Resource>> procedure) {
3098 assert (subject != null);
3099 assert (procedure != null);
3101 processor.forTypes(this, subject, procedure);
3106 public void forTypes(Resource subject,
3107 SyncProcedure<Set<Resource>> procedure) {
3108 forTypes(subject, new SyncToAsyncProcedure<Set<Resource>>(procedure));
3112 public void forTypes(Resource subject, Procedure<Set<Resource>> procedure) {
3113 forTypes(subject, new NoneToAsyncProcedure<Set<Resource>>(procedure));
3117 public void forSupertypes(Resource subject,
3118 AsyncListener<Set<Resource>> listener) {
3119 asyncRequest(new Types(subject), listener);
3123 public void forSupertypes(Resource subject,
3124 SyncListener<Set<Resource>> listener) {
3125 asyncRequest(new Types(subject), listener);
3129 public void forSupertypes(Resource subject, Listener<Set<Resource>> listener) {
3130 asyncRequest(new Types(subject), listener);
3134 final public void forSupertypes(final Resource subject,
3135 final AsyncProcedure<Set<Resource>> procedure) {
3137 assert (subject != null);
3138 assert (procedure != null);
3140 processor.forSupertypes(this, subject, procedure);
3145 public void forSupertypes(Resource subject,
3146 SyncProcedure<Set<Resource>> procedure) {
3147 forSupertypes(subject, new SyncToAsyncProcedure<Set<Resource>>(
3152 public void forSupertypes(Resource subject,
3153 Procedure<Set<Resource>> procedure) {
3154 forSupertypes(subject, new NoneToAsyncProcedure<Set<Resource>>(
3159 public void forDirectSuperrelations(Resource subject,
3160 AsyncMultiProcedure<Resource> procedure) {
3162 assert (subject != null);
3163 assert (procedure != null);
3165 processor.forDirectSuperrelations(this, subject, procedure);
3170 public void forPossibleSuperrelation(Resource subject, AsyncProcedure<Resource> procedure) {
3172 assert (subject != null);
3173 assert (procedure != null);
3175 processor.forPossibleSuperrelation(this, subject, procedure);
3180 public void forSuperrelations(Resource subject,
3181 AsyncListener<Set<Resource>> listener) {
3182 asyncRequest(new Types(subject), listener);
3186 public void forSuperrelations(Resource subject,
3187 SyncListener<Set<Resource>> listener) {
3188 asyncRequest(new Types(subject), listener);
3192 public void forSuperrelations(Resource subject,
3193 Listener<Set<Resource>> listener) {
3194 asyncRequest(new Types(subject), listener);
3198 final public void forSuperrelations(final Resource subject,
3199 final AsyncProcedure<Set<Resource>> procedure) {
3201 assert (subject != null);
3202 assert (procedure != null);
3204 processor.forSuperrelations(this, subject, procedure);
3209 public void forSuperrelations(Resource subject,
3210 SyncProcedure<Set<Resource>> procedure) {
3211 forSuperrelations(subject, new SyncToAsyncProcedure<Set<Resource>>(
3216 public void forSuperrelations(Resource subject,
3217 Procedure<Set<Resource>> procedure) {
3218 forSuperrelations(subject, new NoneToAsyncProcedure<Set<Resource>>(
3223 final public void forEachObject(final Resource subject, final Resource relation, final AsyncMultiProcedure<Resource> procedure) {
3224 processor.forEachObject(this, subject, relation, procedure);
3228 public void forEachObject(Resource subject, Resource relation,
3229 SyncMultiProcedure<Resource> procedure) {
3230 forEachObject(subject, relation,
3231 new SyncToAsyncMultiProcedure<Resource>(procedure));
3235 public void forEachObject(Resource subject, Resource relation,
3236 MultiProcedure<Resource> procedure) {
3238 processor.forEachObject(this, subject, relation, procedure);
3243 // final public void forEachDirectObject(final Resource subject,
3244 // final Resource relation,
3245 // final AsyncMultiProcedure<Resource> procedure) {
3247 // processor.forEachDirectObject(this, subject, relation, procedure);
3252 // public void forEachDirectObject(Resource subject, Resource relation,
3253 // SyncMultiProcedure<Resource> procedure) {
3254 // forEachDirectObject(subject, relation,
3255 // new SyncToAsyncMultiProcedure<Resource>(procedure));
3259 // public void forEachDirectObject(Resource subject, Resource relation,
3260 // MultiProcedure<Resource> procedure) {
3261 // forEachDirectObject(subject, relation,
3262 // new NoneToAsyncMultiProcedure<Resource>(procedure));
3266 final public void forEachDirectPredicate(final Resource subject, final AsyncMultiProcedure<Resource> procedure) {
3267 processor.forEachDirectPredicate(this, subject, procedure);
3271 public void forEachDirectPredicate(Resource subject, SyncMultiProcedure<Resource> procedure) {
3272 forEachDirectPredicate(subject, new SyncToAsyncMultiProcedure<Resource>(procedure));
3276 public void forEachDirectPredicate(Resource subject, MultiProcedure<Resource> procedure) {
3277 forEachDirectPredicate(subject, new NoneToAsyncMultiProcedure<Resource>(procedure));
3281 final public void forObjectSet(final Resource subject,
3282 final Resource relation, final AsyncSetListener<Resource> procedure) {
3284 assert (subject != null);
3285 assert (relation != null);
3286 assert (procedure != null);
3288 processor.forObjectSet(this, subject, relation, procedure);
3293 final public void forObjectSet(final Resource subject,
3294 final Resource relation, final SyncSetListener<Resource> procedure) {
3296 assert (subject != null);
3297 assert (relation != null);
3298 assert (procedure != null);
3300 forObjectSet(subject, relation, new SyncToAsyncSetProcedure<Resource>(
3306 final public void forObjectSet(final Resource subject,
3307 final Resource relation, final SetListener<Resource> procedure) {
3309 assert (subject != null);
3310 assert (relation != null);
3311 assert (procedure != null);
3313 forObjectSet(subject, relation, new NoneToAsyncSetProcedure<Resource>(
3319 final public void forEachAssertedObject(final Resource subject,
3320 final Resource relation,
3321 final AsyncMultiProcedure<Resource> procedure) {
3323 assert (subject != null);
3324 assert (relation != null);
3325 assert (procedure != null);
3327 processor.forEachAssertedObject(this, subject, relation, procedure);
3332 public void forEachAssertedObject(Resource subject, Resource relation,
3333 SyncMultiProcedure<Resource> procedure) {
3335 assert (subject != null);
3336 assert (relation != null);
3337 assert (procedure != null);
3339 forEachAssertedObject(subject, relation,
3340 new SyncToAsyncMultiProcedure<Resource>(procedure));
3345 public void forEachAssertedObject(Resource subject, Resource relation,
3346 MultiProcedure<Resource> procedure) {
3348 assert (subject != null);
3349 assert (relation != null);
3350 assert (procedure != null);
3352 forEachAssertedObject(subject, relation,
3353 new NoneToAsyncMultiProcedure<Resource>(procedure));
3358 public void forAssertedObjectSet(Resource subject, Resource relation,
3359 AsyncSetListener<Resource> procedure) {
3361 assert (subject != null);
3362 assert (relation != null);
3363 assert (procedure != null);
3365 processor.forAssertedObjectSet(this, subject, relation, procedure);
3370 public void forAssertedObjectSet(Resource subject, Resource relation,
3371 SyncSetListener<Resource> procedure) {
3373 assert (subject != null);
3374 assert (relation != null);
3375 assert (procedure != null);
3377 forAssertedObjectSet(subject, relation,
3378 new SyncToAsyncSetProcedure<Resource>(procedure));
3383 public void forAssertedObjectSet(Resource subject, Resource relation,
3384 SetListener<Resource> procedure) {
3386 assert (subject != null);
3387 assert (relation != null);
3388 assert (procedure != null);
3390 forAssertedObjectSet(subject, relation,
3391 new NoneToAsyncSetProcedure<Resource>(procedure));
3396 public void forInverse(Resource relation, AsyncListener<Resource> listener) {
3397 asyncRequest(new Inverse(relation), listener);
3401 public void forInverse(Resource relation, SyncListener<Resource> listener) {
3402 asyncRequest(new Inverse(relation), listener);
3406 public void forInverse(Resource relation, Listener<Resource> listener) {
3407 asyncRequest(new Inverse(relation), listener);
3411 final public void forInverse(final Resource relation,
3412 final AsyncProcedure<Resource> procedure) {
3414 assert (relation != null);
3415 assert (procedure != null);
3417 processor.forInverse(this, relation, new AsyncProcedure<Resource>() {
3420 public void execute(AsyncReadGraph graph, Resource result) {
3422 procedure.execute(graph, result);
3424 procedure.exception(graph, new NoInverseException(relation
3430 public void exception(AsyncReadGraph graph, Throwable throwable) {
3431 procedure.exception(graph, throwable);
3435 public String toString() {
3436 return "forInverse -> " + procedure;
3444 public void forInverse(Resource relation, SyncProcedure<Resource> procedure) {
3445 forInverse(relation, new SyncToAsyncProcedure<Resource>(procedure));
3449 public void forInverse(Resource relation, Procedure<Resource> procedure) {
3450 forInverse(relation, new NoneToAsyncProcedure<Resource>(procedure));
3454 public void forSingleObject(Resource subject, Resource relation,
3455 AsyncListener<Resource> listener) {
3456 asyncRequest(new SingleObject(subject, relation), listener);
3460 public void forSingleObject(Resource subject, Resource relation,
3461 SyncListener<Resource> listener) {
3462 asyncRequest(new SingleObject(subject, relation), listener);
3466 public void forSingleObject(Resource subject, Resource relation,
3467 Listener<Resource> listener) {
3468 asyncRequest(new SingleObject(subject, relation), listener);
3472 final public void forSingleObject(final Resource subject,
3473 final Resource relation, final AsyncProcedure<Resource> procedure) {
3475 assert (subject != null);
3476 assert (relation != null);
3477 assert (procedure != null);
3479 processor.forEachObject(this, subject, relation,
3480 new SingleOrErrorProcedure<Resource>(procedure));
3485 public void forSingleObject(Resource subject, Resource relation,
3486 SyncProcedure<Resource> procedure) {
3487 forSingleObject(subject, relation, new SyncToAsyncProcedure<Resource>(
3492 public void forSingleObject(Resource subject, Resource relation,
3493 Procedure<Resource> procedure) {
3494 forSingleObject(subject, relation, new NoneToAsyncProcedure<Resource>(
3499 public void forSingleStatement(Resource subject, Resource relation,
3500 AsyncListener<Statement> listener) {
3501 asyncRequest(new SingleStatement(subject, relation), listener);
3505 public void forSingleStatement(Resource subject, Resource relation,
3506 SyncListener<Statement> listener) {
3507 asyncRequest(new SingleStatement(subject, relation), listener);
3511 public void forSingleStatement(Resource subject, Resource relation,
3512 Listener<Statement> listener) {
3513 asyncRequest(new SingleStatement(subject, relation), listener);
3517 final public void forSingleStatement(final Resource subject,
3518 final Resource relation, final AsyncProcedure<Statement> procedure) {
3520 assert (subject != null);
3521 assert (relation != null);
3522 assert (procedure != null);
3524 processor.forEachStatement(this, subject, relation,
3525 new SingleOrErrorProcedure<Statement>(procedure));
3530 public void forSingleStatement(Resource subject, Resource relation,
3531 SyncProcedure<Statement> procedure) {
3532 forSingleStatement(subject, relation,
3533 new SyncToAsyncProcedure<Statement>(procedure));
3537 public void forSingleStatement(Resource subject, Resource relation,
3538 Procedure<Statement> procedure) {
3539 forSingleStatement(subject, relation,
3540 new NoneToAsyncProcedure<Statement>(procedure));
3544 public void forSingleType(Resource subject,
3545 AsyncListener<Resource> listener) {
3546 asyncRequest(new SingleTypeAny(subject), listener);
3550 public void forSingleType(Resource subject,
3551 SyncListener<Resource> listener) {
3552 asyncRequest(new SingleTypeAny(subject), listener);
3556 public void forSingleType(Resource subject,
3557 Listener<Resource> listener) {
3558 asyncRequest(new SingleTypeAny(subject), listener);
3562 final public void forSingleType(final Resource subject, final AsyncProcedure<Resource> procedure) {
3564 assert (subject != null);
3565 assert (procedure != null);
3567 final DeepSingleOrErrorProcedure<Resource> checkedProcedure = new DeepSingleOrErrorProcedure<Resource>(procedure);
3569 processor.forEachPrincipalType(this, subject, new AsyncMultiProcedureAdapter<Resource>() {
3572 public void execute(AsyncReadGraph graph, final Resource principalType) {
3573 checkedProcedure.offer(graph, principalType);
3577 public void finished(AsyncReadGraph graph) {
3578 checkedProcedure.dec(graph);
3582 public void exception(AsyncReadGraph graph, Throwable t) {
3583 checkedProcedure.exception(graph, t);
3587 public String toString() {
3588 return "forSingleType -> " + procedure;
3596 public void forSingleType(Resource subject, SyncProcedure<Resource> procedure) {
3597 forSingleType(subject, new SyncToAsyncProcedure<Resource>(
3602 public void forSingleType(Resource subject, Procedure<Resource> procedure) {
3603 forSingleType(subject, new NoneToAsyncProcedure<Resource>(
3608 public void forSingleType(Resource subject, Resource relation,
3609 AsyncListener<Resource> listener) {
3610 asyncRequest(new SingleType(subject, relation), listener);
3614 public void forSingleType(Resource subject, Resource relation,
3615 SyncListener<Resource> listener) {
3616 asyncRequest(new SingleType(subject, relation), listener);
3620 public void forSingleType(Resource subject, Resource relation,
3621 Listener<Resource> listener) {
3622 asyncRequest(new SingleType(subject, relation), listener);
3626 final public void forSingleType(final Resource subject,
3627 final Resource baseType, final AsyncProcedure<Resource> procedure) {
3629 assert (subject != null);
3630 assert (procedure != null);
3632 final DeepSingleOrErrorProcedure<Resource> checkedProcedure = new DeepSingleOrErrorProcedure<Resource>(procedure);
3634 processor.forEachPrincipalType(this, subject,
3635 new AsyncMultiProcedureAdapter<Resource>() {
3638 public void execute(AsyncReadGraph graph,
3639 final Resource principalType) {
3641 checkedProcedure.inc();
3643 if(baseType == null) {
3645 checkedProcedure.offer(graph, principalType);
3646 checkedProcedure.dec(graph);
3648 } else if(principalType.equals(baseType)) {
3650 checkedProcedure.offer(graph, principalType);
3651 checkedProcedure.dec(graph);
3655 processor.forSupertypes((ReadGraphImpl)graph, principalType,
3656 new AsyncProcedure<Set<Resource>>() {
3659 public void execute(
3660 AsyncReadGraph graph,
3661 Set<Resource> result) {
3663 if (result.contains(baseType))
3664 checkedProcedure.offer(graph,
3666 checkedProcedure.dec(graph);
3671 public void exception(
3672 AsyncReadGraph graph,
3675 .exception(graph, t);
3685 public void finished(AsyncReadGraph graph) {
3686 checkedProcedure.dec(graph);
3690 public void exception(AsyncReadGraph graph, Throwable t) {
3691 checkedProcedure.exception(graph, t);
3695 public String toString() {
3696 return "forSingleType -> " + procedure;
3704 public void forSingleType(Resource subject, Resource relation,
3705 SyncProcedure<Resource> procedure) {
3706 forSingleType(subject, relation, new SyncToAsyncProcedure<Resource>(
3711 public void forSingleType(Resource subject, Resource relation,
3712 Procedure<Resource> procedure) {
3713 forSingleType(subject, relation, new NoneToAsyncProcedure<Resource>(
3718 public <T> void forValue(Resource subject, Binding binding,
3719 AsyncListener<T> listener) {
3720 asyncRequest(new Value<T>(subject, binding), listener);
3724 public <T> void forValue(Resource subject, Binding binding,
3725 SyncListener<T> listener) {
3726 asyncRequest(new Value<T>(subject, binding), listener);
3730 public <T> void forValue(Resource subject, Binding binding,
3731 Listener<T> listener) {
3732 asyncRequest(new Value<T>(subject, binding), listener);
3736 public <T> void forValue(final Resource resource, final Binding binding,
3737 final AsyncProcedure<T> procedure) {
3739 assert (resource != null);
3740 assert (binding != null);
3741 assert (procedure != null);
3743 processor.forValue(this, resource, new AsyncProcedure<byte[]>() {
3746 public void execute(AsyncReadGraph graph, byte[] result) {
3750 if (result == null) {
3751 procedure.exception(graph,
3752 new DoesNotContainValueException(
3753 "No value for resource " + resource));
3757 Serializer serializer = binding.serializer();
3758 // Serializer serializer = Bindings.getSerializer( binding );
3759 Object obj = serializer.deserialize(result);
3760 // if (!binding.isInstance(obj))
3761 // procedure.exception(graph, new ClassCastException(
3762 // "Cannot get value " + obj + " with binding "
3765 procedure.execute(graph, (T) obj);
3767 } catch (IOException e) {
3768 procedure.exception(graph, e);
3769 } catch (BufferUnderflowException e) {
3770 procedure.exception(graph, e);
3771 } catch (Throwable t) {
3772 procedure.exception(graph, t);
3778 public void exception(AsyncReadGraph graph, Throwable t) {
3780 procedure.exception(graph, t);
3781 } catch (Throwable t2) {
3782 Logger.defaultLogError(t2);
3787 public String toString() {
3788 return "forValue -> " + procedure;
3796 public <T> void forValue(Resource subject, Binding binding,
3797 SyncProcedure<T> procedure) {
3798 forValue(subject, binding, new SyncToAsyncProcedure<T>(procedure));
3802 public <T> void forValue(Resource subject, Binding binding,
3803 Procedure<T> procedure) {
3804 forValue(subject, binding, new NoneToAsyncProcedure<T>(procedure));
3808 public <T> void forValue(Resource subject, AsyncListener<T> listener) {
3809 asyncRequest(new ValueImplied<T>(subject), listener);
3813 public <T> void forValue(Resource subject, SyncListener<T> listener) {
3814 asyncRequest(new ValueImplied<T>(subject), listener);
3818 public <T> void forValue(Resource subject, Listener<T> listener) {
3819 asyncRequest(new ValueImplied<T>(subject), listener);
3823 final public <T> void forValue(final Resource subject, final AsyncProcedure<T> procedure) {
3825 assert (subject != null);
3826 assert (procedure != null);
3828 forRelatedValue(subject, processor.getL0(this).HasDataType, DATA_TYPE_BINDING_INTERNAL, new AsyncProcedure<Datatype>() {
3831 public void execute(AsyncReadGraph graph, Datatype type) {
3832 // TODO: consider trying Bindings.getBeanBinding(type);
3833 Binding binding = Bindings.getBinding(type);
3834 graph.forValue(subject, binding, procedure);
3838 public void exception(AsyncReadGraph graph, Throwable throwable) {
3839 procedure.exception(graph, new DoesNotContainValueException("Invalid data type", throwable));
3847 public <T> void forValue(Resource subject, SyncProcedure<T> procedure) {
3848 forValue(subject, new SyncToAsyncProcedure<T>(procedure));
3852 public <T> void forValue(Resource subject, Procedure<T> procedure) {
3853 forValue(subject, new NoneToAsyncProcedure<T>(procedure));
3857 public <T> void forRelatedValue(Resource subject, Resource relation,
3858 AsyncListener<T> listener) {
3859 asyncRequest(new RelatedValueImplied<T>(subject, relation), listener);
3863 public <T> void forRelatedValue(Resource subject, Resource relation,
3864 SyncListener<T> listener) {
3865 asyncRequest(new RelatedValueImplied<T>(subject, relation), listener);
3869 public <T> void forRelatedValue(Resource subject, Resource relation,
3870 Listener<T> listener) {
3871 asyncRequest(new RelatedValueImplied<T>(subject, relation), listener);
3875 final public <T> void forRelatedValue(final Resource subject,
3876 final Resource relation, final AsyncProcedure<T> procedure) {
3878 assert (subject != null);
3879 assert (relation != null);
3880 assert (procedure != null);
3882 final DeepSingleOrErrorProcedure<T> checkedProcedure = new DeepSingleOrErrorProcedure<T>(procedure);
3884 processor.forEachObject(this, subject, relation,
3885 new AsyncMultiProcedureAdapter<Resource>() {
3888 public void execute(AsyncReadGraph graph,
3889 final Resource object) {
3891 checkedProcedure.inc();
3893 graph.forValue(object, new AsyncProcedure<Object>() {
3896 public void execute(AsyncReadGraph graph,
3898 checkedProcedure.offer(graph, (T) result);
3899 checkedProcedure.dec(graph);
3903 public void exception(AsyncReadGraph graph,
3905 checkedProcedure.exception(graph, t);
3909 public String toString() {
3910 return "forRelatedValue -> " + procedure;
3918 public void finished(AsyncReadGraph graph) {
3919 checkedProcedure.dec(graph);
3923 public void exception(AsyncReadGraph graph, Throwable t) {
3924 checkedProcedure.exception(graph, t);
3932 public <T> void forRelatedValue(Resource subject, Resource relation,
3933 SyncProcedure<T> procedure) {
3934 forRelatedValue(subject, relation, new SyncToAsyncProcedure<T>(
3939 public <T> void forRelatedValue(Resource subject, Resource relation,
3940 Procedure<T> procedure) {
3941 forRelatedValue(subject, relation, new NoneToAsyncProcedure<T>(
3946 public <T> void forRelatedValue(Resource subject, Resource relation,
3947 Binding binding, AsyncListener<T> listener) {
3948 asyncRequest(new RelatedValue<T>(subject, relation, binding), listener);
3952 public <T> void forRelatedValue(Resource subject, Resource relation,
3953 Binding binding, SyncListener<T> listener) {
3954 asyncRequest(new RelatedValue<T>(subject, relation, binding), listener);
3958 public <T> void forRelatedValue(Resource subject, Resource relation,
3959 Binding binding, Listener<T> listener) {
3960 asyncRequest(new RelatedValue<T>(subject, relation, binding), listener);
3964 final public <T> void forRelatedValue(final Resource subject,
3965 final Resource relation, final Binding binding,
3966 final AsyncProcedure<T> procedure) {
3968 assert (subject != null);
3969 assert (relation != null);
3970 assert (binding != null);
3971 assert (procedure != null);
3973 final DeepSingleOrErrorProcedure<T> checkedProcedure = new DeepSingleOrErrorProcedure<T>(procedure);
3975 processor.forEachObject(this, subject, relation,
3976 new AsyncMultiProcedureAdapter<Resource>() {
3979 public void execute(AsyncReadGraph graph,
3980 final Resource object) {
3982 checkedProcedure.inc();
3984 graph.forValue(object, binding, new AsyncProcedure<Object>() {
3987 public void execute(AsyncReadGraph graph,
3990 checkedProcedure.offer(graph,
3992 checkedProcedure.dec(graph);
3996 public void exception(AsyncReadGraph graph,
3998 checkedProcedure.exception(graph, t);
4002 public String toString() {
4003 return "forRelatedValue -> "
4012 public void finished(AsyncReadGraph graph) {
4013 checkedProcedure.dec(graph);
4017 public void exception(AsyncReadGraph graph, Throwable t) {
4018 checkedProcedure.exception(graph, t);
4026 public <T> void forRelatedValue(Resource subject, Resource relation,
4027 Binding binding, SyncProcedure<T> procedure) {
4028 forRelatedValue(subject, relation, binding,
4029 new SyncToAsyncProcedure<T>(procedure));
4033 public <T> void forRelatedValue(Resource subject, Resource relation,
4034 Binding binding, Procedure<T> procedure) {
4035 forRelatedValue(subject, relation, binding,
4036 new NoneToAsyncProcedure<T>(procedure));
4040 public <T> void forAdapted(Resource resource, Class<T> clazz,
4041 AsyncListener<T> listener) {
4042 asyncRequest(new Adapter<T>(resource, clazz), listener);
4046 public <T> void forAdapted(Resource resource, Class<T> clazz,
4047 SyncListener<T> listener) {
4048 asyncRequest(new Adapter<T>(resource, clazz), listener);
4052 public <T> void forAdapted(Resource resource, Class<T> clazz,
4053 Listener<T> listener) {
4054 asyncRequest(new Adapter<T>(resource, clazz), listener);
4058 final public <T> void forAdapted(final Resource resource,
4059 final Class<T> clazz, final AsyncProcedure<T> procedure) {
4061 assert (resource != null);
4062 assert (clazz != null);
4063 assert (procedure != null);
4065 final AdaptionService service = getSession().peekService(AdaptionService.class);
4066 if (service == null)
4067 procedure.exception(this, new ServiceException("No AdaptionService available"));
4069 service.adapt(this, resource, resource, Resource.class, clazz, false, procedure);
4074 public <T> void forAdapted(Resource resource, Class<T> clazz,
4075 SyncProcedure<T> procedure) {
4076 forAdapted(resource, clazz, new SyncToAsyncProcedure<T>(procedure));
4080 public <T> void forAdapted(Resource resource, Class<T> clazz,
4081 Procedure<T> procedure) {
4082 forAdapted(resource, clazz, new NoneToAsyncProcedure<T>(procedure));
4086 public <T> void forUniqueAdapted(Resource resource, Class<T> clazz,
4087 AsyncListener<T> listener) {
4088 asyncRequest(new UniqueAdapter<T>(resource, clazz), listener);
4092 public <T> void forUniqueAdapted(Resource resource, Class<T> clazz,
4093 SyncListener<T> listener) {
4094 asyncRequest(new UniqueAdapter<T>(resource, clazz), listener);
4098 public <T> void forUniqueAdapted(Resource resource, Class<T> clazz,
4099 Listener<T> listener) {
4100 asyncRequest(new UniqueAdapter<T>(resource, clazz), listener);
4104 final public <T> void forUniqueAdapted(final Resource resource,
4105 final Class<T> clazz, final AsyncProcedure<T> procedure) {
4107 assert (resource != null);
4108 assert (clazz != null);
4109 assert (procedure != null);
4111 final AdaptionService service = getSession().peekService(AdaptionService.class);
4112 if (service == null)
4113 procedure.exception(this, new ServiceException("No AdaptionService available"));
4115 service.adaptNew(this, resource, clazz, false, procedure);
4120 public <T> void forUniqueAdapted(Resource resource, Class<T> clazz,
4121 SyncProcedure<T> procedure) {
4122 forUniqueAdapted(resource, clazz,
4123 new SyncToAsyncProcedure<T>(procedure));
4127 public <T> void forUniqueAdapted(Resource resource, Class<T> clazz,
4128 Procedure<T> procedure) {
4129 forUniqueAdapted(resource, clazz,
4130 new NoneToAsyncProcedure<T>(procedure));
4134 public void forPossibleInverse(Resource subject,
4135 AsyncListener<Resource> listener) {
4136 asyncRequest(new PossibleInverse(subject), listener);
4140 public void forPossibleInverse(Resource subject,
4141 SyncListener<Resource> listener) {
4142 asyncRequest(new PossibleInverse(subject), listener);
4146 public void forPossibleInverse(Resource subject, Listener<Resource> listener) {
4147 asyncRequest(new PossibleInverse(subject), listener);
4151 final public void forPossibleInverse(final Resource relation,
4152 final AsyncProcedure<Resource> procedure) {
4154 assert (relation != null);
4155 assert (procedure != null);
4157 processor.forInverse(this, relation, new ExceptionToNullProcedure<Resource>(procedure));
4162 public void forPossibleInverse(Resource subject,
4163 SyncProcedure<Resource> procedure) {
4164 forPossibleInverse(subject, new SyncToAsyncProcedure<Resource>(
4169 public void forPossibleInverse(Resource subject,
4170 Procedure<Resource> procedure) {
4171 forPossibleInverse(subject, new NoneToAsyncProcedure<Resource>(
4176 public void forPossibleObject(Resource subject, Resource relation,
4177 AsyncListener<Resource> listener) {
4178 asyncRequest(new PossibleObject(subject, relation), listener);
4182 public void forPossibleObject(Resource subject, Resource relation,
4183 SyncListener<Resource> listener) {
4184 asyncRequest(new PossibleObject(subject, relation), listener);
4188 public void forPossibleObject(Resource subject, Resource relation,
4189 Listener<Resource> listener) {
4190 asyncRequest(new PossibleObject(subject, relation), listener);
4194 final public void forPossibleObject(final Resource subject,
4195 final Resource relation, final AsyncProcedure<Resource> procedure) {
4197 assert (subject != null);
4198 assert (relation != null);
4199 assert (procedure != null);
4201 processor.forEachObject(this, subject, relation,
4202 new SingleOrNullProcedure<Resource>(procedure));
4207 public void forPossibleObject(Resource subject, Resource relation,
4208 SyncProcedure<Resource> procedure) {
4209 forPossibleObject(subject, relation,
4210 new SyncToAsyncProcedure<Resource>(procedure));
4214 public void forPossibleObject(Resource subject, Resource relation,
4215 Procedure<Resource> procedure) {
4216 forPossibleObject(subject, relation,
4217 new NoneToAsyncProcedure<Resource>(procedure));
4221 public void forPossibleStatement(Resource subject, Resource relation,
4222 AsyncListener<Statement> listener) {
4223 asyncRequest(new PossibleStatement(subject, relation), listener);
4227 public void forPossibleStatement(Resource subject, Resource relation,
4228 SyncListener<Statement> listener) {
4229 asyncRequest(new PossibleStatement(subject, relation), listener);
4233 public void forPossibleStatement(Resource subject, Resource relation,
4234 Listener<Statement> listener) {
4235 asyncRequest(new PossibleStatement(subject, relation), listener);
4239 final public void forPossibleStatement(final Resource subject,
4240 final Resource relation, final AsyncProcedure<Statement> procedure) {
4242 assert (subject != null);
4243 assert (relation != null);
4244 assert (procedure != null);
4246 processor.forEachStatement(this, subject, relation,
4247 new SingleFunctionalOrNullProcedure<Statement>(
4248 "forPossibleStatement", procedure));
4253 public void forPossibleStatement(Resource subject, Resource relation,
4254 SyncProcedure<Statement> procedure) {
4255 forPossibleStatement(subject, relation,
4256 new SyncToAsyncProcedure<Statement>(procedure));
4260 public void forPossibleStatement(Resource subject, Resource relation,
4261 Procedure<Statement> procedure) {
4262 forPossibleStatement(subject, relation,
4263 new NoneToAsyncProcedure<Statement>(procedure));
4267 public void forPossibleType(Resource subject, Resource relation,
4268 AsyncListener<Resource> listener) {
4269 asyncRequest(new PossibleType(subject, relation), listener);
4273 public void forPossibleType(Resource subject, Resource relation,
4274 SyncListener<Resource> listener) {
4275 asyncRequest(new PossibleType(subject, relation), listener);
4279 public void forPossibleType(Resource subject, Resource relation,
4280 Listener<Resource> listener) {
4281 asyncRequest(new PossibleType(subject, relation), listener);
4285 final public void forPossibleType(final Resource subject,
4286 final Resource baseType, final AsyncProcedure<Resource> procedure) {
4288 assert (subject != null);
4289 assert (procedure != null);
4291 final NullSingleOrNullProcedure<Resource> checkedProcedure = new NullSingleOrNullProcedure<Resource>(procedure);
4293 processor.forEachPrincipalType(this, subject, new AsyncMultiProcedureAdapter<Resource>() {
4296 public void execute(AsyncReadGraph graph,
4297 final Resource principalType) {
4299 if (baseType == null) {
4301 checkedProcedure.offer(graph, principalType);
4303 } else if (principalType.equals(baseType)) {
4305 checkedProcedure.offer(graph, principalType);
4309 checkedProcedure.inc();
4311 processor.forSupertypes((ReadGraphImpl)graph, principalType,
4312 new AsyncProcedure<Set<Resource>>() {
4315 public void execute(
4316 AsyncReadGraph graph,
4317 Set<Resource> result) {
4319 if (result.contains(baseType)) {
4320 checkedProcedure.offer(graph,
4324 checkedProcedure.dec(graph);
4329 public void exception(
4330 AsyncReadGraph graph,
4332 checkedProcedure.exception(graph, t);
4333 checkedProcedure.dec(graph);
4337 public String toString() {
4338 return "forPossibleType -> "
4349 public void finished(AsyncReadGraph graph) {
4350 checkedProcedure.dec(graph);
4354 public void exception(AsyncReadGraph graph, Throwable t) {
4355 checkedProcedure.exception(graph, t);
4356 checkedProcedure.dec(graph);
4364 public void forPossibleType(Resource subject, Resource relation,
4365 SyncProcedure<Resource> procedure) {
4366 forPossibleType(subject, relation, new SyncToAsyncProcedure<Resource>(
4371 public void forPossibleType(Resource subject, Resource relation,
4372 Procedure<Resource> procedure) {
4373 forPossibleType(subject, relation, new NoneToAsyncProcedure<Resource>(
4378 public <T> void forPossibleValue(Resource subject, AsyncListener<T> listener) {
4379 asyncRequest(new PossibleValueImplied<T>(subject), listener);
4383 public <T> void forPossibleValue(Resource subject, SyncListener<T> listener) {
4384 asyncRequest(new PossibleValueImplied<T>(subject), listener);
4388 public <T> void forPossibleValue(Resource subject, Listener<T> listener) {
4389 asyncRequest(new PossibleValueImplied<T>(subject), listener);
4393 final public <T> void forPossibleValue(final Resource subject,
4394 final AsyncProcedure<T> procedure) {
4396 assert (subject != null);
4397 assert (procedure != null);
4399 forPossibleRelatedValue(subject, processor.getL0(this).HasDataType, DATA_TYPE_BINDING_INTERNAL, new AsyncProcedure<Datatype>() {
4402 public void execute(AsyncReadGraph graph, final Datatype type) {
4404 procedure.execute(graph, null);
4407 // TODO: consider trying Bindings.getBeanBinding(type);
4408 Binding binding = Bindings.getBinding(type);
4409 graph.forPossibleValue(subject, binding, procedure);
4410 } catch (RuntimeBindingConstructionException e) {
4411 procedure.exception(graph, e);
4417 public void exception(AsyncReadGraph graph, Throwable t) {
4418 procedure.exception(graph, t);
4422 public String toString() {
4423 return "forPossibleValue -> " + procedure;
4431 public <T> void forPossibleValue(Resource subject,
4432 SyncProcedure<T> procedure) {
4433 forPossibleValue(subject, new SyncToAsyncProcedure<T>(procedure));
4437 public <T> void forPossibleValue(Resource subject, Procedure<T> procedure) {
4438 forPossibleValue(subject, new NoneToAsyncProcedure<T>(procedure));
4442 public <T> void forPossibleValue(Resource subject, Binding binding,
4443 AsyncListener<T> listener) {
4444 asyncRequest(new PossibleValue<T>(subject, binding), listener);
4448 public <T> void forPossibleValue(Resource subject, Binding binding,
4449 SyncListener<T> listener) {
4450 asyncRequest(new PossibleValue<T>(subject, binding), listener);
4454 public <T> void forPossibleValue(Resource subject, Binding binding,
4455 Listener<T> listener) {
4456 asyncRequest(new PossibleValue<T>(subject, binding), listener);
4460 final public <T> void forPossibleValue(final Resource resource,
4461 final Binding binding, final AsyncProcedure<T> procedure) {
4463 assert (resource != null);
4464 assert (binding != null);
4465 assert (procedure != null);
4467 processor.forValue(this, resource, new AsyncProcedure<byte[]>() {
4470 public void execute(AsyncReadGraph graph, byte[] result) {
4474 if (result == null) {
4475 procedure.execute(graph, null);
4479 Serializer serializer = Bindings.getSerializer( binding );
4480 Object obj = serializer.deserialize(result);
4481 if (!binding.isInstance(obj))
4482 procedure.exception(graph, new ClassCastException(
4483 "Cannot get value " + obj + " with binding "
4486 procedure.execute(graph, (T) obj);
4488 } catch (IOException e) {
4489 procedure.exception(graph, e);
4490 } catch (BufferUnderflowException e) {
4491 procedure.exception(graph, e);
4492 } catch (Throwable t) {
4493 procedure.exception(graph, t);
4499 public void exception(AsyncReadGraph graph, Throwable t) {
4501 procedure.exception(graph, t);
4502 } catch (Throwable t2) {
4503 Logger.defaultLogError(t2);
4508 public String toString() {
4509 return "forPossibleValue -> " + procedure;
4517 public <T> void forPossibleValue(Resource subject, Binding binding,
4518 SyncProcedure<T> procedure) {
4519 forPossibleValue(subject, binding, new SyncToAsyncProcedure<T>(
4524 public <T> void forPossibleValue(Resource subject, Binding binding,
4525 Procedure<T> procedure) {
4526 forPossibleValue(subject, binding, new NoneToAsyncProcedure<T>(
4531 public <T> void forPossibleRelatedValue(Resource subject,
4532 Resource relation, AsyncListener<T> listener) {
4533 asyncRequest(new PossibleRelatedValueImplied<T>(subject, relation),
4538 public <T> void forPossibleRelatedValue(Resource subject,
4539 Resource relation, SyncListener<T> listener) {
4540 asyncRequest(new PossibleRelatedValueImplied<T>(subject, relation),
4545 public <T> void forPossibleRelatedValue(Resource subject,
4546 Resource relation, Listener<T> listener) {
4547 asyncRequest(new PossibleRelatedValueImplied<T>(subject, relation),
4552 final public <T> void forPossibleRelatedValue(final Resource subject,
4553 final Resource relation, final AsyncProcedure<T> procedure) {
4555 assert (subject != null);
4556 assert (relation != null);
4557 assert (procedure != null);
4559 final DeepSingleOrNullProcedure<T> checkedProcedure = new DeepSingleOrNullProcedure<T>(procedure);
4561 processor.forEachObject(this, subject, relation,
4562 new AsyncMultiProcedureAdapter<Resource>() {
4565 public void execute(AsyncReadGraph graph,
4566 final Resource object) {
4568 checkedProcedure.inc();
4570 graph.forValue(object, new AsyncProcedure<Object>() {
4573 public void execute(AsyncReadGraph graph,
4575 checkedProcedure.offer(graph, (T) result);
4576 checkedProcedure.dec(graph);
4580 public void exception(AsyncReadGraph graph,
4582 checkedProcedure.exception(graph, t);
4583 checkedProcedure.dec(graph);
4591 public void finished(AsyncReadGraph graph) {
4593 checkedProcedure.dec(graph);
4597 public void exception(AsyncReadGraph graph, Throwable t) {
4598 checkedProcedure.exception(graph, t);
4599 checkedProcedure.dec(graph);
4603 public String toString() {
4604 return "forPossibleRelatedValue -> " + procedure;
4611 public <T> void forPossibleRelatedValue(Resource subject,
4612 Resource relation, SyncProcedure<T> procedure) {
4613 forPossibleRelatedValue(subject, relation, new SyncToAsyncProcedure<T>(
4618 public <T> void forPossibleRelatedValue(Resource subject,
4619 Resource relation, Procedure<T> procedure) {
4620 forPossibleRelatedValue(subject, relation, new NoneToAsyncProcedure<T>(
4625 public <T> void forPossibleRelatedValue(Resource subject,
4626 Resource relation, Binding binding, AsyncListener<T> listener) {
4627 asyncRequest(new PossibleRelatedValue<T>(subject, relation, binding),
4632 public <T> void forPossibleRelatedValue(Resource subject,
4633 Resource relation, Binding binding, SyncListener<T> listener) {
4634 asyncRequest(new PossibleRelatedValue<T>(subject, relation, binding),
4639 public <T> void forPossibleRelatedValue(Resource subject,
4640 Resource relation, Binding binding, Listener<T> listener) {
4641 asyncRequest(new PossibleRelatedValue<T>(subject, relation, binding),
4646 // final public <T> void forPossibleRelatedValue(final Resource subject, final Resource relation, final Binding binding,
4647 // final AsyncProcedure<T> procedure) {
4649 // forPossibleRelatedValue(subject, relation, binding, procedure, false);
4653 final public <T> void forPossibleRelatedValue(final Resource subject, final Resource relation, final Binding binding,
4654 final AsyncProcedure<T> procedure) {
4656 assert (subject != null);
4657 assert (relation != null);
4658 assert (procedure != null);
4660 processor.forPossibleObject(this, subject, relation, new AsyncProcedure<Resource>() {
4663 public void execute(AsyncReadGraph graph, Resource object) {
4665 if(object == null) {
4666 procedure.execute(graph, null);
4670 processor.forPossibleValue((ReadGraphImpl)graph, object, new AsyncProcedure<byte[]>() {
4673 public void execute(AsyncReadGraph graph, byte[] bytes) {
4679 Serializer serializer = binding.serializer();
4680 Object obj = serializer.deserialize(bytes);
4681 if (!binding.isInstance(obj)) {
4682 procedure.exception(graph, new ClassCastException("Cannot get value " + obj + " with binding " + binding));
4684 procedure.execute(graph, (T) obj);
4687 } catch (Throwable t) {
4689 procedure.exception(graph, t);
4695 procedure.execute(graph, null);
4702 public void exception(AsyncReadGraph graph, Throwable t) {
4703 procedure.exception(graph, t);
4711 public void exception(AsyncReadGraph graph, Throwable throwable) {
4712 throwable.printStackTrace();
4713 procedure.exception(graph, throwable);
4721 public <T> void forPossibleRelatedValue(Resource subject,
4722 Resource relation, Binding binding, SyncProcedure<T> procedure) {
4723 forPossibleRelatedValue(subject, relation, binding,
4724 new SyncToAsyncProcedure<T>(procedure));
4728 public <T> void forPossibleRelatedValue(Resource subject,
4729 Resource relation, Binding binding, Procedure<T> procedure) {
4730 forPossibleRelatedValue(subject, relation, binding,
4731 new NoneToAsyncProcedure<T>(procedure));
4735 public void forIsInstanceOf(Resource subject, Resource relation,
4736 AsyncListener<Boolean> listener) {
4737 asyncRequest(new IsInstanceOf(subject, relation), listener);
4741 public void forIsInstanceOf(Resource subject, Resource relation,
4742 SyncListener<Boolean> listener) {
4743 asyncRequest(new IsInstanceOf(subject, relation), listener);
4747 public void forIsInstanceOf(Resource subject, Resource relation,
4748 Listener<Boolean> listener) {
4749 asyncRequest(new IsInstanceOf(subject, relation), listener);
4753 final public void forIsInstanceOf(final Resource resource,
4754 final Resource type, final AsyncProcedure<Boolean> procedure) {
4756 assert (resource != null);
4757 assert (type != null);
4758 assert (procedure != null);
4760 forTypes(resource, new AsyncProcedure<Set<Resource>>() {
4763 public void execute(AsyncReadGraph graph, Set<Resource> result) {
4766 if (result.contains(type))
4767 procedure.execute(graph, true);
4769 procedure.execute(graph, false);
4770 } catch (Throwable t) {
4771 Logger.defaultLogError(t);
4776 public void exception(AsyncReadGraph graph, Throwable t) {
4778 procedure.exception(graph, t);
4779 } catch (Throwable t2) {
4780 Logger.defaultLogError(t2);
4785 public String toString() {
4786 return "forIsInstanceOf -> " + procedure;
4794 public void forIsInstanceOf(Resource subject, Resource relation,
4795 SyncProcedure<Boolean> procedure) {
4796 forIsInstanceOf(subject, relation, new SyncToAsyncProcedure<Boolean>(
4801 public void forIsInstanceOf(Resource subject, Resource relation,
4802 Procedure<Boolean> procedure) {
4803 forIsInstanceOf(subject, relation, new NoneToAsyncProcedure<Boolean>(
4808 public void forIsInheritedFrom(Resource subject, Resource relation,
4809 AsyncListener<Boolean> listener) {
4810 asyncRequest(new IsInheritedFrom(subject, relation), listener);
4814 public void forIsInheritedFrom(Resource subject, Resource relation,
4815 SyncListener<Boolean> listener) {
4816 asyncRequest(new IsInheritedFrom(subject, relation), listener);
4820 public void forIsInheritedFrom(Resource subject, Resource relation,
4821 Listener<Boolean> listener) {
4822 asyncRequest(new IsInheritedFrom(subject, relation), listener);
4826 final public void forIsInheritedFrom(final Resource resource,
4827 final Resource type, final AsyncProcedure<Boolean> procedure) {
4829 assert (resource != null);
4830 assert (type != null);
4831 assert (procedure != null);
4833 if (resource.equals(type)) {
4835 procedure.execute(this, true);
4836 } catch (Throwable t) {
4837 Logger.defaultLogError(t);
4842 forSupertypes(resource, new AsyncProcedure<Set<Resource>>() {
4845 public void execute(AsyncReadGraph graph, Set<Resource> result) {
4847 if (result.contains(type))
4848 procedure.execute(graph, true);
4850 procedure.execute(graph, false);
4851 } catch (Throwable t) {
4852 Logger.defaultLogError(t);
4857 public void exception(AsyncReadGraph graph, Throwable t) {
4859 procedure.exception(graph, t);
4860 } catch (Throwable t2) {
4861 Logger.defaultLogError(t2);
4866 public String toString() {
4867 return "forIsInheritedFrom -> " + procedure;
4875 public void forIsInheritedFrom(Resource subject, Resource relation,
4876 SyncProcedure<Boolean> procedure) {
4877 forIsInheritedFrom(subject, relation,
4878 new SyncToAsyncProcedure<Boolean>(procedure));
4882 public void forIsInheritedFrom(Resource subject, Resource relation,
4883 Procedure<Boolean> procedure) {
4884 forIsInheritedFrom(subject, relation,
4885 new NoneToAsyncProcedure<Boolean>(procedure));
4889 public void forIsSubrelationOf(Resource subject, Resource relation,
4890 AsyncListener<Boolean> listener) {
4891 asyncRequest(new IsSubrelationOf(subject, relation), listener);
4895 public void forIsSubrelationOf(Resource subject, Resource relation,
4896 SyncListener<Boolean> listener) {
4897 asyncRequest(new IsSubrelationOf(subject, relation), listener);
4901 public void forIsSubrelationOf(Resource subject, Resource relation,
4902 Listener<Boolean> listener) {
4903 asyncRequest(new IsSubrelationOf(subject, relation), listener);
4907 final public void forIsSubrelationOf(final Resource resource,
4908 final Resource relation, final AsyncProcedure<Boolean> procedure) {
4910 assert (resource != null);
4911 assert (relation != null);
4912 assert (procedure != null);
4914 if (resource.equals(relation)) {
4915 procedure.execute(this, true);
4919 forSuperrelations(resource, new AsyncProcedure<Set<Resource>>() {
4922 public void execute(AsyncReadGraph graph, Set<Resource> result) {
4924 if (result.contains(relation))
4925 procedure.execute(graph, true);
4927 procedure.execute(graph, false);
4928 } catch (Throwable t) {
4929 Logger.defaultLogError(t);
4934 public void exception(AsyncReadGraph graph, Throwable t) {
4936 procedure.exception(graph, t);
4937 } catch (Throwable t2) {
4938 Logger.defaultLogError(t2);
4943 public String toString() {
4944 return "forIsSubrelationOf -> " + procedure;
4952 public void forIsSubrelationOf(Resource subject, Resource relation,
4953 SyncProcedure<Boolean> procedure) {
4954 forIsSubrelationOf(subject, relation,
4955 new SyncToAsyncProcedure<Boolean>(procedure));
4959 public void forIsSubrelationOf(Resource subject, Resource relation,
4960 Procedure<Boolean> procedure) {
4961 forIsSubrelationOf(subject, relation,
4962 new NoneToAsyncProcedure<Boolean>(procedure));
4966 public void forHasStatement(Resource subject,
4967 AsyncListener<Boolean> listener) {
4968 asyncRequest(new HasStatementSubject(subject), listener);
4972 public void forHasStatement(Resource subject, SyncListener<Boolean> listener) {
4973 asyncRequest(new HasStatementSubject(subject), listener);
4977 public void forHasStatement(Resource subject, Listener<Boolean> listener) {
4978 asyncRequest(new HasStatementSubject(subject), listener);
4982 final public void forHasStatement(final Resource subject,
4983 final AsyncProcedure<Boolean> procedure) {
4985 assert (subject != null);
4986 assert (procedure != null);
4988 processor.forHasStatement(this, subject, procedure);
4993 public void forHasStatement(Resource subject,
4994 SyncProcedure<Boolean> procedure) {
4995 forHasStatement(subject, new SyncToAsyncProcedure<Boolean>(procedure));
4999 public void forHasStatement(Resource subject, Procedure<Boolean> procedure) {
5000 forHasStatement(subject, new NoneToAsyncProcedure<Boolean>(procedure));
5004 public void forHasStatement(Resource subject, Resource relation,
5005 AsyncListener<Boolean> listener) {
5006 asyncRequest(new HasStatement(subject, relation), listener);
5010 public void forHasStatement(Resource subject, Resource relation,
5011 SyncListener<Boolean> listener) {
5012 asyncRequest(new HasStatement(subject, relation), listener);
5016 public void forHasStatement(Resource subject, Resource relation,
5017 Listener<Boolean> listener) {
5018 asyncRequest(new HasStatement(subject, relation), listener);
5022 final public void forHasStatement(final Resource subject,
5023 final Resource relation, final AsyncProcedure<Boolean> procedure) {
5025 assert (subject != null);
5026 assert (relation != null);
5027 assert (procedure != null);
5029 processor.forHasStatement(this, subject, relation, procedure);
5034 public void forHasStatement(Resource subject, Resource relation,
5035 SyncProcedure<Boolean> procedure) {
5036 forHasStatement(subject, relation, new SyncToAsyncProcedure<Boolean>(
5041 public void forHasStatement(Resource subject, Resource relation,
5042 Procedure<Boolean> procedure) {
5043 forHasStatement(subject, relation, new NoneToAsyncProcedure<Boolean>(
5048 public void forHasStatement(Resource subject, Resource relation,
5049 Resource object, AsyncListener<Boolean> listener) {
5050 asyncRequest(new HasStatementSubjectObject(subject, relation, object),
5055 public void forHasStatement(Resource subject, Resource relation,
5056 Resource object, SyncListener<Boolean> listener) {
5057 asyncRequest(new HasStatementSubjectObject(subject, relation, object),
5062 public void forHasStatement(Resource subject, Resource relation,
5063 Resource object, Listener<Boolean> listener) {
5064 asyncRequest(new HasStatementSubjectObject(subject, relation, object),
5069 final public void forHasStatement(final Resource subject,
5070 final Resource relation, final Resource object,
5071 final AsyncProcedure<Boolean> procedure) {
5073 assert (subject != null);
5074 assert (relation != null);
5075 assert (object != null);
5076 assert (procedure != null);
5078 processor.forHasStatement(this, subject, relation, object, procedure);
5083 public void forHasStatement(Resource subject, Resource relation,
5084 Resource object, SyncProcedure<Boolean> procedure) {
5085 forHasStatement(subject, relation, object,
5086 new SyncToAsyncProcedure<Boolean>(procedure));
5090 public void forHasStatement(Resource subject, Resource relation,
5091 Resource object, Procedure<Boolean> procedure) {
5092 forHasStatement(subject, relation, object,
5093 new NoneToAsyncProcedure<Boolean>(procedure));
5097 public void forHasValue(Resource subject, AsyncListener<Boolean> listener) {
5098 asyncRequest(new HasValue(subject), listener);
5102 public void forHasValue(Resource subject, SyncListener<Boolean> listener) {
5103 asyncRequest(new HasValue(subject), listener);
5107 public void forHasValue(Resource subject, Listener<Boolean> listener) {
5108 asyncRequest(new HasValue(subject), listener);
5112 final public void forHasValue(final Resource subject,
5113 final AsyncProcedure<Boolean> procedure) {
5115 assert (subject != null);
5116 assert (procedure != null);
5118 processor.forValue(this, subject, new AsyncProcedure<byte[]>() {
5121 public void execute(AsyncReadGraph graph, byte[] result) {
5124 procedure.execute(graph, false);
5126 procedure.execute(graph, true);
5127 } catch (Throwable t) {
5128 Logger.defaultLogError(t);
5133 public void exception(AsyncReadGraph graph, Throwable t) {
5135 procedure.exception(graph, t);
5136 } catch (Throwable t2) {
5137 Logger.defaultLogError(t2);
5142 public String toString() {
5143 return "forHasValue -> " + procedure;
5151 public void forHasValue(Resource subject, SyncProcedure<Boolean> procedure) {
5152 forHasValue(subject, new SyncToAsyncProcedure<Boolean>(procedure));
5156 public void forHasValue(Resource subject, Procedure<Boolean> procedure) {
5157 forHasValue(subject, new NoneToAsyncProcedure<Boolean>(procedure));
5161 public void forOrderedSet(Resource subject,
5162 AsyncMultiListener<Resource> listener) {
5163 asyncRequest(new OrderedSet(subject), listener);
5167 public void forOrderedSet(Resource subject,
5168 SyncMultiListener<Resource> listener) {
5169 asyncRequest(new OrderedSet(subject), listener);
5173 public void forOrderedSet(Resource subject, MultiListener<Resource> listener) {
5174 asyncRequest(new OrderedSet(subject), listener);
5178 final public void forOrderedSet(final Resource subject,
5179 final AsyncMultiProcedure<Resource> procedure) {
5181 assert (subject != null);
5182 assert (procedure != null);
5184 processor.forOrderedSet(this, subject,
5185 new AsyncMultiProcedure<Resource>() {
5188 public void finished(AsyncReadGraph graph) {
5190 procedure.finished(graph);
5191 } catch (Throwable t) {
5192 Logger.defaultLogError(t);
5197 public void execute(AsyncReadGraph graph, Resource result) {
5199 procedure.execute(graph, result);
5200 } catch (Throwable t) {
5201 Logger.defaultLogError(t);
5206 public void exception(AsyncReadGraph graph, Throwable t) {
5208 procedure.exception(graph, t);
5209 } catch (Throwable t2) {
5210 Logger.defaultLogError(t2);
5215 public String toString() {
5216 return "forOrderedSet -> " + procedure;
5224 public void forOrderedSet(Resource subject,
5225 SyncMultiProcedure<Resource> procedure) {
5226 forOrderedSet(subject, new SyncToAsyncMultiProcedure<Resource>(
5231 public void forOrderedSet(Resource subject,
5232 MultiProcedure<Resource> procedure) {
5233 forOrderedSet(subject, new NoneToAsyncMultiProcedure<Resource>(
5238 public <T> void forPossibleAdapted(Resource resource, Class<T> clazz,
5239 AsyncListener<T> listener) {
5240 asyncRequest(new PossibleAdapter<T>(resource, clazz), listener);
5244 public <T> void forPossibleAdapted(Resource resource, Class<T> clazz,
5245 SyncListener<T> listener) {
5246 asyncRequest(new PossibleAdapter<T>(resource, clazz), listener);
5250 public <T> void forPossibleAdapted(Resource resource, Class<T> clazz,
5251 Listener<T> listener) {
5252 asyncRequest(new PossibleAdapter<T>(resource, clazz), listener);
5256 final public <T> void forPossibleAdapted(final Resource resource,
5257 final Class<T> clazz, final AsyncProcedure<T> procedure) {
5259 assert (resource != null);
5260 assert (clazz != null);
5261 assert (procedure != null);
5263 final AdaptionService service = getSession().peekService(AdaptionService.class);
5264 if (service == null)
5265 procedure.exception(this, new ServiceException("No AdaptionService available"));
5267 service.adapt(this, resource, resource, Resource.class, clazz, true, procedure);
5271 public <T> void forPossibleAdapted(Resource resource, Class<T> clazz,
5272 SyncProcedure<T> procedure) {
5273 forPossibleAdapted(resource, clazz, new SyncToAsyncProcedure<T>(
5278 public <T> void forPossibleAdapted(Resource resource, Class<T> clazz,
5279 Procedure<T> procedure) {
5280 forPossibleAdapted(resource, clazz, new NoneToAsyncProcedure<T>(
5285 public <T> void forPossibleUniqueAdapted(Resource resource, Class<T> clazz,
5286 AsyncListener<T> listener) {
5287 asyncRequest(new PossibleUniqueAdapter<T>(resource, clazz), listener);
5291 public <T> void forPossibleUniqueAdapted(Resource resource, Class<T> clazz,
5292 SyncListener<T> listener) {
5293 asyncRequest(new PossibleUniqueAdapter<T>(resource, clazz), listener);
5297 public <T> void forPossibleUniqueAdapted(Resource resource, Class<T> clazz,
5298 Listener<T> listener) {
5299 asyncRequest(new PossibleUniqueAdapter<T>(resource, clazz), listener);
5303 final public <T> void forPossibleUniqueAdapted(final Resource resource,
5304 final Class<T> clazz, final AsyncProcedure<T> procedure) {
5306 assert (resource != null);
5307 assert (clazz != null);
5308 assert (procedure != null);
5310 final AdaptionService service = getSession().peekService(AdaptionService.class);
5311 if (service == null)
5312 procedure.exception(this, new ServiceException("No AdaptionService available"));
5314 service.adaptNew(this, resource, clazz, true, procedure);
5319 public <T> void forPossibleUniqueAdapted(Resource resource, Class<T> clazz,
5320 SyncProcedure<T> procedure) {
5321 forPossibleUniqueAdapted(resource, clazz, new SyncToAsyncProcedure<T>(
5326 public <T> void forPossibleUniqueAdapted(Resource resource, Class<T> clazz,
5327 Procedure<T> procedure) {
5328 forPossibleUniqueAdapted(resource, clazz, new NoneToAsyncProcedure<T>(
5333 * Implementation of the interface AsyncRequestProcessor
5337 final public Session getSession() {
5338 return processor.getSession();
5342 // final public Builtins getBuiltins() {
5343 // return processor.getSession().getBuiltins();
5347 public <T> void asyncRequest(final Read<T> request) {
5349 asyncRequest(request, new AsyncProcedure<T>() {
5352 public void execute(AsyncReadGraph graph, T result) {
5356 public void exception(AsyncReadGraph graph, Throwable t) {
5357 Logger.defaultLogError(t);
5361 public String toString() {
5362 return "asyncRequest(Read) -> " + request;
5370 public <T> void asyncRequest(Read<T> request, AsyncListener<T> procedure) {
5371 asyncRequest(request, (AsyncProcedure<T>) procedure);
5375 public <T> void asyncRequest(Read<T> request,
5376 final SyncListener<T> procedure) {
5377 asyncRequest(request, new SyncToAsyncListener<T>(procedure));
5381 public <T> void asyncRequest(Read<T> request, final Listener<T> procedure) {
5382 asyncRequest(request, new NoneToAsyncListener<T>(procedure));
5386 public <T> void asyncRequest(final Read<T> request, final AsyncProcedure<T> procedure) {
5388 assert (request != null);
5389 assert (procedure != null);
5391 final ListenerBase listener = getListenerBase(procedure);
5393 if (parent != null || listener != null) {
5396 QueryCache.runnerReadEntry(this, request, parent, listener, procedure);
5397 //processor.query(this, request, parent, procedure,listener);
5398 } catch (DatabaseException e) {
5399 Logger.defaultLogError(e);
5400 // This throwable has already been transferred to procedure at this point - do nothing about it
5406 // final ReadGraphImpl newGraph = newSync();
5410 T result = request.perform(this);
5413 procedure.execute(this, result);
5414 } catch (Throwable t) {
5415 Logger.defaultLogError(t);
5418 } catch (Throwable t) {
5421 procedure.exception(this, t);
5422 } catch (Throwable t2) {
5423 Logger.defaultLogError(t2);
5434 public static ReadGraphImpl createAsync(QueryProcessor support) {
5435 return new ReadGraphImpl(null, support);
5438 public static ReadGraphImpl forRecompute(CacheEntry entry, QueryProcessor support) {
5439 return new ReadGraphImpl(entry, support);
5443 public <T> void asyncRequest(Read<T> request, SyncProcedure<T> procedure) {
5444 asyncRequest(request, new SyncToAsyncProcedure<T>(procedure));
5448 public <T> void asyncRequest(Read<T> request, final Procedure<T> procedure) {
5449 asyncRequest(request, new NoneToAsyncProcedure<T>(procedure));
5453 final public <T> void asyncRequest(final AsyncRead<T> request) {
5455 assert (request != null);
5457 asyncRequest(request, new AsyncProcedure<T>() {
5460 public void execute(AsyncReadGraph graph, T result) {
5464 public void exception(AsyncReadGraph graph, Throwable t) {
5465 Logger.defaultLogError(t);
5469 public String toString() {
5470 return "asyncRequest(AsyncRead) -> " + request;
5478 public <T> void asyncRequest(AsyncRead<T> request,
5479 AsyncListener<T> procedure) {
5480 asyncRequest(request, (AsyncProcedure<T>) procedure);
5484 final public <T> void asyncRequest(AsyncRead<T> request,
5485 final SyncListener<T> procedure) {
5486 asyncRequest(request, new SyncToAsyncListener<T>(procedure));
5490 final public <T> void asyncRequest(AsyncRead<T> request,
5491 final Listener<T> procedure) {
5492 asyncRequest(request, new NoneToAsyncListener<T>(procedure));
5496 final public <T> void asyncRequest(final AsyncRead<T> request,
5497 final AsyncProcedure<T> procedure) {
5499 assert (request != null);
5500 assert (procedure != null);
5502 final ListenerBase listener = getListenerBase(procedure);
5504 if (parent != null || listener != null) {
5507 QueryCache.runnerAsyncReadEntry(this, request, parent, listener, procedure);
5508 //processor.query(this, request, parent, procedure, listener);
5509 } catch (DatabaseException e) {
5510 Logger.defaultLogError(e);
5517 request.perform(this, new CallWrappedSingleQueryProcedure4<T>(procedure, request));
5519 } catch (Throwable t) {
5521 if (t instanceof DatabaseException)
5522 procedure.exception(this, t);
5527 new DatabaseException(
5528 "Unexpected exception in ReadGraph.asyncRequest(SingleAsyncRead, SingleProcedure)",
5538 public <T> void asyncRequest(AsyncRead<T> request,
5539 SyncProcedure<T> procedure) {
5540 asyncRequest(request, new SyncToAsyncProcedure<T>(procedure));
5544 final public <T> void asyncRequest(final AsyncRead<T> request,
5545 final Procedure<T> procedure) {
5546 asyncRequest(request, new NoneToAsyncProcedure<T>(procedure));
5550 public <T> void asyncRequest(final MultiRead<T> request) {
5552 assert (request != null);
5554 asyncRequest(request, new AsyncMultiProcedureAdapter<T>() {
5556 public void exception(AsyncReadGraph graph, Throwable t) {
5557 Logger.defaultLogError(t);
5561 public String toString() {
5562 return "asyncRequest(MultiRead) -> " + request;
5569 public <T> void asyncRequest(MultiRead<T> request,
5570 AsyncMultiListener<T> procedure) {
5571 asyncRequest(request, (AsyncMultiProcedure<T>) procedure);
5575 public <T> void asyncRequest(MultiRead<T> request,
5576 SyncMultiListener<T> procedure) {
5577 asyncRequest(request, new SyncToAsyncMultiListener<T>(procedure));
5581 public <T> void asyncRequest(MultiRead<T> request,
5582 MultiListener<T> procedure) {
5583 asyncRequest(request, new NoneToAsyncMultiListener<T>(procedure));
5587 public <T> void asyncRequest(final MultiRead<T> request,
5588 final AsyncMultiProcedure<T> procedure) {
5590 assert (request != null);
5591 assert (procedure != null);
5593 final ListenerBase listener = getListenerBase(procedure);
5595 if (parent != null || listener != null) {
5597 // final ReadGraphImpl newGraph = newSync();
5598 processor.query(this, request, parent, procedure,listener);
5602 // final ReadGraphImpl newGraph = newSync();
5606 request.perform(this, procedure);
5608 } catch (Throwable t) {
5610 procedure.exception(this, t);
5619 public <T> void asyncRequest(MultiRead<T> request,
5620 SyncMultiProcedure<T> procedure) {
5621 asyncRequest(request, new SyncToAsyncMultiProcedure<T>(procedure));
5625 public <T> void asyncRequest(MultiRead<T> request,
5626 MultiProcedure<T> procedure) {
5627 asyncRequest(request, new NoneToAsyncMultiProcedure<T>(procedure));
5631 final public <T> void asyncRequest(final AsyncMultiRead<T> request) {
5633 assert (request != null);
5635 asyncRequest(request, new AsyncMultiProcedureAdapter<T>() {
5637 public void exception(AsyncReadGraph graph, Throwable t) {
5638 Logger.defaultLogError(t);
5642 public String toString() {
5643 return "asyncRequest(AsyncMultiRead) -> " + request;
5650 public <T> void asyncRequest(AsyncMultiRead<T> request,
5651 AsyncMultiListener<T> procedure) {
5652 asyncRequest(request, (AsyncMultiProcedure<T>) procedure);
5656 public <T> void asyncRequest(AsyncMultiRead<T> request,
5657 SyncMultiListener<T> procedure) {
5658 asyncRequest(request, new SyncToAsyncMultiListener<T>(procedure));
5662 public <T> void asyncRequest(AsyncMultiRead<T> request,
5663 MultiListener<T> procedure) {
5664 asyncRequest(request, new NoneToAsyncMultiListener<T>(procedure));
5668 final public <T> void asyncRequest(AsyncMultiRead<T> request,
5669 final AsyncMultiProcedure<T> procedure) {
5671 assert (request != null);
5672 assert (procedure != null);
5674 ListenerBase listener = getListenerBase(procedure);
5676 if (parent != null || listener != null) {
5678 processor.query(this, request, parent, procedure, listener);
5684 request.perform(this, new AsyncMultiProcedure<T>() {
5687 public void execute(AsyncReadGraph graph, T result) {
5688 procedure.execute(graph, result);
5692 public void finished(AsyncReadGraph graph) {
5693 procedure.finished(graph);
5697 public void exception(AsyncReadGraph graph, Throwable t) {
5698 procedure.exception(graph, t);
5702 public String toString() {
5703 return "asyncRequest(AsyncMultiRead) -> " + procedure;
5708 } catch (Throwable t) {
5710 procedure.exception(this, new DatabaseException(t));
5718 public <T> void asyncRequest(AsyncMultiRead<T> request,
5719 SyncMultiProcedure<T> procedure) {
5720 asyncRequest(request, new SyncToAsyncMultiProcedure<T>(procedure));
5724 final public <T> void asyncRequest(AsyncMultiRead<T> request,
5725 final MultiProcedure<T> procedure) {
5726 asyncRequest(request, new NoneToAsyncMultiProcedure<T>(procedure));
5730 final public <T> void asyncRequest(final ExternalRead<T> request) {
5732 assert (request != null);
5734 asyncRequest(request, new Procedure<T>() {
5737 public void execute(T result) {
5741 public void exception(Throwable t) {
5742 Logger.defaultLogError(t);
5746 public String toString() {
5747 return "asyncRequest(PrimitiveRead) -> " + request;
5755 public <T> void asyncRequest(ExternalRead<T> request,
5756 final Listener<T> procedure) {
5757 asyncRequest(request, (Procedure<T>) procedure);
5761 final public <T> void asyncRequest(final ExternalRead<T> request,
5762 final Procedure<T> procedure) {
5764 assert (request != null);
5765 assert (procedure != null);
5767 ListenerBase listener = getListenerBase(procedure);
5769 if (parent != null || listener != null) {
5771 processor.query(this, request, parent, procedure, listener);
5777 request.register(this, new Listener<T>() {
5780 public void execute(T result) {
5781 procedure.execute(result);
5785 public void exception(Throwable t) {
5786 procedure.exception(t);
5790 public String toString() {
5791 return "asyncRequest(PrimitiveRead) -> " + request;
5795 public boolean isDisposed() {
5801 } catch (Throwable t) {
5803 if (t instanceof DatabaseException)
5804 procedure.exception(t);
5807 .exception(new DatabaseException(
5808 "Unexpected exception in ReadGraph.asyncRequest(SingleAsyncRead, SingleProcedure)",
5818 public void asyncRequest(final Write request) {
5820 assert (request != null);
5822 getSession().asyncRequest(request);
5824 // processor.asyncWrite(request);
5829 public <T> void asyncRequest(final WriteResult<T> request, Procedure<T> procedure) {
5830 throw new Error("Not implemented.");
5834 public void asyncRequest(Write request, Consumer<DatabaseException> callback) {
5836 assert (request != null);
5838 getSession().asyncRequest(request, callback);
5843 public void asyncRequest(final DelayedWrite request) {
5845 assert (request != null);
5847 getSession().asyncRequest(request);
5852 public <T> void asyncRequest(final DelayedWriteResult<T> request, Procedure<T> procedure) {
5853 throw new Error("Not implemented.");
5857 public void asyncRequest(DelayedWrite r,
5858 Consumer<DatabaseException> callback) {
5859 throw new Error("Not implemented.");
5863 public void asyncRequest(final WriteOnly request) {
5865 assert (request != null);
5867 getSession().asyncRequest(request);
5872 public <T> void asyncRequest(final WriteOnlyResult<T> request, Procedure<T> procedure) {
5873 throw new Error("Not implemented.");
5877 public void asyncRequest(WriteOnly r, Consumer<DatabaseException> callback) {
5878 throw new Error("Not implemented.");
5882 * Implementation of the interface ServiceLocator
5886 public <T> T getService(Class<T> api) {
5887 if(WriteSupport.class == api) {
5888 if(this instanceof WriteGraphImpl) {
5889 WriteGraphImpl impl = (WriteGraphImpl)this;
5890 return (T)impl.writeSupport;
5893 return getSession().getService(api);
5897 public <T> T peekService(Class<T> api) {
5898 return getSession().peekService(api);
5902 public boolean hasService(Class<?> api) {
5903 return getSession().hasService(api);
5907 public <T> void registerService(Class<T> api, T service) {
5908 getSession().registerService(api, service);
5912 public boolean isImmutable(Resource resource) throws DatabaseException {
5913 ResourceImpl impl = (ResourceImpl)resource;
5914 return processor.isImmutable(impl.id);
5921 protected static String INTERNAL_ERROR_STRING = "Transaction aborted due to internal client error. Contact application support.";
5924 * callerThread is the currently running thread state.syncThread is blocking for
5925 * this execution state.syncParent is the blocking request
5928 final private boolean isExternal(int thread) {
5929 return thread == Integer.MIN_VALUE;
5932 // final private boolean isSync(int thread) {
5933 // return thread < -1 && thread > Integer.MIN_VALUE;
5936 ReadGraphImpl(ReadGraphImpl graph) {
5937 this(graph.parent, graph.processor);
5940 ReadGraphImpl(CacheEntry parent, QueryProcessor support) {
5941 // this.state = new ReadGraphState(barrier, support);
5942 this.parent = parent;
5943 this.processor = support;
5946 ReadGraphImpl(final QueryProcessor support) {
5948 // this.state = state;
5949 this.processor = support;
5954 // public static ReadGraphImpl createSync(int syncThread, Object syncParent,
5955 // ReadGraphSupportImpl support) {
5956 // return new ReadGraphImpl(syncThread, syncThread, syncParent, null,
5957 // support, new AsyncBarrierImpl(null));
5960 public static ReadGraphImpl create(QueryProcessor support) {
5961 return new ReadGraphImpl(support);
5964 // public ReadGraphImpl newAsync() {
5966 //// if(!state.synchronizedExecution) {
5969 //// return new ReadGraphImpl(false, parent, state.support, state.barrier);
5973 // public ReadGraphImpl newSync() {
5974 // return new ReadGraphImpl(parent, processor);
5977 public ReadGraphImpl newSync(CacheEntry parentEntry) {
5978 return new ReadGraphImpl(parentEntry, processor);
5981 public ReadGraphImpl newRestart(ReadGraphImpl impl) {
5983 WriteGraphImpl write = processor.getSession().getService(
5984 WriteGraphImpl.class);
5986 // if (write.callerThread != impl.callerThread)
5987 // return new WriteGraphImpl(impl.callerThread, parent, state.support, write.writeSupport, write.provider, write.state.barrier);
5992 // public ReadGraphImpl newSync(Object parentRequest) {
5993 // return new ReadGraphImpl(callerThread, state.parent, state.support, new AsyncBarrierImpl(state.barrier));
5996 // public ReadGraphImpl newSync(final int callerThread, Object parentRequest) {
5997 // assert (state.syncThread == callerThread || (state.syncThread == Integer.MIN_VALUE && callerThread != Integer.MIN_VALUE));
5998 // return new ReadGraphImpl(callerThread, callerThread, parentRequest,
5999 // state.parent, state.support, new AsyncBarrierImpl(state.barrier));
6002 // public ReadGraphImpl newSyncAsync(Object parentRequest) {
6003 //// assert (callerThread < 0);
6004 // return new ReadGraphImpl(callerThread, state.syncThread, parentRequest,
6005 // state.parent, state.support, new AsyncBarrierImpl(state.barrier));
6008 // public ReadGraphImpl newSyncAsync(final int callerThread,
6009 // Object parentRequest) {
6010 //// assert (callerThread < 0);
6011 // // assert(state.syncThread == callerThread || (state.syncThread == Integer.MIN_VALUE
6012 // // && callerThread != Integer.MIN_VALUE) );
6013 // return new ReadGraphImpl(callerThread, callerThread, parentRequest,
6014 // state.parent, state.support, new AsyncBarrierImpl(state.barrier));
6017 public ReadGraphImpl withAsyncParent(CacheEntry parent) {
6018 return new ReadGraphImpl(parent, processor);
6021 public ReadGraphImpl withParent(CacheEntry parent) {
6022 if(parent == this.parent) return this;
6023 else return new ReadGraphImpl(parent, processor);
6026 final private ListenerBase getListenerBase(final Object procedure) {
6027 if (procedure instanceof ListenerBase)
6028 return (ListenerBase) procedure;
6033 public <T> void waitAsyncProcedure(AsyncMultiReadProcedure<T> procedure) {
6035 assert(procedure.done());
6037 // while (!procedure.done()) {
6039 // boolean executed = processor.resumeTasks(callerThread, null, null);
6043 // // sema.tryAcquire(1, TimeUnit.MILLISECONDS);
6044 // } catch (InterruptedException e) {
6045 // e.printStackTrace();
6053 public <T> void waitAsyncProcedure(AsyncReadProcedure<T> procedure) {
6055 assert(procedure.done());
6057 // while (!procedure.done()) {
6059 // boolean executed = processor.processor.resume(this);
6063 // // sema.tryAcquire(1, TimeUnit.MILLISECONDS);
6064 // } catch (InterruptedException e) {
6065 // e.printStackTrace();
6073 // public void waitAsync(Object request) {
6075 // state.barrier.waitBarrier(request, this);
6076 // } catch (Throwable t) {
6077 // t.printStackTrace();
6078 // processor.scanPending();
6079 // processor.querySupport.checkTasks();
6080 // throw new RuntimeDatabaseException(t);
6084 // public void restart() {
6085 // state.barrier.restart();
6088 public boolean resumeTasks() {
6089 return processor.resumeTasks(this);
6092 Class<?> singleClass(Set<Resource> types) {
6093 Class<?> result = null;
6094 for (Resource type : types) {
6095 Class<?> clazz = processor.getBuiltinValue(type);
6096 if (clazz != null) {
6106 private String debugString(Resource r) {
6109 name = getPossibleRelatedValue(r, processor.getL0(this).HasName);
6110 } catch (ManyObjectsForFunctionalRelationException e) {
6111 Logger.defaultLogError(e);
6112 } catch (ServiceException e) {
6113 Logger.defaultLogError(e);
6115 return "[" + name + " - " + r + "]";
6119 public String toString() {
6120 return "ReadGraphImpl[thread=" + Thread.currentThread() + "]";
6124 final public int thread() {
6128 static class MultiTripleIntProcedure implements TripleIntProcedure {
6130 final private AsyncMultiProcedure<Statement> procedure;
6131 final private ReadGraphImpl impl;
6132 final private QuerySupport support;
6134 public MultiTripleIntProcedure(AsyncMultiProcedure<Statement> procedure, ReadGraphImpl impl, QuerySupport support) {
6135 this.procedure = procedure;
6137 this.support = support;
6141 public void execute(ReadGraphImpl graph, int s, int p, int o) {
6143 procedure.execute(graph, support.getStatement(s, p, o));
6144 } catch (Throwable t2) {
6145 Logger.defaultLogError(t2);
6150 public void finished(ReadGraphImpl graph) {
6152 procedure.finished(graph);
6153 // impl.state.barrier.dec("ReadGraphSupportImpl.516");
6154 } catch (Throwable t2) {
6155 Logger.defaultLogError(t2);
6160 public void exception(ReadGraphImpl graph, Throwable t) {
6162 procedure.exception(graph, t);
6163 } catch (Throwable t2) {
6164 Logger.defaultLogError(t2);
6166 // impl.state.barrier.dec("ReadGraphSupportImpl.516");
6170 public String toString() {
6171 return "forEachObject with " + procedure;
6176 // private AsyncMultiProcedure<Resource> cacheKey = null;
6177 // private MultiIntProcedure cacheResult = null;
6179 // final IntProcedure forMultiProcedure(final AsyncMultiProcedure<Resource> procedure) {
6181 // if(procedure == cacheKey) return cacheResult;
6183 // cacheResult = new MultiIntProcedure(procedure, this, processor.support);
6184 // cacheKey = procedure;
6186 // return cacheResult;
6190 // private AsyncMultiProcedure<Statement> cacheKey2 = null;
6191 // private MultiTripleIntProcedure cacheResult2 = null;
6193 // final synchronized TripleIntProcedure forMultiProcedure(final AsyncMultiProcedure<Statement> procedure) {
6195 // if(procedure == cacheKey2) return cacheResult2;
6197 // cacheResult2 = new MultiTripleIntProcedure(procedure, this, processor.support);
6198 // cacheKey2 = procedure;
6200 // return cacheResult2;
6205 public Datatype getDataType(Resource subject) throws DatabaseException {
6206 for(Resource dataTypeResource : getObjects(subject, processor.getL0(this).HasDataType))
6207 return getValue(dataTypeResource, Bindings.getBindingUnchecked(Datatype.class));
6208 throw new DoesNotContainValueException("The literal has no data type.");
6211 protected <T extends Accessor> T getAccessor4File(Resource subject)
6212 throws DatabaseException {
6215 byte[] bytes = processor.support.getValue(g, subject);
6219 BinaryVariant va = (BinaryVariant) Accessors.getAccessor(bytes, Datatypes.VARIANT);
6220 Accessor ca = va.getContentAccessor();
6222 } catch (AccessorConstructionException e) {
6223 throw new DatabaseException(e);
6229 Binding datatype_binding = Bindings.getBindingUnchecked(DataType.class);
6230 Serializer datatype_serializer = datatype_binding.serializer();
6233 BinaryMemory in = new BinaryMemory(ByteBuffer.wrap(bytes));
6234 datatype = (DataType)datatype_serializer.deserialize(in);
6235 Binding data_binding = Bindings.getBinding(datatype);
6236 Serializer data_serializer = data_binding.serializer(BinarySerializationFormat.INSTANCE);
6237 Object o = data_serializer.deserialize(in);
6239 return (T)Accessors.getAccessor(data_binding, o);
6240 } catch(AccessorConstructionException e) {
6243 } catch (Exception e) {
6244 throw new DatabaseException(e);
6247 @SuppressWarnings("unchecked")
6249 public <T extends Accessor> T getAccessor(Resource subject) throws DatabaseException {
6250 RandomAccessBinary rab = getRandomAccessBinary(subject);
6252 return (T)Accessors.getAccessor(rab, getDataType(subject));
6253 } catch(AccessorConstructionException e) {
6254 throw new DatabaseException(e);
6257 @SuppressWarnings("unchecked")
6258 protected <T extends Accessor> T createAccessor(Resource resource, Datatype datatype, Object intialValue)
6259 throws DatabaseException {
6260 RandomAccessBinary rab = createRandomAccessBinary(resource, datatype, intialValue);
6262 return (T)Accessors.getAccessor(rab, datatype);
6263 } catch(AccessorConstructionException e) {
6264 throw new DatabaseException(e);
6268 public RandomAccessBinary getRandomAccessBinary(Resource subject) throws DatabaseException {
6269 RandomAccessValueSupport ravs = getSession().getService(RandomAccessValueSupport.class);
6270 ResourceData rd = ravs.get(subject);
6274 ExternalValueSupport evs = getService(ExternalValueSupport.class);
6275 long size = evs.getValueSize(this, subject); // Throws DatabaseException if no old external value.
6277 File platform = Platform.getLocation().toFile();
6278 File tempFiles = new File(platform, "tempFiles");
6279 File dbDir = new File(tempFiles, "db");
6281 File file = new File(dbDir, "ResourceFile" + subject.getResourceId());
6282 rd = new ResourceData(new BinaryFile(file), true); // Old external value.
6283 final int N = 1<<20;
6287 int length = N < left ? N : (int)left;
6288 byte[] bytes = evs.readValue(this, subject, offset, length);
6289 offset += bytes.length;
6290 left -= bytes.length;
6291 rd.binaryFile.write(bytes);
6293 ravs.put(subject, rd);
6295 } catch (Exception e) {
6296 throw new DatabaseException("Resource " + subject + " have value but there was problem with accessing value data.", e);
6298 } catch (Exception e) {
6299 if(Development.DEVELOPMENT) {
6300 if(Development.<Boolean>getProperty(DevelopmentKeys.WRITEGRAPH_EXCEPTION_STACKTRACES, Bindings.BOOLEAN)) {
6301 e.printStackTrace();
6305 Datatype datatype = getDataType(subject);
6306 Object value = getPossibleValue(subject, Bindings.getBinding(datatype));
6307 return createRandomAccessBinary(subject, datatype, value);
6309 public RandomAccessBinary createRandomAccessBinary(Resource resource, Datatype datatype, Object initialValue)
6310 throws DatabaseException {
6311 RandomAccessValueSupport ravs = getSession().getService(RandomAccessValueSupport.class);
6313 File platform = Platform.getLocation().toFile();
6314 File tempFiles = new File(platform, "tempFiles");
6315 File dbDir = new File(tempFiles, "db");
6317 File file = new File(dbDir, "ResourceFile" + resource.getResourceId());
6318 ResourceData rd = new ResourceData(new BinaryFile(file), false);
6319 Binding binding = Bindings.getBinding(datatype);
6320 if (null == initialValue) {
6321 initialValue = binding.createDefault();
6323 Serializer serializer = binding.serializer();
6324 byte[] bytes = serializer.serialize(initialValue);
6325 rd.binaryFile.write(bytes);
6326 ravs.put(resource, rd);
6328 } catch (Exception e) {
6329 if (e instanceof DatabaseException)
6330 throw (DatabaseException)e;
6332 throw new DatabaseException(e);
6336 // static class ExternalValueRequest<T> extends ResourceRead<T> {
6338 // public ExternalValueRequest(Resource resource) {
6342 // @SuppressWarnings("unchecked")
6344 // public T perform(ReadGraph graph) throws DatabaseException {
6347 // String uri = graph.getURI(resource);
6348 // if(Layer0.URIs.Functions_functionApplication.equals(uri)) return (T)functionApplication;
6350 // return (T)ReflectionUtils.getValue(uri).getValue();
6352 // } catch(ValueNotFoundException e) {
6353 // throw new DatabaseException("Couldn't convert to external value (r=" + resource + ")", e);
6354 // } catch(ClassCastException e) {
6355 // throw new DatabaseException("Couldn't convert to external value (r=" + resource + ")", e);
6361 @SuppressWarnings("unchecked")
6363 public <T> T getValue2(Resource r, Object context) throws DatabaseException {
6364 Layer0 L0 = processor.getL0(this);
6365 Set<Resource> types = getTypes(r);
6367 if(types.contains(L0.Literal)) {
6368 if(isImmutable(r)) {
6369 return syncRequest(new ValueImplied<T>(r));
6374 else if(types.contains(L0.ExternalValue)) {
6375 return (T)syncRequest(new AdaptValue(r), TransientCacheListener.<Object>instance());
6379 Function3<ReadGraph,Resource,Object,T> function = requestValueFunction(r);
6380 if(function == null) throw new DoesNotContainValueException("Couldn't convert to a value function " + r);
6382 return function.apply(this, r, context);
6383 } catch(RuntimeException e) {
6384 DatabaseException dte = findPossibleRootException(e);
6385 if(dte != null) throw dte;
6386 else throw new DatabaseException(e);
6393 public Variant getVariantValue2(Resource r, Object context) throws DatabaseException {
6394 Layer0 L0 = processor.getL0(this);
6395 Set<Resource> types = getTypes(r);
6397 if(types.contains(L0.Literal)) {
6398 if(isImmutable(r)) {
6399 return syncRequest(new VariantValueImplied(r));
6401 return getVariantValue(r);
6404 else if(types.contains(L0.ExternalValue)) {
6405 Object value = syncRequest(new AdaptValue(r), TransientCacheListener.<Object>instance());
6407 return new Variant(Bindings.OBJECT.getContentBinding(value), value);
6408 } catch ( org.simantics.databoard.binding.error.BindingException e ) {
6409 throw new BindingException( "No binding found for class " + value.getClass().getName(), e );
6414 Function3<ReadGraph,Resource,Object,Object> function = requestValueFunction(r);
6415 if(function == null) throw new DoesNotContainValueException("Couldn't convert to a value function " + r);
6417 Object value = function.apply(this, r, context);
6419 return new Variant(Bindings.OBJECT.getContentBinding(value), value);
6420 } catch ( org.simantics.databoard.binding.error.BindingException e ) {
6421 throw new BindingException( "No binding found for class " + value.getClass().getName(), e );
6423 } catch(RuntimeException e) {
6424 DatabaseException dte = findPossibleRootException(e);
6425 if(dte != null) throw dte;
6426 else throw new DatabaseException(e);
6432 public <T> T getPossibleValue2(Resource subject, Object context) throws DatabaseException {
6434 return getValue2(subject, context);
6435 } catch (DatabaseException e) {
6440 static class PossibleConverterFunction<T> extends ResourceRead<Function3<ReadGraph,Resource,Object,T>> {
6442 public PossibleConverterFunction(Resource resource) {
6447 public Function3<ReadGraph,Resource,Object,T> perform(ReadGraph graph) throws DatabaseException {
6448 return compute(graph, resource);
6451 @SuppressWarnings("unchecked")
6452 public static <T> Function3<ReadGraph,Resource,Object,T> compute(ReadGraph graph, Resource resource) throws DatabaseException {
6453 Layer0 L0 = Layer0.getInstance(graph);
6454 for(Resource converter : graph.getObjects(resource, L0.ConvertsToValueWith)) {
6456 if(L0.Functions_functionApplication.equals(converter)) {
6457 return AdaptValue.functionApplication;
6458 //return (Function3<ReadGraph,Resource,Object,T>)graph.syncRequest(new AdaptValue(resource));
6460 return graph.getValue2(converter, resource);
6462 } catch(RuntimeException e) {
6463 DatabaseException dte = findPossibleRootException(e);
6464 if(dte != null) throw dte;
6465 else throw new DatabaseException(e);
6473 <T> Function3<ReadGraph,Resource,Object,T> requestValueFunction(Resource r) throws DatabaseException {
6475 return syncRequest(new PossibleConverterFunction<T>(r), TransientCacheAsyncListener.<Function3<ReadGraph,Resource,Object,T>>instance());
6477 return syncRequest(new PossibleConverterFunction<T>(r));
6481 * Get a value associated with a graph {@link Resource}, using a possible context object and
6482 * a desired value binding. The following methods are tried in order to retreive the value:
6484 * <li>If the given resource is a {@code L0.Literal}, the value of the literal is returned, using the binding specified by {@code binding}.</li>
6485 * <li>If the resource is a {@code L0.ExternalValue}, the value is acquired using
6486 * {@link ReflectionUtils#getValue(String)}.</li>
6487 * <li>If the resource is associated with a suitable value converter with relation {@code L0.ConvertsToValueWith}
6488 * (see {@link #requestValueFunction(Resource)}), the value function is called with the graph, the resource
6489 * and the context object.</li>
6492 * @param r A graph resource with which the value is associated
6493 * @param context A context object that is used for acquiring the value (only applied in case 3)
6494 * @param binding A binding for the value type (only applied in case 1)
6495 * @return The value of the graph node.
6496 * @throws DoesNotContainValueException No value is associated with the graph node.
6497 * @throws DatabaseException Other errors, such as an error in casting the value to the return type or
6498 * a runtime error in the value function.
6500 @SuppressWarnings("unchecked")
6502 public <T> T getValue2(Resource r, Object context, Binding binding) throws DatabaseException {
6503 if (binding instanceof ObjectVariantBinding)
6504 return getValue2(r, context);
6506 Layer0 L0 = processor.getL0(this);
6507 Set<Resource> types = getTypes(r);
6508 if(types.contains(L0.Literal)) {
6509 if(isImmutable(r)) {
6510 return syncRequest(new Value<T>(r, binding));
6512 return getValue(r, binding);
6514 } else if(types.contains(L0.ExternalValue)) {
6516 ExternalValue ev = adapt(r, ExternalValue.class);
6517 return ev.getValue(this, r);
6518 //return (T)ReflectionUtils.getValue(getURI(r)).getValue();
6519 // } catch(ValueNotFoundException e) {
6520 // throw new DatabaseException(e);
6521 } catch(ClassCastException e) {
6522 throw new DatabaseException(e);
6526 Function3<ReadGraph,Resource,Object,T> function = requestValueFunction(r);
6527 if(function == null) throw new DoesNotContainValueException("Couldn't convert to a value function.");
6529 Object value = function.apply(this, r, context);
6530 if(binding.isInstance(value)) return (T)value;
6531 Binding srcBinding = Bindings.OBJECT.getContentBinding(value);
6532 return (T)Bindings.adapt(value, srcBinding, binding);
6533 } catch(RuntimeException e) {
6534 DatabaseException dte = findPossibleRootException(e);
6535 if(dte != null) throw dte;
6536 else throw new DatabaseException(e);
6537 } catch (AdaptException e) {
6538 throw new DatabaseException(e);
6539 } catch (org.simantics.databoard.binding.error.BindingException e) {
6540 throw new DatabaseException(e);
6546 public <T> T getPossibleValue2(Resource subject, Object context, Binding binding) throws DatabaseException {
6548 return getValue2(subject, context, binding);
6549 } catch (DatabaseException e) {
6554 private static DatabaseException findPossibleRootException(Throwable t) {
6555 if(t == null) return null;
6556 if(t instanceof DatabaseException) return (DatabaseException)t;
6557 if(t instanceof RuntimeException || t instanceof InvocationTargetException) {
6558 return findPossibleRootException(t.getCause());
6564 public <T> T getRelatedValue2(Resource subject, Resource relation) throws DatabaseException {
6565 return getRelatedValue2(subject, relation, subject);
6569 public Variant getRelatedVariantValue2(Resource subject, Resource relation) throws DatabaseException {
6570 return getRelatedVariantValue2(subject, relation, subject);
6574 public <T> T getPossibleRelatedValue2(Resource subject, Resource relation) throws DatabaseException {
6576 Resource object = getPossibleObject(subject, relation);
6577 if(object == null) return null;
6578 else return getValue2(object, subject);
6579 } catch (DatabaseException e) {
6585 public <T> T getRelatedValue2(Resource subject, Resource relation, Object context) throws DatabaseException {
6586 if(Development.DEVELOPMENT) {
6587 String error = L0Validations.checkValueType(this, subject, relation);
6589 Logger.defaultLogError(new ValidationException(error));
6590 //throw new ValidationException(error);
6591 new ValidationException(error).printStackTrace();
6594 return getValue2(getSingleObject(subject, relation), context);
6598 public Variant getRelatedVariantValue2(Resource subject, Resource relation, Object context) throws DatabaseException {
6599 if(Development.DEVELOPMENT) {
6600 String error = L0Validations.checkValueType(this, subject, relation);
6602 Logger.defaultLogError(new ValidationException(error));
6603 //throw new ValidationException(error);
6604 new ValidationException(error).printStackTrace();
6607 return getVariantValue2(getSingleObject(subject, relation), context);
6611 public <T> T getPossibleRelatedValue2(Resource subject, Resource relation, Object context) throws DatabaseException {
6613 Resource object = getPossibleObject(subject, relation);
6614 if(object == null) return null;
6615 else return getValue2(object, context);
6616 } catch (DatabaseException e) {
6622 public <T> T getRelatedValue2(Resource subject, Resource relation, Binding binding) throws DatabaseException {
6623 return getRelatedValue2(subject, relation, subject, binding);
6627 public <T> T getPossibleRelatedValue2(Resource subject, Resource relation, Binding binding) throws DatabaseException {
6629 Resource object = getPossibleObject(subject, relation);
6630 if(object == null) return null;
6631 return getValue2(object, subject, binding);
6632 } catch (DatabaseException e) {
6638 public <T> T getRelatedValue2(Resource subject, Resource relation, Object context, Binding binding) throws DatabaseException {
6639 return getValue2(getSingleObject(subject, relation), context, binding);
6643 public <T> T getPossibleRelatedValue2(Resource subject, Resource relation, Object context, Binding binding) throws DatabaseException {
6645 Resource object = getPossibleObject(subject, relation);
6646 if(object == null) return null;
6647 else return getValue2(object, context, binding);
6648 } catch (DatabaseException e) {
6654 public Type getRelatedValueType(Resource subject, Resource relation) throws DatabaseException {
6655 Layer0 L0 = processor.getL0(this);
6656 Resource property = getSingleObject(subject, relation);
6657 String typeText = (String)getRelatedValue(property, L0.HasValueType, Bindings.STRING);
6659 return org.simantics.scl.compiler.types.Types.parseType(typeText);
6660 } catch (SCLTypeParseException e) {
6661 throw new DatabaseException(e);
6666 public boolean setSynchronous(boolean value) {
6667 boolean old = processor.synch;
6668 processor.synch = value;
6673 public boolean getSynchronous() {
6674 return processor.synch;
6677 public void ensureLoaded(int resource) {
6678 processor.querySupport.ensureLoaded(this, resource);
6681 public void ensureLoaded(int resource, int predicate) {
6682 processor.querySupport.ensureLoaded(this, resource, predicate);
6685 public byte[] getValue(int resource) {
6686 return processor.querySupport.getValue(this, resource);
6689 public int thread(int resource) {
6690 return (resource >>> 16) & processor.THREAD_MASK;
6693 public int thread(Resource resource) {
6694 return (((ResourceImpl)resource).id >>> 16) & processor.THREAD_MASK;
6697 public ResourceSupport getResourceSupport() {
6698 return processor.getResourceSupport();
6702 public Object getModificationCounter() {
6703 return processor.getSession().getModificationCounter();