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.Functions;
116 import org.simantics.db.common.utils.Logger;
117 import org.simantics.db.common.utils.NameUtils;
118 import org.simantics.db.common.validation.L0Validations;
119 import org.simantics.db.exception.AdaptionException;
120 import org.simantics.db.exception.ArgumentException;
121 import org.simantics.db.exception.AssumptionException;
122 import org.simantics.db.exception.BindingException;
123 import org.simantics.db.exception.DatabaseException;
124 import org.simantics.db.exception.DoesNotContainValueException;
125 import org.simantics.db.exception.EmptyResourceException;
126 import org.simantics.db.exception.InternalException;
127 import org.simantics.db.exception.InvalidLiteralException;
128 import org.simantics.db.exception.ManyObjectsForFunctionalRelationException;
129 import org.simantics.db.exception.NoInverseException;
130 import org.simantics.db.exception.NoSingleResultException;
131 import org.simantics.db.exception.ResourceNotFoundException;
132 import org.simantics.db.exception.ServiceException;
133 import org.simantics.db.exception.ValidationException;
134 import org.simantics.db.impl.RelationContextImpl;
135 import org.simantics.db.impl.ResourceImpl;
136 import org.simantics.db.impl.internal.RandomAccessValueSupport;
137 import org.simantics.db.impl.internal.ResourceData;
138 import org.simantics.db.impl.procedure.CallWrappedSingleQueryProcedure4;
139 import org.simantics.db.impl.procedure.ResultCallWrappedQueryProcedure4;
140 import org.simantics.db.impl.procedure.ResultCallWrappedSingleQueryProcedure4;
141 import org.simantics.db.impl.query.CacheEntry;
142 import org.simantics.db.impl.query.QueryCache;
143 import org.simantics.db.impl.query.QueryCacheBase;
144 import org.simantics.db.impl.query.QueryProcessor;
145 import org.simantics.db.impl.query.QuerySupport;
146 import org.simantics.db.impl.query.TripleIntProcedure;
147 import org.simantics.db.impl.support.ResourceSupport;
148 import org.simantics.db.procedure.AsyncListener;
149 import org.simantics.db.procedure.AsyncMultiListener;
150 import org.simantics.db.procedure.AsyncMultiProcedure;
151 import org.simantics.db.procedure.AsyncProcedure;
152 import org.simantics.db.procedure.AsyncSetListener;
153 import org.simantics.db.procedure.Listener;
154 import org.simantics.db.procedure.ListenerBase;
155 import org.simantics.db.procedure.MultiListener;
156 import org.simantics.db.procedure.MultiProcedure;
157 import org.simantics.db.procedure.Procedure;
158 import org.simantics.db.procedure.SetListener;
159 import org.simantics.db.procedure.StatementProcedure;
160 import org.simantics.db.procedure.SyncListener;
161 import org.simantics.db.procedure.SyncMultiListener;
162 import org.simantics.db.procedure.SyncMultiProcedure;
163 import org.simantics.db.procedure.SyncProcedure;
164 import org.simantics.db.procedure.SyncSetListener;
165 import org.simantics.db.request.AsyncMultiRead;
166 import org.simantics.db.request.AsyncRead;
167 import org.simantics.db.request.DelayedWrite;
168 import org.simantics.db.request.DelayedWriteResult;
169 import org.simantics.db.request.ExternalRead;
170 import org.simantics.db.request.MultiRead;
171 import org.simantics.db.request.Read;
172 import org.simantics.db.request.ReadInterface;
173 import org.simantics.db.request.RequestFlags;
174 import org.simantics.db.request.Write;
175 import org.simantics.db.request.WriteInterface;
176 import org.simantics.db.request.WriteOnly;
177 import org.simantics.db.request.WriteOnlyResult;
178 import org.simantics.db.request.WriteResult;
179 import org.simantics.layer0.Layer0;
180 import org.simantics.scl.compiler.types.Type;
181 import org.simantics.scl.compiler.types.exceptions.SCLTypeParseException;
182 import org.simantics.scl.reflection.ReflectionUtils;
183 import org.simantics.scl.reflection.ValueNotFoundException;
184 import org.simantics.scl.runtime.function.Function1;
185 import org.simantics.scl.runtime.function.Function3;
186 import org.simantics.utils.DataContainer;
187 import org.simantics.utils.Development;
188 import org.simantics.utils.datastructures.Pair;
189 import org.simantics.utils.datastructures.collections.CollectionUtils;
191 import gnu.trove.map.hash.TObjectIntHashMap;
193 public class ReadGraphImpl implements ReadGraph {
195 final static boolean EMPTY_RESOURCE_CHECK = false;
197 final public CacheEntry parent;
198 final public QueryProcessor processor;
200 final static Binding DATA_TYPE_BINDING_INTERNAL = Bindings.getBindingUnchecked(Datatype.class);
201 final static Serializer DATA_TYPE_SERIALIZER = Bindings.getSerializerUnchecked(DATA_TYPE_BINDING_INTERNAL);
203 final public static TObjectIntHashMap<String> counters = new TObjectIntHashMap<String>();
205 public static void resetCounters() {
209 public static String listCounters(File file) throws IOException {
211 PrintStream b = new PrintStream(new BufferedOutputStream(new FileOutputStream(file)));
213 for(Pair<String,Integer> p : CollectionUtils.valueSortedEntries(counters)) {
214 b.print(-p.second + " " + p.first + "\n");
219 return "Dumped " + counters.size() + " queries.";
224 * Implementation of the interface ReadGraph
226 final public String getURI(final Resource resource) throws AssumptionException, ValidationException, ServiceException {
228 assert (resource != null);
232 return syncRequest(new org.simantics.db.common.uri.ResourceToURI(resource));
234 } catch (AssumptionException e) {
236 throw new AssumptionException(e);
238 } catch (ValidationException e) {
240 throw new ValidationException(e);
242 } catch (ServiceException e) {
244 throw new ServiceException(e);
246 } catch (DatabaseException e) {
248 throw new ServiceException(INTERNAL_ERROR_STRING, e);
254 final public String getPossibleURI(final Resource resource) throws ValidationException, ServiceException {
256 assert (resource != null);
260 return syncRequest(new org.simantics.db.common.uri.ResourceToPossibleURI(resource));
262 } catch (ValidationException e) {
264 throw new ValidationException(e);
266 } catch (ServiceException e) {
268 throw new ServiceException(e);
270 } catch (DatabaseException e) {
272 throw new ServiceException(INTERNAL_ERROR_STRING, e);
278 final public Resource getResource(final String id)
279 throws ResourceNotFoundException, ValidationException,
286 return syncRequest(new org.simantics.db.common.primitiverequest.Resource(
289 } catch (ResourceNotFoundException e) {
291 throw new ResourceNotFoundException(id, e);
293 } catch (ValidationException e) {
295 throw new ValidationException(e);
297 } catch (ServiceException e) {
299 throw new ServiceException(e);
301 } catch (DatabaseException e) {
303 throw new ServiceException(INTERNAL_ERROR_STRING, e);
309 final public Resource getPossibleResource(final String id)
310 throws ResourceNotFoundException, ValidationException,
317 return syncRequest(new org.simantics.db.common.primitiverequest.Resource(
320 } catch (ResourceNotFoundException e) {
324 } catch (ValidationException e) {
326 throw new ValidationException(e);
328 } catch (ServiceException e) {
330 throw new ServiceException(e);
332 } catch (DatabaseException e) {
334 throw new ServiceException(INTERNAL_ERROR_STRING, e);
340 final public Resource getRootLibrary() {
341 return processor.getRootLibraryResource();
344 final public Resource getBuiltin(final String id)
345 throws ResourceNotFoundException, ServiceException {
351 return syncRequest(new Builtin(id));
353 } catch (ResourceNotFoundException e) {
355 throw new ResourceNotFoundException(id, e);
357 } catch (ServiceException e) {
359 throw new ServiceException(e);
361 } catch (DatabaseException e) {
363 throw new ServiceException(INTERNAL_ERROR_STRING, e);
369 static class StatementReadProcedure extends TIntArrayListInternal implements StatementProcedure {
371 private static Throwable DONE = new Throwable();
373 Throwable exception = null;
375 final ResourceSupport support;
377 public StatementReadProcedure(ResourceSupport support) {
378 this.support = support;
382 public synchronized void execute(AsyncReadGraph graph, int s, int p, int o) {
389 public void finished(AsyncReadGraph graph) {
394 public void exception(AsyncReadGraph graph, Throwable t) {
398 public void checkAndThrow() throws DatabaseException {
399 if(exception != DONE) {
400 if (exception instanceof DatabaseException)
401 throw (DatabaseException) exception;
403 throw new DatabaseException(
404 "Unexpected exception in ReadGraph.syncRequest(AsyncMultiRead)",
409 public boolean done() {
410 return exception != null;
414 public boolean contains(Object obj) {
415 if(!(obj instanceof InternalStatement))
417 InternalStatement statement = (InternalStatement)obj;
421 for(int i=0;i<sizeInternal();i+=3)
422 if(s==getQuick(i) && p==getQuick(i+1) && o==getQuick(i+2))
427 @SuppressWarnings("unchecked")
429 public <T> T[] toArray(T[] a) {
430 int length = sizeInternal() / 3;
431 if(length > a.length) {
432 Class<?> arrayType = a.getClass();
433 a = (arrayType == Object[].class)
434 ? (T[]) new Object[length]
435 : (T[]) Array.newInstance(arrayType.getComponentType(), length);
438 for(int i=length;i<a.length;++i)
441 for(int i=0,j=0;i<sizeInternal();i+=3,++j)
442 a[j] = (T)new InternalStatement(support, getQuick(i), getQuick(i+1), getQuick(i+2));
447 public boolean add(Statement e) {
448 throw new UnsupportedOperationException();
452 public boolean remove(Object o) {
453 throw new UnsupportedOperationException();
457 public boolean addAll(Collection<? extends Statement> c) {
458 throw new UnsupportedOperationException();
461 class IteratorImpl implements ListIterator<Statement> {
465 public IteratorImpl(int index) {
470 public boolean hasNext() {
471 return index < sizeInternal();
475 public Statement next() {
476 Statement result = new InternalStatement(support, getQuick(index), getQuick(index+1), getQuick(index+2));
482 public void remove() {
483 throw new Error("Not supported");
487 public boolean hasPrevious() {
492 public Statement previous() {
494 Statement result = new InternalStatement(support, getQuick(index), getQuick(index+1), getQuick(index+2));
499 public int nextIndex() {
504 public int previousIndex() {
509 public void set(Statement e) {
510 throw new UnsupportedOperationException();
514 public void add(Statement e) {
515 throw new UnsupportedOperationException();
521 public Iterator<Statement> iterator() {
522 return new IteratorImpl(0);
527 return sizeInternal() / 3;
531 public Object[] toArray() {
532 Object[] result = new Object[sizeInternal() / 3];
533 for(int i=0,j=0;j<sizeInternal();i++,j+=3)
534 result[i] = new InternalStatement(support, getQuick(j), getQuick(j+1), getQuick(j+2));
539 public boolean addAll(int index, Collection<? extends Statement> c) {
540 throw new UnsupportedOperationException();
544 public Statement get(int index) {
546 if(index < 0 || index >= sizeInternal())
547 throw new IndexOutOfBoundsException();
548 return new InternalStatement(support, getQuick(index), getQuick(index+1), getQuick(index+2));
552 public Statement set(int index, Statement element) {
553 throw new UnsupportedOperationException();
557 public void add(int index, Statement element) {
558 throw new UnsupportedOperationException();
562 public Statement remove(int index) {
563 throw new UnsupportedOperationException();
567 public int indexOf(Object obj) {
568 if(!(obj instanceof InternalStatement))
570 InternalStatement statement = (InternalStatement)obj;
574 for(int i=0;i<sizeInternal();i+=3)
575 if(s==getQuick(i) && p==getQuick(i+1) && o==getQuick(i+2))
581 public int lastIndexOf(Object obj) {
582 if(!(obj instanceof InternalStatement))
584 InternalStatement statement = (InternalStatement)obj;
588 for(int i=sizeInternal()-3;i>=0;i-=3)
589 if(s==getQuick(i) && p==getQuick(i+1) && o==getQuick(i+2))
595 public ListIterator<Statement> listIterator() {
596 return new IteratorImpl(0);
600 public ListIterator<Statement> listIterator(int index) {
601 return new IteratorImpl(index*3);
605 public List<Statement> subList(int fromIndex, int toIndex) {
606 if(fromIndex < 0 || toIndex*3 >= sizeInternal() || fromIndex > toIndex)
607 throw new IndexOutOfBoundsException();
608 return new RandomAccessSubList<Statement>(this, fromIndex, toIndex-fromIndex);
613 final public Collection<Statement> getStatements(final Resource subject,
614 final Resource relation)
615 throws ManyObjectsForFunctionalRelationException, ServiceException {
617 assert (subject != null);
618 assert (relation != null);
622 StatementReadProcedure procedure = new StatementReadProcedure(getResourceSupport());
623 processor.forEachStatement(this, subject, relation, procedure);
624 procedure.checkAndThrow();
627 } catch (DatabaseException e) {
629 System.err.println(INTERNAL_ERROR_STRING + " getStatements " + subject + " " + relation);
631 StatementReadProcedure procedure = new StatementReadProcedure(getResourceSupport());
632 processor.forEachStatement(this, subject, relation, procedure);
634 return Collections.emptyList();
636 // throw new ServiceException(INTERNAL_ERROR_STRING + " getStatements " + subject + " " + relation, e);
643 final public Collection<Statement> getAssertedStatements(final Resource subject, final Resource relation)
644 throws ManyObjectsForFunctionalRelationException, ServiceException {
646 assert (subject != null);
647 assert (relation != null);
651 return syncRequest(new ForEachAssertedStatement(subject, relation));
653 } catch (ManyObjectsForFunctionalRelationException e) {
655 throw new ManyObjectsForFunctionalRelationException(e);
657 } catch (ServiceException e) {
659 throw new ServiceException(e);
661 } catch (DatabaseException e) {
663 throw new ServiceException(INTERNAL_ERROR_STRING, e);
670 final public Collection<Resource> getPredicates(final Resource subject) throws ServiceException {
672 assert (subject != null);
676 return processor.getPredicates(this, subject);
678 // AsyncMultiReadProcedure<Resource> procedure = new AsyncMultiReadProcedure<Resource>();
679 // processor.forEachPredicate(this, subject, procedure);
680 // procedure.checkAndThrow();
683 } catch (ServiceException e) {
685 throw new ServiceException(e);
687 } catch (DatabaseException e) {
689 throw new ServiceException(INTERNAL_ERROR_STRING, e);
691 } catch (Throwable e) {
693 throw new ServiceException(e);
700 final public Collection<Resource> getPrincipalTypes(final Resource subject)
701 throws ServiceException {
703 assert (subject != null);
707 AsyncMultiReadProcedure<Resource> procedure = new AsyncMultiReadProcedure<Resource>();
708 processor.forEachPrincipalType(this, subject, procedure);
709 procedure.checkAndThrow();
712 } catch (ServiceException e) {
714 throw new ServiceException(e);
716 } catch (DatabaseException e) {
718 throw new ServiceException(INTERNAL_ERROR_STRING, e);
725 final public Set<Resource> getTypes(final Resource subject) throws ServiceException {
727 assert (subject != null);
731 return processor.getTypes(this, subject);
733 } catch (ServiceException e) {
735 throw new ServiceException(e);
737 } catch (DatabaseException e) {
739 throw new ServiceException(INTERNAL_ERROR_STRING, e);
741 } catch (Throwable e) {
743 throw new ServiceException(e);
750 final public Set<Resource> getSupertypes(final Resource subject)
751 throws ServiceException {
753 assert (subject != null);
757 SyncReadProcedure<Set<Resource>> procedure = new SyncReadProcedure<Set<Resource>>();
758 processor.forSupertypes(this, subject, procedure);
759 procedure.checkAndThrow();
760 return procedure.result;
762 } catch (ServiceException e) {
764 throw new ServiceException(e);
766 } catch (DatabaseException e) {
768 throw new ServiceException(INTERNAL_ERROR_STRING, e);
775 final public Set<Resource> getSuperrelations(final Resource subject)
776 throws ServiceException {
778 assert (subject != null);
782 SyncReadProcedure<Set<Resource>> procedure = new SyncReadProcedure<Set<Resource>>();
783 processor.forSuperrelations(this, subject, procedure);
784 procedure.checkAndThrow();
785 return procedure.result;
787 } catch (ServiceException e) {
789 throw new ServiceException(e);
791 } catch (DatabaseException e) {
793 throw new ServiceException(INTERNAL_ERROR_STRING, e);
800 public Resource getPossibleSuperrelation(Resource subject) throws ServiceException {
804 SyncReadProcedure<Resource> procedure = new SyncReadProcedure<Resource>();
805 processor.forPossibleSuperrelation(this, subject, procedure);
806 procedure.checkAndThrow();
807 return procedure.result;
809 } catch (ServiceException e) {
811 throw new ServiceException(e);
813 } catch (DatabaseException e) {
815 throw new ServiceException(INTERNAL_ERROR_STRING, e);
822 final public Collection<Resource> getObjects(final Resource subject, final Resource relation)
823 throws ServiceException {
825 assert (subject != null);
826 assert (relation != null);
828 if(Development.DEVELOPMENT) {
829 if(Development.isTrue(DevelopmentKeys.READGRAPH_COUNT)) {
830 counters.adjustOrPutValue("objects $" + subject.getResourceId() + " $" + relation.getResourceId(), 1, 1);
832 //if(subject.getResourceId()==xx && relation.getResourceId()==xx) new Exception().printStackTrace();
837 AsyncMultiReadProcedure<Resource> procedure = new AsyncMultiReadProcedure<Resource>();
838 processor.forEachObject(this, subject, relation, procedure);
839 procedure.checkAndThrow();
842 } catch (DatabaseException e) {
844 throw new ServiceException(INTERNAL_ERROR_STRING, e);
851 final public Collection<Resource> getAssertedObjects(
852 final Resource subject, final Resource relation)
853 throws ManyObjectsForFunctionalRelationException, ServiceException {
856 throw new ArgumentException("Subject must not be null.");
857 if (relation == null)
858 throw new ArgumentException("Relation must not be null. Subject=" + subject);
862 return syncRequest(new ForEachAssertedObject(subject, relation));
864 } catch (ManyObjectsForFunctionalRelationException e) {
866 throw new ManyObjectsForFunctionalRelationException(e);
868 } catch (ServiceException e) {
870 throw new ServiceException(e);
872 } catch (DatabaseException e) {
874 throw new ServiceException(INTERNAL_ERROR_STRING, e);
881 final public Resource getInverse(final Resource relation) throws NoInverseException, ServiceException {
883 assert (relation != null);
887 return getSingleObject(relation, processor.querySupport.getResource(processor.getInverseOf()));
889 } catch (NoSingleResultException e) {
891 throw new NoInverseException(e);
893 } catch (ServiceException e) {
895 throw new ServiceException(e);
902 final public Resource getSingleObject(final Resource subject, final Resource relation) throws NoSingleResultException, ServiceException {
904 if( subject == null) throw new IllegalArgumentException("subject can not be null");
905 if( relation == null) throw new IllegalArgumentException("relation can not be null");
908 int single = processor.getSingleObject(this, subject, relation);
910 if (EMPTY_RESOURCE_CHECK) {
911 if (!hasStatement(subject)) {
912 throw new EmptyResourceException("Resource " + debugString(subject));
915 throw new NoSingleResultException("No single object for subject " + debugString(subject)
916 + " and relation " + debugString(relation), single);
918 return processor.querySupport.getResource(single);
919 } catch (NoSingleResultException e) {
921 } catch (DatabaseException e) {
922 throw new ServiceException(e);
927 final public Statement getSingleStatement(final Resource subject, final Resource relation) throws NoSingleResultException, ManyObjectsForFunctionalRelationException, ServiceException {
928 assert (subject != null);
929 assert (relation != null);
931 Collection<Statement> statements = getStatements(subject, relation);
932 if (statements.size() == 1) {
933 return statements.iterator().next();
935 if (EMPTY_RESOURCE_CHECK)
936 if (!hasStatement(subject))
937 throw new EmptyResourceException("Resource " + debugString(subject));
938 throw new NoSingleResultException("No single statement for subject " + debugString(subject)
939 + " and relation " + debugString(relation), statements.size());
941 } catch (ServiceException e) {
942 throw new ServiceException(e);
947 final public Resource getSingleType(final Resource subject) throws NoSingleResultException, ServiceException {
948 assert (subject != null);
950 ArrayList<Resource> principalTypes = (ArrayList<Resource>)getPrincipalTypes(subject);
951 if (principalTypes.size() == 1) {
952 return principalTypes.get(0);
954 throw new NoSingleResultException("No single type for subject " + debugString(subject), principalTypes.size());
956 } catch (ServiceException e) {
957 throw new ServiceException(e);
962 final public Resource getSingleType(final Resource subject,
963 final Resource baseType) throws NoSingleResultException,
966 assert (subject != null);
967 assert (baseType != null);
970 return syncRequest(new SingleType(subject, baseType));
971 } catch (DatabaseException e) {
972 throw new NoSingleResultException("subject=" + subject + ", baseType=" + baseType, 0, e);
977 final public <T> T getValue(final Resource subject) throws DoesNotContainValueException, ServiceException {
979 assert (subject != null);
983 Layer0 L0 = processor.getL0(this);
984 int object = processor.getSingleObject(this, subject, L0.HasDataType);
985 if(object == 0) throw new DoesNotContainValueException("No data type for " + subject);
987 if(processor.isImmutable(object)) {
988 Binding binding = syncRequest(new DatatypeBinding(processor.querySupport.getResource(object)), TransientCacheListener.<Binding>instance());
989 return getValue(subject, binding);
991 byte[] dt = processor.getValue(this, object);
992 if(dt == null) throw new ServiceException("No data type for " + subject);
993 Datatype datatype = (Datatype)DATA_TYPE_SERIALIZER.deserialize(dt);
994 Binding binding = Bindings.getBinding(datatype);
995 return getValue(subject, binding);
998 } catch (IOException e) {
1000 throw new ServiceException(e);
1002 } catch (DoesNotContainValueException e) {
1004 throw new DoesNotContainValueException(e, subject);
1006 } catch (ServiceException e) {
1008 throw new ServiceException(e);
1010 } catch (DatabaseException e) {
1012 throw new ServiceException(INTERNAL_ERROR_STRING, e);
1019 final public Variant getVariantValue(final Resource subject) throws DoesNotContainValueException, ServiceException {
1021 assert (subject != null);
1025 Layer0 L0 = processor.getL0(this);
1026 int object = processor.getSingleObject(this, subject, L0.HasDataType);
1027 if(object == 0) throw new DoesNotContainValueException("No data type for " + subject);
1029 if(processor.isImmutable(object)) {
1030 Binding binding = syncRequest(new DatatypeBinding(processor.querySupport.getResource(object)), TransientCacheListener.<Binding>instance());
1031 return new Variant(binding, getValue(subject, binding));
1033 byte[] dt = processor.getValue(this, object);
1034 if(dt == null) throw new ServiceException("No data type for " + subject);
1035 Datatype datatype = (Datatype)DATA_TYPE_SERIALIZER.deserialize(dt);
1036 Binding binding = Bindings.getBinding(datatype);
1037 return new Variant(binding, getValue(subject, binding));
1040 } catch (IOException e) {
1042 throw new ServiceException(e);
1044 } catch (DoesNotContainValueException e) {
1046 throw new DoesNotContainValueException(e, subject);
1048 } catch (ServiceException e) {
1050 throw new ServiceException(e);
1052 } catch (DatabaseException e) {
1054 throw new ServiceException(INTERNAL_ERROR_STRING, e);
1059 static final IdentityHashMap<Binding,Serializer> serializers = new IdentityHashMap<Binding,Serializer>();
1062 serializers.put(Bindings.STRING, Bindings.STRING.serializer());
1065 final protected Serializer getSerializer(Binding binding) {
1066 return binding.serializer();
1070 final public <T> T getValue(final Resource subject, final Binding binding) throws DoesNotContainValueException, BindingException,
1073 assert (subject != null);
1077 byte[] bytes = processor.getValue(this, subject);
1078 if (bytes == null) throw new DoesNotContainValueException("No value for resource " + subject);
1080 Serializer serializer = getSerializer(binding);
1081 return (T)serializer.deserialize(bytes);
1083 } catch (DoesNotContainValueException e) {
1085 throw new DoesNotContainValueException(e);
1087 } catch (IOException e) {
1089 throw new ServiceException(e);
1091 } catch (DatabaseException e) {
1093 throw new ServiceException(e);
1095 } catch (BufferUnderflowException e) {
1096 // This is sometimes thrown when deserialize fails because wrong format.
1097 // For callers of this method this is just an service exception.
1098 throw new ServiceException(e);
1104 final public <T> T getRelatedValue(final Resource subject, final Resource relation) throws NoSingleResultException,
1105 DoesNotContainValueException, ServiceException {
1107 assert (subject != null);
1108 assert (relation != null);
1111 Resource object = getSingleObject(subject, relation);
1112 return getValue(object);
1113 } catch (NoSingleResultException e) {
1114 throw new NoSingleResultException("No single value found for subject " + debugString(subject) + " and relation " + debugString(relation), e.getResultCount(), e);
1115 } catch (DoesNotContainValueException e) {
1117 Layer0 L0 = processor.getL0(this);
1118 Resource object = getPossibleObject(subject, relation);
1119 if(isInstanceOf(object, L0.Value)) {
1120 if(isInstanceOf(object, L0.Literal)) {
1121 throw new DoesNotContainValueException(e);
1123 throw new InvalidLiteralException("The object " + object + " is not an instance of L0.Literal (use getRelatedValue2 instead)", e);
1126 throw new DoesNotContainValueException("The object " + object + " is not an instance of L0.Value", e);
1128 } catch (DoesNotContainValueException e2) {
1130 } catch (DatabaseException e2) {
1131 throw new InternalException("The client failed to analyse the cause of the following exception", e);
1133 } catch (ServiceException e) {
1134 throw new ServiceException(e);
1139 final public Variant getRelatedVariantValue(final Resource subject, final Resource relation) throws NoSingleResultException,
1140 DoesNotContainValueException, ServiceException {
1142 assert (subject != null);
1143 assert (relation != null);
1146 Resource object = getSingleObject(subject, relation);
1147 return getVariantValue(object);
1148 } catch (NoSingleResultException e) {
1149 throw new NoSingleResultException("No single object for subject " + debugString(subject) + " and relation " + debugString(relation), e.getResultCount(), e);
1150 } catch (DoesNotContainValueException e) {
1152 Layer0 L0 = processor.getL0(this);
1153 Resource object = getPossibleObject(subject, relation);
1154 if(isInstanceOf(object, L0.Value)) {
1155 if(isInstanceOf(object, L0.Literal)) {
1156 throw new DoesNotContainValueException(e);
1158 throw new InvalidLiteralException("The object " + object + " is not an instance of L0.Literal (use getRelatedValue2 instead)", e);
1161 throw new DoesNotContainValueException("The object " + object + " is not an instance of L0.Value", e);
1163 } catch (DoesNotContainValueException e2) {
1165 } catch (DatabaseException e2) {
1166 throw new InternalException("The client failed to analyse the cause of the following exception", e);
1168 } catch (ServiceException e) {
1169 throw new ServiceException(e);
1174 final public <T> T getRelatedValue(final Resource subject, final Resource relation, final Binding binding)
1175 throws NoSingleResultException, DoesNotContainValueException, BindingException, ServiceException {
1177 assert (subject != null);
1178 assert (relation != null);
1181 Resource object = getSingleObject(subject, relation);
1182 return getValue(object, binding);
1183 } catch (NoSingleResultException e) {
1184 String message = "";
1186 String subjectName = NameUtils.getSafeName(this, subject, true);
1187 String relationName = NameUtils.getSafeName(this, relation, true);
1188 message = "Subject: " + subjectName + ", Relation: " + relationName;
1189 } catch (DatabaseException e2) {
1192 throw new NoSingleResultException(message, e.getResultCount(), e);
1193 } catch (DoesNotContainValueException e) {
1194 throw new DoesNotContainValueException(e);
1195 } catch (ServiceException e) {
1196 throw new ServiceException(e);
1201 final public <T> T adapt(final Resource resource, final Class<T> clazz)
1202 throws AdaptionException, ValidationException, ServiceException {
1204 assert (resource != null);
1205 assert (clazz != null);
1209 return syncRequest(new Adapter<T>(resource, clazz));
1211 } catch (AdaptionException e) {
1213 throw new AdaptionException(e);
1215 } catch (ValidationException e) {
1217 throw new ValidationException(e);
1219 } catch (ServiceException e) {
1221 throw new ServiceException(e);
1223 } catch (DatabaseException e) {
1225 throw new ServiceException(INTERNAL_ERROR_STRING, e);
1232 final public <T,C> T adaptContextual(final Resource resource, final C context, final Class<C> contextClass, final Class<T> clazz)
1233 throws AdaptionException, ValidationException, ServiceException {
1235 assert (resource != null);
1236 assert (context != null);
1238 class ContextualAdapter implements AsyncRead<T> {
1240 final private Resource resource;
1241 final private C context;
1242 final private Class<T> clazz;
1245 public int hashCode() {
1246 return resource.hashCode() + 31 * (clazz.hashCode() + 41 * context.hashCode());
1250 final public int threadHash() {
1251 return resource.getThreadHash();
1255 public boolean equals(Object object) {
1258 else if (object == null)
1260 else if (getClass() != object.getClass())
1262 ContextualAdapter r = (ContextualAdapter)object;
1263 return resource.equals(r.resource) && context.equals(r.context) && clazz.equals(r.clazz);
1267 public int getFlags() {
1271 public ContextualAdapter(Resource resource, C context, Class<T> clazz) {
1272 this.resource = resource;
1273 this.context = context;
1278 public void perform(AsyncReadGraph graph, AsyncProcedure<T> procedure) {
1280 final AdaptionService service = getSession().peekService(AdaptionService.class);
1281 if (service == null)
1282 procedure.exception(graph, new ServiceException("No AdaptionService available"));
1284 service.adapt(graph, resource, context, contextClass, clazz, false, procedure);
1289 public String toString() {
1290 return "Adapter for (" + resource + "," + context + ") as " + clazz.getName();
1297 return syncRequest(new ContextualAdapter(resource, context, clazz));
1299 } catch (AdaptionException e) {
1301 throw new AdaptionException(e);
1303 } catch (ValidationException e) {
1305 throw new ValidationException(e);
1307 } catch (ServiceException e) {
1309 throw new ServiceException(e);
1311 } catch (DatabaseException e) {
1313 throw new ServiceException(INTERNAL_ERROR_STRING, e);
1320 final public <T> T adaptRelated(final Resource resource, final Resource relation, final Class<T> clazz)
1321 throws AdaptionException, NoSingleResultException, ValidationException, ServiceException {
1323 assert (resource != null);
1324 assert (clazz != null);
1326 Statement stm = getSingleStatement(resource, relation);
1328 return adaptContextual(stm.getObject(), new RelationContextImpl(resource, stm), RelationContext.class, clazz);
1333 final public <T> T getPossibleRelatedAdapter(final Resource resource, final Resource relation, final Class<T> clazz)
1334 throws ValidationException, ServiceException {
1337 return adaptRelated(resource, relation, clazz);
1338 } catch (DatabaseException e) {
1345 final public <T,C> T getPossibleContextualAdapter(final Resource resource, final C context, final Class<C> contextClass, final Class<T> clazz)
1346 throws ValidationException, ServiceException {
1348 assert (resource != null);
1349 assert (context != null);
1351 class PossibleContextualAdapter implements AsyncRead<T> {
1353 final private Resource resource;
1354 final private C context;
1355 final private Class<T> clazz;
1358 public int hashCode() {
1359 return resource.hashCode() + 31 * (clazz.hashCode() + 41 * context.hashCode());
1363 final public int threadHash() {
1364 return resource.getThreadHash();
1368 public boolean equals(Object object) {
1371 else if (object == null)
1373 else if (getClass() != object.getClass())
1375 PossibleContextualAdapter r = (PossibleContextualAdapter)object;
1376 return resource.equals(r.resource) && context.equals(r.context) && clazz.equals(r.clazz);
1380 public int getFlags() {
1384 public PossibleContextualAdapter(Resource resource, C context, Class<T> clazz) {
1385 this.resource = resource;
1386 this.context = context;
1391 public void perform(AsyncReadGraph graph, AsyncProcedure<T> procedure) {
1393 final AdaptionService service = getSession().peekService(AdaptionService.class);
1394 if (service == null)
1395 procedure.exception(graph, new ServiceException("No AdaptionService available"));
1397 service.adapt(graph, resource, context, contextClass, clazz, true, procedure);
1402 public String toString() {
1403 return "Possible adapter for (" + resource + "," + context + ") as " + clazz.getName();
1410 return syncRequest(new PossibleContextualAdapter(resource, context, clazz));
1412 } catch (ValidationException e) {
1414 throw new ValidationException(e);
1416 } catch (ServiceException e) {
1418 throw new ServiceException(e);
1420 } catch (DatabaseException e) {
1422 throw new ServiceException(INTERNAL_ERROR_STRING, e);
1429 final public <T> T adaptUnique(final Resource resource, final Class<T> clazz)
1430 throws AdaptionException, ValidationException, ServiceException {
1432 assert (resource != null);
1433 assert (clazz != null);
1437 return syncRequest(new UniqueAdapter<T>(resource, clazz));
1439 } catch (AdaptionException e) {
1441 throw new AdaptionException(e);
1443 } catch (ValidationException e) {
1445 throw new ValidationException(e);
1447 } catch (ServiceException e) {
1449 throw new ServiceException(e);
1451 } catch (DatabaseException e) {
1453 throw new ServiceException(INTERNAL_ERROR_STRING, e);
1460 final public Resource getPossibleInverse(final Resource relation)
1461 throws ServiceException {
1463 assert (relation != null);
1467 return getPossibleObject(relation, processor.querySupport.getResource(processor.getInverseOf()));
1469 } catch (ServiceException e) {
1471 throw new ServiceException(e);
1473 } catch (DatabaseException e) {
1475 throw new ServiceException(INTERNAL_ERROR_STRING, e);
1482 public Resource getPossibleObject(final Resource subject, final Resource relation)
1483 throws ManyObjectsForFunctionalRelationException, ServiceException {
1485 assert (subject != null);
1486 assert (relation != null);
1490 int result = processor.getSingleObject(this, subject, relation);
1491 if(result == 0) return null;
1493 return processor.querySupport.getResource(result);
1495 } catch (ManyObjectsForFunctionalRelationException e) {
1497 throw new ManyObjectsForFunctionalRelationException("subject=" + subject + ", relation=" + relation, e);
1499 } catch (DatabaseException e) {
1501 throw new ServiceException(e);
1508 final public Statement getPossibleStatement(final Resource subject, final Resource relation)
1509 throws ManyObjectsForFunctionalRelationException, ServiceException {
1511 assert (subject != null);
1512 assert (relation != null);
1516 Collection<Statement> statements = getStatements(subject, relation);
1517 if(statements.size() == 1) return statements.iterator().next();
1520 } catch (ManyObjectsForFunctionalRelationException e) {
1522 throw new ManyObjectsForFunctionalRelationException("Many objects in " + subject + " for functional relation " + relation);
1524 } catch (ServiceException e) {
1526 throw new ServiceException(e);
1533 final public Resource getPossibleType(final Resource subject, final Resource baseType) throws ServiceException {
1535 assert (subject != null);
1536 assert (baseType != null);
1540 AsyncReadProcedure<Resource> procedure = new AsyncReadProcedure<Resource>();
1541 forPossibleType(subject, baseType, procedure);
1542 procedure.checkAndThrow();
1543 return procedure.result;
1545 } catch (ServiceException e) {
1547 throw new ServiceException(e);
1549 } catch (DatabaseException e) {
1551 throw new ServiceException(INTERNAL_ERROR_STRING, e);
1558 final public <T> T getPossibleValue(final Resource subject) throws ServiceException {
1560 assert (subject != null);
1564 int object = processor.getSingleObject(this, subject, processor.getL0(this).HasDataType);
1565 if(object == 0) return null;
1567 if(processor.isImmutable(object)) {
1568 Binding binding = syncRequest(new DatatypeBinding(processor.querySupport.getResource(object)), TransientCacheListener.<Binding>instance());
1569 return getPossibleValue(subject, binding);
1571 byte[] dt = processor.getValue(this, object);
1572 if(dt == null) return null;
1573 Datatype datatype = (Datatype)DATA_TYPE_SERIALIZER.deserialize(dt);
1574 Binding binding = Bindings.getBinding(datatype);
1575 return getPossibleValue(subject, binding);
1578 } catch (IOException e) {
1580 throw new ServiceException(e);
1582 } catch (ServiceException e) {
1584 throw new ServiceException(e);
1586 } catch (DatabaseException e) {
1588 throw new ServiceException(INTERNAL_ERROR_STRING, e);
1595 final public <T> T getPossibleValue(final Resource subject, final Binding binding) throws BindingException, ServiceException {
1597 assert (subject != null);
1598 assert (binding != null);
1602 byte[] dt = processor.getValue(this, subject);
1603 if(dt == null) return null;
1604 Serializer serializer = getSerializer(binding);
1605 return (T)serializer.deserialize(dt);
1607 } catch (IOException e) {
1609 throw new ServiceException(e);
1611 } catch (BindingException e) {
1613 throw new BindingException(e);
1615 } catch (ServiceException e) {
1617 throw new ServiceException(e);
1619 } catch (DatabaseException e) {
1620 e.printStackTrace();
1621 throw new ServiceException(INTERNAL_ERROR_STRING, e);
1627 public <T> T getPossibleRelatedValue(final Resource subject, final Resource relation)
1628 throws ManyObjectsForFunctionalRelationException, ServiceException {
1630 assert (subject != null);
1631 assert (relation != null);
1635 Resource object = getPossibleObject(subject, relation);
1636 if(object == null) return null;
1637 else return getPossibleValue(object);
1639 } catch (ManyObjectsForFunctionalRelationException e) {
1641 throw new ManyObjectsForFunctionalRelationException(e);
1643 } catch (ServiceException e) {
1645 throw new ServiceException(e);
1652 public <T> T getPossibleRelatedValue(final Resource subject, final Resource relation, final Binding binding)
1653 throws ManyObjectsForFunctionalRelationException, BindingException, ServiceException {
1655 assert (subject != null);
1656 assert (relation != null);
1657 assert (binding != null);
1661 Resource object = getPossibleObject(subject, relation);
1662 if(object == null) return null;
1663 else return getPossibleValue(object, binding);
1665 } catch (ManyObjectsForFunctionalRelationException e) {
1667 throw new ManyObjectsForFunctionalRelationException(e);
1669 } catch (BindingException e) {
1671 throw new BindingException(e);
1673 } catch (ServiceException e) {
1675 throw new ServiceException(e);
1682 public <T> T getPossibleAdapter(Resource resource, Class<T> clazz) throws ValidationException, ServiceException {
1684 assert (resource != null);
1685 assert (clazz != null);
1689 return syncRequest(new PossibleAdapter<T>(resource, clazz));
1691 } catch (ValidationException e) {
1693 throw new ValidationException(e);
1695 } catch (AdaptionException e) {
1699 } catch (DatabaseException e) {
1701 throw new ServiceException(INTERNAL_ERROR_STRING, e);
1707 public <T> T getPossibleUniqueAdapter(Resource resource, Class<T> clazz) throws ValidationException, ServiceException {
1709 assert (resource != null);
1710 assert (clazz != null);
1714 return syncRequest(new PossibleUniqueAdapter<T>(resource, clazz));
1716 } catch (AdaptionException e) {
1720 } catch (ValidationException e) {
1722 throw new ValidationException(e);
1724 } catch (DatabaseException e) {
1726 throw new ServiceException(INTERNAL_ERROR_STRING, e);
1733 final public boolean isInstanceOf(final Resource resource, final Resource type) throws ServiceException {
1735 assert (resource != null);
1736 assert (type != null);
1738 Set<Resource> resources = getTypes(resource);
1739 // This check was necessary because some of the callers of this method got stuck when the NPE was thrown from here.
1740 if (null == resources)
1743 if(EMPTY_RESOURCE_CHECK) {
1744 if (resources.isEmpty()) {
1745 if(!hasStatement(resource)) throw new EmptyResourceException("Resource " + debugString(resource));
1749 return resources.contains(type);
1754 final public boolean isInheritedFrom(final Resource resource, final Resource type) throws ServiceException {
1756 assert (resource != null);
1757 assert (type != null);
1761 if(resource.equals(type)) return true;
1763 return getSupertypes(resource).contains(type);
1765 } catch (ServiceException e) {
1767 throw new ServiceException(e);
1774 final public boolean isSubrelationOf(final Resource resource, final Resource type) throws ServiceException {
1776 assert (resource != null);
1777 assert (type != null);
1781 if(resource.equals(type)) return true;
1783 return getSuperrelations(resource).contains(type);
1785 } catch (ServiceException e) {
1787 throw new ServiceException(e);
1794 final public boolean hasStatement(final Resource subject) throws ServiceException {
1796 assert (subject != null);
1800 SyncReadProcedure<Boolean> procedure = new SyncReadProcedure<Boolean>();
1801 processor.forHasStatement(this, subject, procedure);
1802 procedure.checkAndThrow();
1803 return procedure.result;
1805 } catch (ServiceException e) {
1807 throw new ServiceException(e);
1809 } catch (DatabaseException e) {
1811 throw new ServiceException(INTERNAL_ERROR_STRING, e);
1818 final public boolean hasStatement(final Resource subject, final Resource relation) throws ServiceException {
1820 assert (subject != null);
1821 assert (relation != null);
1825 Collection<Resource> objects = getObjects(subject, relation);
1826 return !objects.isEmpty();
1828 } catch (ServiceException e) {
1830 throw new ServiceException(e);
1837 final public boolean hasStatement(final Resource subject, final Resource relation, final Resource object) throws ServiceException {
1839 assert (subject != null);
1840 assert (relation != null);
1841 assert (object != null);
1845 for(Resource o : getObjects(subject, relation)) {
1846 if(object.equals(o)) return true;
1851 } catch (ServiceException e) {
1853 throw new ServiceException(e);
1860 final public boolean hasValue(final Resource subject) throws ServiceException {
1862 assert (subject != null);
1866 SyncReadProcedure<Boolean> procedure = new SyncReadProcedure<Boolean>();
1867 processor.forHasValue(this, subject, procedure);
1868 procedure.checkAndThrow();
1869 return procedure.result;
1871 } catch (ServiceException e) {
1873 throw new ServiceException(e);
1875 } catch (DatabaseException e) {
1877 throw new ServiceException(INTERNAL_ERROR_STRING, e);
1883 final AsyncProcedure<?> NONE = new AsyncProcedure<Object>() {
1886 public void execute(AsyncReadGraph graph, Object result) {
1890 public void exception(AsyncReadGraph graph, Throwable throwable) {
1896 * Implementation of the interface RequestProcessor
1900 public <T> T syncRequest(final Read<T> request) throws DatabaseException {
1902 assert (request != null);
1904 return QueryCache.resultReadEntry(this, request, parent, null, null);
1906 //return processor.query(this, request, parent, null, null);
1908 // if (parent != null) {
1911 // } catch (Throwable e) {
1912 // if(e instanceof DatabaseException) throw (DatabaseException)e;
1913 // else throw new DatabaseException(e);
1920 // return processor.tryQuery(this, request);
1922 // } catch (Throwable throwable) {
1924 // //Logger.defaultLogError("Internal read request failure", throwable);
1926 // if (throwable instanceof DatabaseException)
1927 // throw (DatabaseException) throwable;
1929 // throw new DatabaseException(
1930 // "Unexpected exception in ReadGraph.syncRequest(Read,Procedure)",
1940 public <T> T syncRequest(Read<T> request, SyncListener<T> procedure)
1941 throws DatabaseException {
1942 return syncRequest(request, new SyncToAsyncListener<T>(procedure));
1946 public <T> T syncRequest(Read<T> request, final Listener<T> procedure)
1947 throws DatabaseException {
1948 return syncRequest(request, new NoneToAsyncListener<T>(procedure));
1952 public <T> T syncRequest(final Read<T> request, final AsyncProcedure<T> procedure) throws DatabaseException {
1954 assert (request != null);
1956 ListenerBase listener = procedure != null ? getListenerBase(procedure) : null;
1958 return QueryCache.resultReadEntry(this, request, parent, listener, procedure);
1960 // return processor.query(this, request, parent, procedure, listener);
1963 // if (parent != null || listener != null) {
1966 // } catch (Throwable e) {
1967 // if(e instanceof DatabaseException) throw (DatabaseException)e;
1968 // else throw new DatabaseException(e);
1975 // T t = processor.tryQuery(this, request);
1976 // if(procedure != null)
1977 // procedure.execute(this, t);
1981 // } catch (Throwable throwable) {
1983 // Logger.defaultLogError("Internal read request failure", throwable);
1985 // if(procedure != null)
1986 // procedure.exception(this, throwable);
1988 // if (throwable instanceof DatabaseException)
1989 // throw (DatabaseException) throwable;
1991 // throw new DatabaseException(
1992 // "Unexpected exception in ReadGraph.syncRequest(Read,Procedure)",
2002 public <T> T syncRequest(final Read<T> request,
2003 final SyncProcedure<T> procedure) throws DatabaseException {
2004 return syncRequest(request, new SyncToAsyncProcedure<T>(procedure));
2008 public <T> T syncRequest(Read<T> request, Procedure<T> procedure)
2009 throws DatabaseException {
2010 return syncRequest(request, new NoneToAsyncProcedure<T>(procedure));
2013 static class AsyncReadProcedure<T> implements AsyncProcedure<T> {
2015 private static Throwable DONE = new Throwable();
2018 Throwable exception = null;
2021 public void execute(AsyncReadGraph graph, T t) {
2027 public void exception(AsyncReadGraph graph, Throwable t) {
2031 public void checkAndThrow() throws DatabaseException {
2032 if(exception != DONE) {
2033 if (exception instanceof DatabaseException)
2034 throw (DatabaseException) exception;
2036 throw new DatabaseException(
2037 "Unexpected exception in ReadGraph.syncRequest(AsyncRead)",
2042 public boolean done() {
2043 return exception != null;
2049 public <T> T syncRequest(final AsyncRead<T> request)
2050 throws DatabaseException {
2052 assert (request != null);
2053 AsyncReadProcedure<T> procedure = new AsyncReadProcedure<T>();
2054 syncRequest(request, procedure);
2055 procedure.checkAndThrow();
2056 return procedure.result;
2058 // return syncRequest(request, new AsyncProcedureAdapter<T>());
2063 public <T> T syncRequest(AsyncRead<T> request, AsyncListener<T> procedure)
2064 throws DatabaseException {
2065 return syncRequest(request, (AsyncProcedure<T>) procedure);
2069 public <T> T syncRequest(AsyncRead<T> request, SyncListener<T> procedure)
2070 throws DatabaseException {
2071 return syncRequest(request, new SyncToAsyncListener<T>(procedure));
2075 public <T> T syncRequest(AsyncRead<T> request, Listener<T> procedure)
2076 throws DatabaseException {
2077 return syncRequest(request, new NoneToAsyncListener<T>(procedure));
2081 final public <T> T syncRequest(final AsyncRead<T> request,
2082 final AsyncProcedure<T> procedure) throws DatabaseException {
2084 assert (request != null);
2086 ListenerBase listener = getListenerBase(procedure);
2088 final ResultCallWrappedSingleQueryProcedure4<T> wrapper = new ResultCallWrappedSingleQueryProcedure4<T>(
2089 procedure, request);
2091 QueryCache.runnerAsyncReadEntry(this, request, parent, listener, wrapper);
2093 //processor.query(this, request, parent, wrapper, listener);
2095 return wrapper.getResult();
2097 // if (parent != null || listener != null || ((request.getFlags() & RequestFlags.SCHEDULE) > 0)) {
2099 //// Object syncParent = request;
2101 //// final ReadGraphImpl newGraph = newSync();
2104 //// newGraph.waitAsync(syncParent);
2106 // Throwable e = wrapper.getException();
2108 // // The request was async - produce meaningful stack trace by
2110 // if (e instanceof DatabaseException)
2111 // throw (DatabaseException) e;
2113 // throw new DatabaseException(e);
2116 // return wrapper.getResult();
2120 // // System.out.println("direct call " + request );
2122 // // Do not set the sync state.parent for external threads
2123 //// Object syncParent = request;
2125 //// final ReadGraphImpl newGraph = newSync();
2127 // final ResultCallWrappedSingleQueryProcedure4<T> wrapper = new ResultCallWrappedSingleQueryProcedure4<T>(
2128 // procedure, request);
2132 // processor.tryQuery(this, request, wrapper);
2134 // } catch (Throwable t) {
2136 // wrapper.exception(this, t);
2140 // Throwable e = wrapper.getException();
2142 // // The request was async - produce meaningful stack trace by
2144 // if (e instanceof DatabaseException)
2145 // throw (DatabaseException) e;
2147 // throw new DatabaseException(e);
2150 // return wrapper.getResult();
2156 final private <T> void syncRequest(final AsyncRead<T> request, final AsyncReadProcedure<T> procedure) throws DatabaseException {
2158 assert (request != null);
2160 ListenerBase listener = getListenerBase(procedure);
2161 assert(listener == null);
2163 // final ResultCallWrappedSingleQueryProcedure4<T> wrapper = new ResultCallWrappedSingleQueryProcedure4<T>(
2164 // procedure, request);
2166 QueryCache.runnerAsyncReadEntry(this, request, parent, listener, procedure);
2171 public <T> T syncRequest(AsyncRead<T> request,
2172 final SyncProcedure<T> procedure) throws DatabaseException {
2173 return syncRequest(request, new SyncToAsyncProcedure<T>(procedure));
2177 final public <T> T syncRequest(final AsyncRead<T> request,
2178 final Procedure<T> procedure) throws DatabaseException {
2179 return syncRequest(request, new NoneToAsyncProcedure<T>(procedure));
2183 public <T> Collection<T> syncRequest(final MultiRead<T> request)
2184 throws DatabaseException {
2186 assert (request != null);
2188 final ArrayList<T> result = new ArrayList<T>();
2189 final DataContainer<Throwable> exception = new DataContainer<Throwable>();
2191 syncRequest(request, new AsyncMultiProcedure<T>() {
2194 public void execute(AsyncReadGraph graph, T t) {
2195 synchronized (result) {
2201 public void finished(AsyncReadGraph graph) {
2205 public void exception(AsyncReadGraph graph, Throwable t) {
2210 public String toString() {
2211 return "syncRequest(MultiRead) -> " + request;
2216 Throwable t = exception.get();
2218 if (t instanceof DatabaseException)
2219 throw (DatabaseException) t;
2221 throw new DatabaseException(
2222 "Unexpected exception in ReadGraph.syncRequest(Read)",
2231 public <T> Collection<T> syncRequest(MultiRead<T> request,
2232 AsyncMultiListener<T> procedure) {
2233 return syncRequest(request, (AsyncMultiProcedure<T>) procedure);
2237 public <T> Collection<T> syncRequest(MultiRead<T> request,
2238 SyncMultiListener<T> procedure) {
2239 return syncRequest(request, new SyncToAsyncMultiListener<T>(procedure));
2243 public <T> Collection<T> syncRequest(MultiRead<T> request,
2244 MultiListener<T> procedure) {
2245 return syncRequest(request, new NoneToAsyncMultiListener<T>(procedure));
2249 public <T> Collection<T> syncRequest(MultiRead<T> request,
2250 AsyncMultiProcedure<T> procedure) {
2252 assert (request != null);
2254 ListenerBase listener = getListenerBase(procedure);
2256 if (parent != null || listener != null) {
2258 // Object syncParent = request;
2260 // final ReadGraphImpl newGraph = newSync();
2262 processor.query(this, request, parent, procedure, listener);
2264 // newGraph.waitAsync(syncParent);
2268 // Object syncParent = request;
2270 // final ReadGraphImpl newGraph = newSync();
2272 final ResultCallWrappedQueryProcedure4<T> wrapper = new ResultCallWrappedQueryProcedure4<T>(procedure);
2276 request.perform(this, wrapper);
2278 } catch (Throwable t) {
2280 wrapper.exception(this, t);
2281 // newGraph.waitAsync(syncParent);
2293 public <T> Collection<T> syncRequest(MultiRead<T> request,
2294 SyncMultiProcedure<T> procedure) {
2295 return syncRequest(request, new SyncToAsyncMultiProcedure<T>(procedure));
2299 public <T> Collection<T> syncRequest(MultiRead<T> request,
2300 MultiProcedure<T> procedure) {
2301 return syncRequest(request, new NoneToAsyncMultiProcedure<T>(procedure));
2304 static class AsyncMultiReadProcedure<T> extends ArrayList<T> implements AsyncMultiProcedure<T> {
2306 private static Throwable DONE = new Throwable();
2308 private static final long serialVersionUID = -6494230465108115812L;
2310 Throwable exception = null;
2313 public synchronized void execute(AsyncReadGraph graph, T t) {
2318 public void finished(AsyncReadGraph graph) {
2323 public void exception(AsyncReadGraph graph, Throwable t) {
2327 public void checkAndThrow() throws DatabaseException {
2328 if(exception != DONE) {
2329 if (exception instanceof DatabaseException)
2330 throw (DatabaseException) exception;
2332 throw new DatabaseException(
2333 "Unexpected exception in ReadGraph.syncRequest(AsyncMultiRead)",
2338 public boolean done() {
2339 return exception != null;
2345 final public <T> Collection<T> syncRequest(AsyncMultiRead<T> request)
2346 throws DatabaseException {
2348 assert (request != null);
2350 final AsyncMultiReadProcedure<T> procedure = new AsyncMultiReadProcedure<T>();
2352 syncRequest(request, procedure);
2354 procedure.checkAndThrow();
2360 public <T> Collection<T> syncRequest(AsyncMultiRead<T> request,
2361 AsyncMultiListener<T> procedure) {
2362 return syncRequest(request, (AsyncMultiProcedure<T>) procedure);
2366 public <T> Collection<T> syncRequest(AsyncMultiRead<T> request,
2367 SyncMultiListener<T> procedure) {
2368 return syncRequest(request, new SyncToAsyncMultiListener<T>(procedure));
2372 public <T> Collection<T> syncRequest(AsyncMultiRead<T> request,
2373 MultiListener<T> procedure) {
2374 return syncRequest(request, new NoneToAsyncMultiListener<T>(procedure));
2377 final private <T> void syncRequest(final AsyncMultiRead<T> request,
2378 final AsyncMultiReadProcedure<T> procedure) {
2380 assert (request != null);
2381 assert (procedure != null);
2383 ListenerBase listener = getListenerBase(procedure);
2385 if (parent != null || listener != null) {
2387 // Object syncParent = request;
2389 // final ReadGraphImpl newGraph = newSync();
2391 processor.query(this, request, parent, procedure, listener);
2393 // newGraph.waitAsync(syncParent);
2394 waitAsyncProcedure(procedure);
2398 // Object syncParent = callerThread == Integer.MIN_VALUE ? null
2401 // final ReadGraphImpl newGraph = newSyncAsync(syncParent);
2406 // ReadGraphImpl sync = newSync();
2407 request.perform(this, procedure);
2408 // sync.waitAsync(null);
2409 waitAsyncProcedure(procedure);
2412 } catch (Throwable t) {
2414 waitAsyncProcedure(procedure);
2425 final public <T> Collection<T> syncRequest(final AsyncMultiRead<T> request,
2426 final AsyncMultiProcedure<T> procedure) {
2428 assert (request != null);
2429 assert (procedure != null);
2431 ListenerBase listener = getListenerBase(procedure);
2433 if (parent != null || listener != null) {
2435 // Object syncParent = request;
2437 // final ReadGraphImpl newGraph = newSync();
2439 processor.query(this, request, parent, procedure, listener);
2441 // newGraph.waitAsync(syncParent);
2445 // Object syncParent = request;
2447 // final ReadGraphImpl newGraph = newSync();
2451 request.perform(this, new AsyncMultiProcedure<T>() {
2454 public void execute(AsyncReadGraph graph, T result) {
2455 procedure.execute(graph, result);
2459 public void finished(AsyncReadGraph graph) {
2460 procedure.finished(graph);
2464 public void exception(AsyncReadGraph graph, Throwable t) {
2465 procedure.exception(graph, t);
2469 public String toString() {
2470 return "syncRequest(AsyncMultiRead) -> " + procedure;
2475 } catch (Throwable t) {
2487 public <T> Collection<T> syncRequest(AsyncMultiRead<T> request,
2488 final SyncMultiProcedure<T> procedure) {
2489 return syncRequest(request, new SyncToAsyncMultiProcedure<T>(procedure));
2493 final public <T> Collection<T> syncRequest(final AsyncMultiRead<T> request,
2494 final MultiProcedure<T> procedure) {
2495 return syncRequest(request, new NoneToAsyncMultiProcedure<T>(procedure));
2499 public <T> T syncRequest(final ExternalRead<T> request)
2500 throws DatabaseException {
2502 assert (request != null);
2504 return syncRequest(request, new Procedure<T>() {
2507 public void execute(T t) {
2511 public void exception(Throwable t) {
2515 public String toString() {
2516 return "syncRequest(AsyncRead) -> " + request;
2524 public <T> T syncRequest(ExternalRead<T> request, Listener<T> procedure) throws DatabaseException {
2525 return syncRequest(request, (Procedure<T>) procedure);
2529 final public <T> T syncRequest(final ExternalRead<T> request,
2530 final Procedure<T> procedure) throws DatabaseException {
2532 assert (request != null);
2534 ListenerBase listener = procedure != null ? getListenerBase(procedure) : null;
2535 return QueryCache.resultExternalReadEntry(this, request, parent, listener, procedure);
2538 // ListenerBase listener = getListenerBase(procedure);
2540 // return QueryCache.resultExternalReadEntry(this, request, parent, listener, procedure);
2542 // assert (request != null);
2544 // ListenerBase listener = getListenerBase(procedure);
2546 // final DataContainer<Throwable> exception = new DataContainer<Throwable>();
2547 // final DataContainer<T> result = new DataContainer<T>();
2549 // processor.query(this, request, parent, new Procedure<T>() {
2552 // public void exception(Throwable throwable) {
2553 // exception.set(throwable);
2554 // procedure.exception(throwable);
2558 // public void execute(T t) {
2560 // procedure.execute(t);
2567 // if (parent != null || listener != null) {
2569 //// final ReadGraphImpl newGraph = newSync();
2572 //// newGraph.waitAsync(request);
2578 // T t = processor.tryQuery(this, request);
2580 // procedure.execute(t);
2582 // } catch (Throwable t) {
2584 // if (t instanceof DatabaseException) {
2585 // exception.set((DatabaseException)t);
2586 // procedure.exception(exception.get());
2588 // exception.set(new DatabaseException(
2589 // "Unexpected exception in ReadGraph.syncRequest(Read)",
2591 // procedure.exception(exception.get());
2598 // Throwable t = exception.get();
2600 // if (t instanceof DatabaseException)
2601 // throw (DatabaseException) t;
2603 // throw new DatabaseException(
2604 // "Unexpected exception in ReadGraph.syncRequest(Read)",
2608 // return result.get();
2613 public void syncRequest(final Write request) throws DatabaseException {
2615 assert (request != null);
2617 throw new DatabaseException(
2618 "Write operations are not supported during read transactions!");
2623 public <T> T syncRequest(final WriteResult<T> request) throws DatabaseException {
2625 assert (request != null);
2627 throw new DatabaseException(
2628 "Write operations are not supported during read transactions!");
2633 public void syncRequest(final DelayedWrite request)
2634 throws DatabaseException {
2636 assert (request != null);
2638 throw new DatabaseException(
2639 "Write operations are not supported during read transactions!");
2644 public <T> T syncRequest(final DelayedWriteResult<T> request) throws DatabaseException {
2646 assert (request != null);
2648 throw new DatabaseException(
2649 "Write operations are not supported during read transactions!");
2654 public void syncRequest(final WriteOnly request) throws DatabaseException {
2656 assert (request != null);
2658 throw new DatabaseException(
2659 "Write operations are not supported during read transactions!");
2664 public <T> T syncRequest(final WriteOnlyResult<T> request) throws DatabaseException {
2666 assert (request != null);
2668 throw new DatabaseException(
2669 "Write operations are not supported during read transactions!");
2674 public <T> void async(ReadInterface<T> r, AsyncProcedure<T> procedure) {
2675 r.request(this, procedure);
2679 public <T> void async(ReadInterface<T> r, Procedure<T> procedure) {
2680 r.request(this, procedure);
2684 public <T> void async(ReadInterface<T> r, SyncProcedure<T> procedure) {
2685 r.request(this, procedure);
2689 public <T> void async(ReadInterface<T> r, AsyncListener<T> procedure) {
2690 r.request(this, procedure);
2694 public <T> void async(ReadInterface<T> r, Listener<T> procedure) {
2695 r.request(this, procedure);
2699 public <T> void async(ReadInterface<T> r, SyncListener<T> procedure) {
2700 r.request(this, procedure);
2704 public <T> T sync(ReadInterface<T> r) throws DatabaseException {
2705 return r.request(this);
2709 public <T> T sync(WriteInterface<T> r) throws DatabaseException {
2710 return r.request(this);
2714 public <T> void async(WriteInterface<T> r, Procedure<T> procedure) {
2715 r.request(this, procedure);
2719 public <T> void async(WriteInterface<T> r) {
2720 r.request(this, new ProcedureAdapter<T>());
2724 * Implementation of the interface AsyncReadGraph
2728 public void forURI(Resource resource, AsyncListener<String> listener) {
2729 asyncRequest(new org.simantics.db.common.uri.ResourceToURI(resource),
2734 public void forURI(Resource resource, SyncListener<String> listener) {
2735 asyncRequest(new org.simantics.db.common.uri.ResourceToURI(resource),
2740 public void forURI(Resource resource, Listener<String> listener) {
2741 asyncRequest(new org.simantics.db.common.uri.ResourceToURI(resource),
2746 final public void forURI(final Resource resource,
2747 final AsyncProcedure<String> procedure) {
2749 assert (resource != null);
2750 assert (procedure != null);
2752 asyncRequest(new org.simantics.db.common.uri.ResourceToURI(resource),
2758 public void forURI(Resource resource, SyncProcedure<String> procedure) {
2759 forURI(resource, new SyncToAsyncProcedure<String>(procedure));
2763 public void forURI(Resource resource, Procedure<String> procedure) {
2764 forURI(resource, new NoneToAsyncProcedure<String>(procedure));
2768 public void forResource(String id, AsyncListener<Resource> listener) {
2769 asyncRequest(new org.simantics.db.common.primitiverequest.Resource(id),
2774 public void forResource(String id, SyncListener<Resource> listener) {
2775 asyncRequest(new org.simantics.db.common.primitiverequest.Resource(id),
2780 public void forResource(String id, Listener<Resource> listener) {
2781 asyncRequest(new org.simantics.db.common.primitiverequest.Resource(id),
2786 final public void forResource(final String id,
2787 final AsyncProcedure<Resource> procedure) {
2789 assert (id != null);
2790 assert (procedure != null);
2792 processor.forResource(this, id, procedure);
2797 public void forResource(String id, SyncProcedure<Resource> procedure) {
2798 forResource(id, new SyncToAsyncProcedure<Resource>(procedure));
2802 public void forResource(String id, Procedure<Resource> procedure) {
2803 forResource(id, new NoneToAsyncProcedure<Resource>(procedure));
2807 public void forBuiltin(String id, AsyncListener<Resource> listener) {
2808 asyncRequest(new Builtin(id), listener);
2812 public void forBuiltin(String id, SyncListener<Resource> listener) {
2813 asyncRequest(new Builtin(id), listener);
2817 public void forBuiltin(String id, Listener<Resource> listener) {
2818 asyncRequest(new Builtin(id), listener);
2822 final public void forBuiltin(final String id,
2823 final AsyncProcedure<Resource> procedure) {
2825 assert (id != null);
2826 assert (procedure != null);
2828 processor.forBuiltin(this, id, procedure);
2833 public void forBuiltin(String id, SyncProcedure<Resource> procedure) {
2834 forBuiltin(id, new SyncToAsyncProcedure<Resource>(procedure));
2838 public void forBuiltin(String id, Procedure<Resource> procedure) {
2839 forBuiltin(id, new NoneToAsyncProcedure<Resource>(procedure));
2843 final public void forEachStatement(Resource subject, Resource relation,
2844 AsyncMultiProcedure<Statement> procedure) {
2846 assert (subject != null);
2847 assert (relation != null);
2848 assert (procedure != null);
2850 processor.forEachStatement(this, subject, relation, procedure);
2855 public void forEachStatement(Resource subject, Resource relation,
2856 SyncMultiProcedure<Statement> procedure) {
2857 forEachStatement(subject, relation,
2858 new SyncToAsyncMultiProcedure<Statement>(procedure));
2862 final public void forEachStatement(Resource subject, Resource relation,
2863 MultiProcedure<Statement> procedure) {
2865 assert (subject != null);
2866 assert (relation != null);
2867 assert (procedure != null);
2869 processor.forEachStatement(this, subject, relation, procedure);
2874 final public void forStatementSet(Resource subject, Resource relation,
2875 AsyncSetListener<Statement> procedure) {
2877 assert (subject != null);
2878 assert (relation != null);
2879 assert (procedure != null);
2881 processor.forStatementSet(this, subject, relation, procedure);
2886 final public void forStatementSet(Resource subject, Resource relation,
2887 SyncSetListener<Statement> procedure) {
2888 forStatementSet(subject, relation,
2889 new SyncToAsyncSetProcedure<Statement>(procedure));
2893 public void forStatementSet(Resource subject, Resource relation,
2894 SetListener<Statement> listener) {
2895 forStatementSet(subject, relation,
2896 new NoneToAsyncSetProcedure<Statement>(listener));
2900 final public void forEachAssertedStatement(final Resource subject,
2901 final Resource relation,
2902 final AsyncMultiProcedure<Statement> procedure) {
2904 assert (subject != null);
2905 assert (relation != null);
2906 assert (procedure != null);
2908 processor.forEachAssertedStatement(this, subject, relation, procedure);
2913 public void forEachAssertedStatement(Resource subject, Resource relation,
2914 SyncMultiProcedure<Statement> procedure) {
2915 forEachAssertedStatement(subject, relation,
2916 new SyncToAsyncMultiProcedure<Statement>(procedure));
2920 public void forEachAssertedStatement(Resource subject, Resource relation,
2921 MultiProcedure<Statement> procedure) {
2922 forEachAssertedStatement(subject, relation,
2923 new NoneToAsyncMultiProcedure<Statement>(procedure));
2927 public void forAssertedStatementSet(Resource subject, Resource relation,
2928 AsyncSetListener<Statement> procedure) {
2930 assert (subject != null);
2931 assert (relation != null);
2932 assert (procedure != null);
2934 processor.forAssertedStatementSet(this, subject, relation, procedure);
2939 public void forAssertedStatementSet(Resource subject, Resource relation,
2940 SyncSetListener<Statement> procedure) {
2942 assert (subject != null);
2943 assert (relation != null);
2944 assert (procedure != null);
2946 forAssertedStatementSet(subject, relation,
2947 new SyncToAsyncSetProcedure<Statement>(procedure));
2952 public void forAssertedStatementSet(Resource subject, Resource relation,
2953 SetListener<Statement> procedure) {
2955 assert (subject != null);
2956 assert (relation != null);
2957 assert (procedure != null);
2959 forAssertedStatementSet(subject, relation,
2960 new NoneToAsyncSetProcedure<Statement>(procedure));
2965 final public void forEachPredicate(final Resource subject,
2966 final AsyncMultiProcedure<Resource> procedure) {
2968 assert (subject != null);
2969 assert (procedure != null);
2971 processor.forEachPredicate(this, subject, procedure);
2976 public void forEachPredicate(Resource subject,
2977 SyncMultiProcedure<Resource> procedure) {
2978 forEachPredicate(subject, new SyncToAsyncMultiProcedure<Resource>(
2983 final public void forEachPredicate(final Resource subject,
2984 final MultiProcedure<Resource> procedure) {
2986 assert (subject != null);
2987 assert (procedure != null);
2989 processor.forEachPredicate(this, subject, procedure);
2994 final public void forPredicateSet(final Resource subject,
2995 final AsyncSetListener<Resource> procedure) {
2997 assert (subject != null);
2998 assert (procedure != null);
3000 processor.forPredicateSet(this, subject, procedure);
3005 final public void forPredicateSet(final Resource subject,
3006 final SyncSetListener<Resource> procedure) {
3008 assert (subject != null);
3009 assert (procedure != null);
3011 forPredicateSet(subject, new SyncToAsyncSetProcedure<Resource>(
3017 final public void forPredicateSet(final Resource subject,
3018 final SetListener<Resource> procedure) {
3020 assert (subject != null);
3021 assert (procedure != null);
3023 forPredicateSet(subject, new NoneToAsyncSetProcedure<Resource>(
3029 final public void forEachPrincipalType(final Resource subject,
3030 final AsyncMultiProcedure<Resource> procedure) {
3032 assert (subject != null);
3033 assert (procedure != null);
3035 processor.forEachPrincipalType(this, subject, procedure);
3040 public void forEachPrincipalType(Resource subject,
3041 SyncMultiProcedure<Resource> procedure) {
3042 forEachPrincipalType(subject, new SyncToAsyncMultiProcedure<Resource>(
3047 final public void forEachPrincipalType(final Resource subject,
3048 final MultiProcedure<Resource> procedure) {
3050 assert (subject != null);
3051 assert (procedure != null);
3053 processor.forEachPrincipalType(this, subject, procedure);
3058 final public void forPrincipalTypeSet(final Resource subject,
3059 final AsyncSetListener<Resource> procedure) {
3061 assert (subject != null);
3062 assert (procedure != null);
3064 processor.forPrincipalTypeSet(this, subject, procedure);
3069 final public void forPrincipalTypeSet(final Resource subject,
3070 final SyncSetListener<Resource> procedure) {
3072 assert (subject != null);
3073 assert (procedure != null);
3075 forPrincipalTypeSet(subject, new SyncToAsyncSetProcedure<Resource>(
3081 final public void forPrincipalTypeSet(final Resource subject,
3082 final SetListener<Resource> procedure) {
3084 assert (subject != null);
3085 assert (procedure != null);
3087 forPrincipalTypeSet(subject, new NoneToAsyncSetProcedure<Resource>(
3093 public void forTypes(Resource subject, AsyncListener<Set<Resource>> listener) {
3094 asyncRequest(new Types(subject), listener);
3098 public void forTypes(Resource subject, SyncListener<Set<Resource>> listener) {
3099 asyncRequest(new Types(subject), listener);
3103 public void forTypes(Resource subject, Listener<Set<Resource>> listener) {
3104 asyncRequest(new Types(subject), listener);
3108 final public void forTypes(final Resource subject,
3109 final AsyncProcedure<Set<Resource>> procedure) {
3111 assert (subject != null);
3112 assert (procedure != null);
3114 processor.forTypes(this, subject, procedure);
3119 public void forTypes(Resource subject,
3120 SyncProcedure<Set<Resource>> procedure) {
3121 forTypes(subject, new SyncToAsyncProcedure<Set<Resource>>(procedure));
3125 public void forTypes(Resource subject, Procedure<Set<Resource>> procedure) {
3126 forTypes(subject, new NoneToAsyncProcedure<Set<Resource>>(procedure));
3130 public void forSupertypes(Resource subject,
3131 AsyncListener<Set<Resource>> listener) {
3132 asyncRequest(new Types(subject), listener);
3136 public void forSupertypes(Resource subject,
3137 SyncListener<Set<Resource>> listener) {
3138 asyncRequest(new Types(subject), listener);
3142 public void forSupertypes(Resource subject, Listener<Set<Resource>> listener) {
3143 asyncRequest(new Types(subject), listener);
3147 final public void forSupertypes(final Resource subject,
3148 final AsyncProcedure<Set<Resource>> procedure) {
3150 assert (subject != null);
3151 assert (procedure != null);
3153 processor.forSupertypes(this, subject, procedure);
3158 public void forSupertypes(Resource subject,
3159 SyncProcedure<Set<Resource>> procedure) {
3160 forSupertypes(subject, new SyncToAsyncProcedure<Set<Resource>>(
3165 public void forSupertypes(Resource subject,
3166 Procedure<Set<Resource>> procedure) {
3167 forSupertypes(subject, new NoneToAsyncProcedure<Set<Resource>>(
3172 public void forDirectSuperrelations(Resource subject,
3173 AsyncMultiProcedure<Resource> procedure) {
3175 assert (subject != null);
3176 assert (procedure != null);
3178 processor.forDirectSuperrelations(this, subject, procedure);
3183 public void forPossibleSuperrelation(Resource subject, AsyncProcedure<Resource> procedure) {
3185 assert (subject != null);
3186 assert (procedure != null);
3188 processor.forPossibleSuperrelation(this, subject, procedure);
3193 public void forSuperrelations(Resource subject,
3194 AsyncListener<Set<Resource>> listener) {
3195 asyncRequest(new Types(subject), listener);
3199 public void forSuperrelations(Resource subject,
3200 SyncListener<Set<Resource>> listener) {
3201 asyncRequest(new Types(subject), listener);
3205 public void forSuperrelations(Resource subject,
3206 Listener<Set<Resource>> listener) {
3207 asyncRequest(new Types(subject), listener);
3211 final public void forSuperrelations(final Resource subject,
3212 final AsyncProcedure<Set<Resource>> procedure) {
3214 assert (subject != null);
3215 assert (procedure != null);
3217 processor.forSuperrelations(this, subject, procedure);
3222 public void forSuperrelations(Resource subject,
3223 SyncProcedure<Set<Resource>> procedure) {
3224 forSuperrelations(subject, new SyncToAsyncProcedure<Set<Resource>>(
3229 public void forSuperrelations(Resource subject,
3230 Procedure<Set<Resource>> procedure) {
3231 forSuperrelations(subject, new NoneToAsyncProcedure<Set<Resource>>(
3236 final public void forEachObject(final Resource subject, final Resource relation, final AsyncMultiProcedure<Resource> procedure) {
3237 processor.forEachObject(this, subject, relation, procedure);
3241 public void forEachObject(Resource subject, Resource relation,
3242 SyncMultiProcedure<Resource> procedure) {
3243 forEachObject(subject, relation,
3244 new SyncToAsyncMultiProcedure<Resource>(procedure));
3248 public void forEachObject(Resource subject, Resource relation,
3249 MultiProcedure<Resource> procedure) {
3251 processor.forEachObject(this, subject, relation, procedure);
3256 // final public void forEachDirectObject(final Resource subject,
3257 // final Resource relation,
3258 // final AsyncMultiProcedure<Resource> procedure) {
3260 // processor.forEachDirectObject(this, subject, relation, procedure);
3265 // public void forEachDirectObject(Resource subject, Resource relation,
3266 // SyncMultiProcedure<Resource> procedure) {
3267 // forEachDirectObject(subject, relation,
3268 // new SyncToAsyncMultiProcedure<Resource>(procedure));
3272 // public void forEachDirectObject(Resource subject, Resource relation,
3273 // MultiProcedure<Resource> procedure) {
3274 // forEachDirectObject(subject, relation,
3275 // new NoneToAsyncMultiProcedure<Resource>(procedure));
3279 final public void forEachDirectPredicate(final Resource subject, final AsyncMultiProcedure<Resource> procedure) {
3280 processor.forEachDirectPredicate(this, subject, procedure);
3284 public void forEachDirectPredicate(Resource subject, SyncMultiProcedure<Resource> procedure) {
3285 forEachDirectPredicate(subject, new SyncToAsyncMultiProcedure<Resource>(procedure));
3289 public void forEachDirectPredicate(Resource subject, MultiProcedure<Resource> procedure) {
3290 forEachDirectPredicate(subject, new NoneToAsyncMultiProcedure<Resource>(procedure));
3294 final public void forObjectSet(final Resource subject,
3295 final Resource relation, final AsyncSetListener<Resource> procedure) {
3297 assert (subject != null);
3298 assert (relation != null);
3299 assert (procedure != null);
3301 processor.forObjectSet(this, subject, relation, procedure);
3306 final public void forObjectSet(final Resource subject,
3307 final Resource relation, final SyncSetListener<Resource> procedure) {
3309 assert (subject != null);
3310 assert (relation != null);
3311 assert (procedure != null);
3313 forObjectSet(subject, relation, new SyncToAsyncSetProcedure<Resource>(
3319 final public void forObjectSet(final Resource subject,
3320 final Resource relation, final SetListener<Resource> procedure) {
3322 assert (subject != null);
3323 assert (relation != null);
3324 assert (procedure != null);
3326 forObjectSet(subject, relation, new NoneToAsyncSetProcedure<Resource>(
3332 final public void forEachAssertedObject(final Resource subject,
3333 final Resource relation,
3334 final AsyncMultiProcedure<Resource> procedure) {
3336 assert (subject != null);
3337 assert (relation != null);
3338 assert (procedure != null);
3340 processor.forEachAssertedObject(this, subject, relation, procedure);
3345 public void forEachAssertedObject(Resource subject, Resource relation,
3346 SyncMultiProcedure<Resource> procedure) {
3348 assert (subject != null);
3349 assert (relation != null);
3350 assert (procedure != null);
3352 forEachAssertedObject(subject, relation,
3353 new SyncToAsyncMultiProcedure<Resource>(procedure));
3358 public void forEachAssertedObject(Resource subject, Resource relation,
3359 MultiProcedure<Resource> procedure) {
3361 assert (subject != null);
3362 assert (relation != null);
3363 assert (procedure != null);
3365 forEachAssertedObject(subject, relation,
3366 new NoneToAsyncMultiProcedure<Resource>(procedure));
3371 public void forAssertedObjectSet(Resource subject, Resource relation,
3372 AsyncSetListener<Resource> procedure) {
3374 assert (subject != null);
3375 assert (relation != null);
3376 assert (procedure != null);
3378 processor.forAssertedObjectSet(this, subject, relation, procedure);
3383 public void forAssertedObjectSet(Resource subject, Resource relation,
3384 SyncSetListener<Resource> procedure) {
3386 assert (subject != null);
3387 assert (relation != null);
3388 assert (procedure != null);
3390 forAssertedObjectSet(subject, relation,
3391 new SyncToAsyncSetProcedure<Resource>(procedure));
3396 public void forAssertedObjectSet(Resource subject, Resource relation,
3397 SetListener<Resource> procedure) {
3399 assert (subject != null);
3400 assert (relation != null);
3401 assert (procedure != null);
3403 forAssertedObjectSet(subject, relation,
3404 new NoneToAsyncSetProcedure<Resource>(procedure));
3409 public void forInverse(Resource relation, AsyncListener<Resource> listener) {
3410 asyncRequest(new Inverse(relation), listener);
3414 public void forInverse(Resource relation, SyncListener<Resource> listener) {
3415 asyncRequest(new Inverse(relation), listener);
3419 public void forInverse(Resource relation, Listener<Resource> listener) {
3420 asyncRequest(new Inverse(relation), listener);
3424 final public void forInverse(final Resource relation,
3425 final AsyncProcedure<Resource> procedure) {
3427 assert (relation != null);
3428 assert (procedure != null);
3430 processor.forInverse(this, relation, new AsyncProcedure<Resource>() {
3433 public void execute(AsyncReadGraph graph, Resource result) {
3435 procedure.execute(graph, result);
3437 procedure.exception(graph, new NoInverseException(relation
3443 public void exception(AsyncReadGraph graph, Throwable throwable) {
3444 procedure.exception(graph, throwable);
3448 public String toString() {
3449 return "forInverse -> " + procedure;
3457 public void forInverse(Resource relation, SyncProcedure<Resource> procedure) {
3458 forInverse(relation, new SyncToAsyncProcedure<Resource>(procedure));
3462 public void forInverse(Resource relation, Procedure<Resource> procedure) {
3463 forInverse(relation, new NoneToAsyncProcedure<Resource>(procedure));
3467 public void forSingleObject(Resource subject, Resource relation,
3468 AsyncListener<Resource> listener) {
3469 asyncRequest(new SingleObject(subject, relation), listener);
3473 public void forSingleObject(Resource subject, Resource relation,
3474 SyncListener<Resource> listener) {
3475 asyncRequest(new SingleObject(subject, relation), listener);
3479 public void forSingleObject(Resource subject, Resource relation,
3480 Listener<Resource> listener) {
3481 asyncRequest(new SingleObject(subject, relation), listener);
3485 final public void forSingleObject(final Resource subject,
3486 final Resource relation, final AsyncProcedure<Resource> procedure) {
3488 assert (subject != null);
3489 assert (relation != null);
3490 assert (procedure != null);
3492 processor.forEachObject(this, subject, relation,
3493 new SingleOrErrorProcedure<Resource>(procedure));
3498 public void forSingleObject(Resource subject, Resource relation,
3499 SyncProcedure<Resource> procedure) {
3500 forSingleObject(subject, relation, new SyncToAsyncProcedure<Resource>(
3505 public void forSingleObject(Resource subject, Resource relation,
3506 Procedure<Resource> procedure) {
3507 forSingleObject(subject, relation, new NoneToAsyncProcedure<Resource>(
3512 public void forSingleStatement(Resource subject, Resource relation,
3513 AsyncListener<Statement> listener) {
3514 asyncRequest(new SingleStatement(subject, relation), listener);
3518 public void forSingleStatement(Resource subject, Resource relation,
3519 SyncListener<Statement> listener) {
3520 asyncRequest(new SingleStatement(subject, relation), listener);
3524 public void forSingleStatement(Resource subject, Resource relation,
3525 Listener<Statement> listener) {
3526 asyncRequest(new SingleStatement(subject, relation), listener);
3530 final public void forSingleStatement(final Resource subject,
3531 final Resource relation, final AsyncProcedure<Statement> procedure) {
3533 assert (subject != null);
3534 assert (relation != null);
3535 assert (procedure != null);
3537 processor.forEachStatement(this, subject, relation,
3538 new SingleOrErrorProcedure<Statement>(procedure));
3543 public void forSingleStatement(Resource subject, Resource relation,
3544 SyncProcedure<Statement> procedure) {
3545 forSingleStatement(subject, relation,
3546 new SyncToAsyncProcedure<Statement>(procedure));
3550 public void forSingleStatement(Resource subject, Resource relation,
3551 Procedure<Statement> procedure) {
3552 forSingleStatement(subject, relation,
3553 new NoneToAsyncProcedure<Statement>(procedure));
3557 public void forSingleType(Resource subject,
3558 AsyncListener<Resource> listener) {
3559 asyncRequest(new SingleTypeAny(subject), listener);
3563 public void forSingleType(Resource subject,
3564 SyncListener<Resource> listener) {
3565 asyncRequest(new SingleTypeAny(subject), listener);
3569 public void forSingleType(Resource subject,
3570 Listener<Resource> listener) {
3571 asyncRequest(new SingleTypeAny(subject), listener);
3575 final public void forSingleType(final Resource subject, final AsyncProcedure<Resource> procedure) {
3577 assert (subject != null);
3578 assert (procedure != null);
3580 final DeepSingleOrErrorProcedure<Resource> checkedProcedure = new DeepSingleOrErrorProcedure<Resource>(procedure);
3582 processor.forEachPrincipalType(this, subject, new AsyncMultiProcedureAdapter<Resource>() {
3585 public void execute(AsyncReadGraph graph, final Resource principalType) {
3586 checkedProcedure.offer(graph, principalType);
3590 public void finished(AsyncReadGraph graph) {
3591 checkedProcedure.dec(graph);
3595 public void exception(AsyncReadGraph graph, Throwable t) {
3596 checkedProcedure.exception(graph, t);
3600 public String toString() {
3601 return "forSingleType -> " + procedure;
3609 public void forSingleType(Resource subject, SyncProcedure<Resource> procedure) {
3610 forSingleType(subject, new SyncToAsyncProcedure<Resource>(
3615 public void forSingleType(Resource subject, Procedure<Resource> procedure) {
3616 forSingleType(subject, new NoneToAsyncProcedure<Resource>(
3621 public void forSingleType(Resource subject, Resource relation,
3622 AsyncListener<Resource> listener) {
3623 asyncRequest(new SingleType(subject, relation), listener);
3627 public void forSingleType(Resource subject, Resource relation,
3628 SyncListener<Resource> listener) {
3629 asyncRequest(new SingleType(subject, relation), listener);
3633 public void forSingleType(Resource subject, Resource relation,
3634 Listener<Resource> listener) {
3635 asyncRequest(new SingleType(subject, relation), listener);
3639 final public void forSingleType(final Resource subject,
3640 final Resource baseType, final AsyncProcedure<Resource> procedure) {
3642 assert (subject != null);
3643 assert (procedure != null);
3645 final DeepSingleOrErrorProcedure<Resource> checkedProcedure = new DeepSingleOrErrorProcedure<Resource>(procedure);
3647 processor.forEachPrincipalType(this, subject,
3648 new AsyncMultiProcedureAdapter<Resource>() {
3651 public void execute(AsyncReadGraph graph,
3652 final Resource principalType) {
3654 checkedProcedure.inc();
3656 if(baseType == null) {
3658 checkedProcedure.offer(graph, principalType);
3659 checkedProcedure.dec(graph);
3661 } else if(principalType.equals(baseType)) {
3663 checkedProcedure.offer(graph, principalType);
3664 checkedProcedure.dec(graph);
3668 processor.forSupertypes((ReadGraphImpl)graph, principalType,
3669 new AsyncProcedure<Set<Resource>>() {
3672 public void execute(
3673 AsyncReadGraph graph,
3674 Set<Resource> result) {
3676 if (result.contains(baseType))
3677 checkedProcedure.offer(graph,
3679 checkedProcedure.dec(graph);
3684 public void exception(
3685 AsyncReadGraph graph,
3688 .exception(graph, t);
3698 public void finished(AsyncReadGraph graph) {
3699 checkedProcedure.dec(graph);
3703 public void exception(AsyncReadGraph graph, Throwable t) {
3704 checkedProcedure.exception(graph, t);
3708 public String toString() {
3709 return "forSingleType -> " + procedure;
3717 public void forSingleType(Resource subject, Resource relation,
3718 SyncProcedure<Resource> procedure) {
3719 forSingleType(subject, relation, new SyncToAsyncProcedure<Resource>(
3724 public void forSingleType(Resource subject, Resource relation,
3725 Procedure<Resource> procedure) {
3726 forSingleType(subject, relation, new NoneToAsyncProcedure<Resource>(
3731 public <T> void forValue(Resource subject, Binding binding,
3732 AsyncListener<T> listener) {
3733 asyncRequest(new Value<T>(subject, binding), listener);
3737 public <T> void forValue(Resource subject, Binding binding,
3738 SyncListener<T> listener) {
3739 asyncRequest(new Value<T>(subject, binding), listener);
3743 public <T> void forValue(Resource subject, Binding binding,
3744 Listener<T> listener) {
3745 asyncRequest(new Value<T>(subject, binding), listener);
3749 public <T> void forValue(final Resource resource, final Binding binding,
3750 final AsyncProcedure<T> procedure) {
3752 assert (resource != null);
3753 assert (binding != null);
3754 assert (procedure != null);
3756 processor.forValue(this, resource, new AsyncProcedure<byte[]>() {
3759 public void execute(AsyncReadGraph graph, byte[] result) {
3763 if (result == null) {
3764 procedure.exception(graph,
3765 new DoesNotContainValueException(
3766 "No value for resource " + resource));
3770 Serializer serializer = binding.serializer();
3771 // Serializer serializer = Bindings.getSerializer( binding );
3772 Object obj = serializer.deserialize(result);
3773 // if (!binding.isInstance(obj))
3774 // procedure.exception(graph, new ClassCastException(
3775 // "Cannot get value " + obj + " with binding "
3778 procedure.execute(graph, (T) obj);
3780 } catch (IOException e) {
3781 procedure.exception(graph, e);
3782 } catch (BufferUnderflowException e) {
3783 procedure.exception(graph, e);
3784 } catch (Throwable t) {
3785 procedure.exception(graph, t);
3791 public void exception(AsyncReadGraph graph, Throwable t) {
3793 procedure.exception(graph, t);
3794 } catch (Throwable t2) {
3795 Logger.defaultLogError(t2);
3800 public String toString() {
3801 return "forValue -> " + procedure;
3809 public <T> void forValue(Resource subject, Binding binding,
3810 SyncProcedure<T> procedure) {
3811 forValue(subject, binding, new SyncToAsyncProcedure<T>(procedure));
3815 public <T> void forValue(Resource subject, Binding binding,
3816 Procedure<T> procedure) {
3817 forValue(subject, binding, new NoneToAsyncProcedure<T>(procedure));
3821 public <T> void forValue(Resource subject, AsyncListener<T> listener) {
3822 asyncRequest(new ValueImplied<T>(subject), listener);
3826 public <T> void forValue(Resource subject, SyncListener<T> listener) {
3827 asyncRequest(new ValueImplied<T>(subject), listener);
3831 public <T> void forValue(Resource subject, Listener<T> listener) {
3832 asyncRequest(new ValueImplied<T>(subject), listener);
3836 final public <T> void forValue(final Resource subject, final AsyncProcedure<T> procedure) {
3838 assert (subject != null);
3839 assert (procedure != null);
3841 forRelatedValue(subject, processor.getL0(this).HasDataType, DATA_TYPE_BINDING_INTERNAL, new AsyncProcedure<Datatype>() {
3844 public void execute(AsyncReadGraph graph, Datatype type) {
3845 // TODO: consider trying Bindings.getBeanBinding(type);
3846 Binding binding = Bindings.getBinding(type);
3847 graph.forValue(subject, binding, procedure);
3851 public void exception(AsyncReadGraph graph, Throwable throwable) {
3852 procedure.exception(graph, new DoesNotContainValueException("Invalid data type", throwable));
3860 public <T> void forValue(Resource subject, SyncProcedure<T> procedure) {
3861 forValue(subject, new SyncToAsyncProcedure<T>(procedure));
3865 public <T> void forValue(Resource subject, Procedure<T> procedure) {
3866 forValue(subject, new NoneToAsyncProcedure<T>(procedure));
3870 public <T> void forRelatedValue(Resource subject, Resource relation,
3871 AsyncListener<T> listener) {
3872 asyncRequest(new RelatedValueImplied<T>(subject, relation), listener);
3876 public <T> void forRelatedValue(Resource subject, Resource relation,
3877 SyncListener<T> listener) {
3878 asyncRequest(new RelatedValueImplied<T>(subject, relation), listener);
3882 public <T> void forRelatedValue(Resource subject, Resource relation,
3883 Listener<T> listener) {
3884 asyncRequest(new RelatedValueImplied<T>(subject, relation), listener);
3888 final public <T> void forRelatedValue(final Resource subject,
3889 final Resource relation, final AsyncProcedure<T> procedure) {
3891 assert (subject != null);
3892 assert (relation != null);
3893 assert (procedure != null);
3895 final DeepSingleOrErrorProcedure<T> checkedProcedure = new DeepSingleOrErrorProcedure<T>(procedure);
3897 processor.forEachObject(this, subject, relation,
3898 new AsyncMultiProcedureAdapter<Resource>() {
3901 public void execute(AsyncReadGraph graph,
3902 final Resource object) {
3904 checkedProcedure.inc();
3906 graph.forValue(object, new AsyncProcedure<Object>() {
3909 public void execute(AsyncReadGraph graph,
3911 checkedProcedure.offer(graph, (T) result);
3912 checkedProcedure.dec(graph);
3916 public void exception(AsyncReadGraph graph,
3918 checkedProcedure.exception(graph, t);
3922 public String toString() {
3923 return "forRelatedValue -> " + procedure;
3931 public void finished(AsyncReadGraph graph) {
3932 checkedProcedure.dec(graph);
3936 public void exception(AsyncReadGraph graph, Throwable t) {
3937 checkedProcedure.exception(graph, t);
3945 public <T> void forRelatedValue(Resource subject, Resource relation,
3946 SyncProcedure<T> procedure) {
3947 forRelatedValue(subject, relation, new SyncToAsyncProcedure<T>(
3952 public <T> void forRelatedValue(Resource subject, Resource relation,
3953 Procedure<T> procedure) {
3954 forRelatedValue(subject, relation, new NoneToAsyncProcedure<T>(
3959 public <T> void forRelatedValue(Resource subject, Resource relation,
3960 Binding binding, AsyncListener<T> listener) {
3961 asyncRequest(new RelatedValue<T>(subject, relation, binding), listener);
3965 public <T> void forRelatedValue(Resource subject, Resource relation,
3966 Binding binding, SyncListener<T> listener) {
3967 asyncRequest(new RelatedValue<T>(subject, relation, binding), listener);
3971 public <T> void forRelatedValue(Resource subject, Resource relation,
3972 Binding binding, Listener<T> listener) {
3973 asyncRequest(new RelatedValue<T>(subject, relation, binding), listener);
3977 final public <T> void forRelatedValue(final Resource subject,
3978 final Resource relation, final Binding binding,
3979 final AsyncProcedure<T> procedure) {
3981 assert (subject != null);
3982 assert (relation != null);
3983 assert (binding != null);
3984 assert (procedure != null);
3986 final DeepSingleOrErrorProcedure<T> checkedProcedure = new DeepSingleOrErrorProcedure<T>(procedure);
3988 processor.forEachObject(this, subject, relation,
3989 new AsyncMultiProcedureAdapter<Resource>() {
3992 public void execute(AsyncReadGraph graph,
3993 final Resource object) {
3995 checkedProcedure.inc();
3997 graph.forValue(object, binding, new AsyncProcedure<Object>() {
4000 public void execute(AsyncReadGraph graph,
4003 checkedProcedure.offer(graph,
4005 checkedProcedure.dec(graph);
4009 public void exception(AsyncReadGraph graph,
4011 checkedProcedure.exception(graph, t);
4015 public String toString() {
4016 return "forRelatedValue -> "
4025 public void finished(AsyncReadGraph graph) {
4026 checkedProcedure.dec(graph);
4030 public void exception(AsyncReadGraph graph, Throwable t) {
4031 checkedProcedure.exception(graph, t);
4039 public <T> void forRelatedValue(Resource subject, Resource relation,
4040 Binding binding, SyncProcedure<T> procedure) {
4041 forRelatedValue(subject, relation, binding,
4042 new SyncToAsyncProcedure<T>(procedure));
4046 public <T> void forRelatedValue(Resource subject, Resource relation,
4047 Binding binding, Procedure<T> procedure) {
4048 forRelatedValue(subject, relation, binding,
4049 new NoneToAsyncProcedure<T>(procedure));
4053 public <T> void forAdapted(Resource resource, Class<T> clazz,
4054 AsyncListener<T> listener) {
4055 asyncRequest(new Adapter<T>(resource, clazz), listener);
4059 public <T> void forAdapted(Resource resource, Class<T> clazz,
4060 SyncListener<T> listener) {
4061 asyncRequest(new Adapter<T>(resource, clazz), listener);
4065 public <T> void forAdapted(Resource resource, Class<T> clazz,
4066 Listener<T> listener) {
4067 asyncRequest(new Adapter<T>(resource, clazz), listener);
4071 final public <T> void forAdapted(final Resource resource,
4072 final Class<T> clazz, final AsyncProcedure<T> procedure) {
4074 assert (resource != null);
4075 assert (clazz != null);
4076 assert (procedure != null);
4078 final AdaptionService service = getSession().peekService(AdaptionService.class);
4079 if (service == null)
4080 procedure.exception(this, new ServiceException("No AdaptionService available"));
4082 service.adapt(this, resource, resource, Resource.class, clazz, false, procedure);
4087 public <T> void forAdapted(Resource resource, Class<T> clazz,
4088 SyncProcedure<T> procedure) {
4089 forAdapted(resource, clazz, new SyncToAsyncProcedure<T>(procedure));
4093 public <T> void forAdapted(Resource resource, Class<T> clazz,
4094 Procedure<T> procedure) {
4095 forAdapted(resource, clazz, new NoneToAsyncProcedure<T>(procedure));
4099 public <T> void forUniqueAdapted(Resource resource, Class<T> clazz,
4100 AsyncListener<T> listener) {
4101 asyncRequest(new UniqueAdapter<T>(resource, clazz), listener);
4105 public <T> void forUniqueAdapted(Resource resource, Class<T> clazz,
4106 SyncListener<T> listener) {
4107 asyncRequest(new UniqueAdapter<T>(resource, clazz), listener);
4111 public <T> void forUniqueAdapted(Resource resource, Class<T> clazz,
4112 Listener<T> listener) {
4113 asyncRequest(new UniqueAdapter<T>(resource, clazz), listener);
4117 final public <T> void forUniqueAdapted(final Resource resource,
4118 final Class<T> clazz, final AsyncProcedure<T> procedure) {
4120 assert (resource != null);
4121 assert (clazz != null);
4122 assert (procedure != null);
4124 final AdaptionService service = getSession().peekService(AdaptionService.class);
4125 if (service == null)
4126 procedure.exception(this, new ServiceException("No AdaptionService available"));
4128 service.adaptNew(this, resource, clazz, false, procedure);
4133 public <T> void forUniqueAdapted(Resource resource, Class<T> clazz,
4134 SyncProcedure<T> procedure) {
4135 forUniqueAdapted(resource, clazz,
4136 new SyncToAsyncProcedure<T>(procedure));
4140 public <T> void forUniqueAdapted(Resource resource, Class<T> clazz,
4141 Procedure<T> procedure) {
4142 forUniqueAdapted(resource, clazz,
4143 new NoneToAsyncProcedure<T>(procedure));
4147 public void forPossibleInverse(Resource subject,
4148 AsyncListener<Resource> listener) {
4149 asyncRequest(new PossibleInverse(subject), listener);
4153 public void forPossibleInverse(Resource subject,
4154 SyncListener<Resource> listener) {
4155 asyncRequest(new PossibleInverse(subject), listener);
4159 public void forPossibleInverse(Resource subject, Listener<Resource> listener) {
4160 asyncRequest(new PossibleInverse(subject), listener);
4164 final public void forPossibleInverse(final Resource relation,
4165 final AsyncProcedure<Resource> procedure) {
4167 assert (relation != null);
4168 assert (procedure != null);
4170 processor.forInverse(this, relation, new ExceptionToNullProcedure<Resource>(procedure));
4175 public void forPossibleInverse(Resource subject,
4176 SyncProcedure<Resource> procedure) {
4177 forPossibleInverse(subject, new SyncToAsyncProcedure<Resource>(
4182 public void forPossibleInverse(Resource subject,
4183 Procedure<Resource> procedure) {
4184 forPossibleInverse(subject, new NoneToAsyncProcedure<Resource>(
4189 public void forPossibleObject(Resource subject, Resource relation,
4190 AsyncListener<Resource> listener) {
4191 asyncRequest(new PossibleObject(subject, relation), listener);
4195 public void forPossibleObject(Resource subject, Resource relation,
4196 SyncListener<Resource> listener) {
4197 asyncRequest(new PossibleObject(subject, relation), listener);
4201 public void forPossibleObject(Resource subject, Resource relation,
4202 Listener<Resource> listener) {
4203 asyncRequest(new PossibleObject(subject, relation), listener);
4207 final public void forPossibleObject(final Resource subject,
4208 final Resource relation, final AsyncProcedure<Resource> procedure) {
4210 assert (subject != null);
4211 assert (relation != null);
4212 assert (procedure != null);
4214 processor.forEachObject(this, subject, relation,
4215 new SingleOrNullProcedure<Resource>(procedure));
4220 public void forPossibleObject(Resource subject, Resource relation,
4221 SyncProcedure<Resource> procedure) {
4222 forPossibleObject(subject, relation,
4223 new SyncToAsyncProcedure<Resource>(procedure));
4227 public void forPossibleObject(Resource subject, Resource relation,
4228 Procedure<Resource> procedure) {
4229 forPossibleObject(subject, relation,
4230 new NoneToAsyncProcedure<Resource>(procedure));
4234 public void forPossibleStatement(Resource subject, Resource relation,
4235 AsyncListener<Statement> listener) {
4236 asyncRequest(new PossibleStatement(subject, relation), listener);
4240 public void forPossibleStatement(Resource subject, Resource relation,
4241 SyncListener<Statement> listener) {
4242 asyncRequest(new PossibleStatement(subject, relation), listener);
4246 public void forPossibleStatement(Resource subject, Resource relation,
4247 Listener<Statement> listener) {
4248 asyncRequest(new PossibleStatement(subject, relation), listener);
4252 final public void forPossibleStatement(final Resource subject,
4253 final Resource relation, final AsyncProcedure<Statement> procedure) {
4255 assert (subject != null);
4256 assert (relation != null);
4257 assert (procedure != null);
4259 processor.forEachStatement(this, subject, relation,
4260 new SingleFunctionalOrNullProcedure<Statement>(
4261 "forPossibleStatement", procedure));
4266 public void forPossibleStatement(Resource subject, Resource relation,
4267 SyncProcedure<Statement> procedure) {
4268 forPossibleStatement(subject, relation,
4269 new SyncToAsyncProcedure<Statement>(procedure));
4273 public void forPossibleStatement(Resource subject, Resource relation,
4274 Procedure<Statement> procedure) {
4275 forPossibleStatement(subject, relation,
4276 new NoneToAsyncProcedure<Statement>(procedure));
4280 public void forPossibleType(Resource subject, Resource relation,
4281 AsyncListener<Resource> listener) {
4282 asyncRequest(new PossibleType(subject, relation), listener);
4286 public void forPossibleType(Resource subject, Resource relation,
4287 SyncListener<Resource> listener) {
4288 asyncRequest(new PossibleType(subject, relation), listener);
4292 public void forPossibleType(Resource subject, Resource relation,
4293 Listener<Resource> listener) {
4294 asyncRequest(new PossibleType(subject, relation), listener);
4298 final public void forPossibleType(final Resource subject,
4299 final Resource baseType, final AsyncProcedure<Resource> procedure) {
4301 assert (subject != null);
4302 assert (procedure != null);
4304 final NullSingleOrNullProcedure<Resource> checkedProcedure = new NullSingleOrNullProcedure<Resource>(procedure);
4306 processor.forEachPrincipalType(this, subject, new AsyncMultiProcedureAdapter<Resource>() {
4309 public void execute(AsyncReadGraph graph,
4310 final Resource principalType) {
4312 if (baseType == null) {
4314 checkedProcedure.offer(graph, principalType);
4316 } else if (principalType.equals(baseType)) {
4318 checkedProcedure.offer(graph, principalType);
4322 checkedProcedure.inc();
4324 processor.forSupertypes((ReadGraphImpl)graph, principalType,
4325 new AsyncProcedure<Set<Resource>>() {
4328 public void execute(
4329 AsyncReadGraph graph,
4330 Set<Resource> result) {
4332 if (result.contains(baseType)) {
4333 checkedProcedure.offer(graph,
4337 checkedProcedure.dec(graph);
4342 public void exception(
4343 AsyncReadGraph graph,
4345 checkedProcedure.exception(graph, t);
4346 checkedProcedure.dec(graph);
4350 public String toString() {
4351 return "forPossibleType -> "
4362 public void finished(AsyncReadGraph graph) {
4363 checkedProcedure.dec(graph);
4367 public void exception(AsyncReadGraph graph, Throwable t) {
4368 checkedProcedure.exception(graph, t);
4369 checkedProcedure.dec(graph);
4377 public void forPossibleType(Resource subject, Resource relation,
4378 SyncProcedure<Resource> procedure) {
4379 forPossibleType(subject, relation, new SyncToAsyncProcedure<Resource>(
4384 public void forPossibleType(Resource subject, Resource relation,
4385 Procedure<Resource> procedure) {
4386 forPossibleType(subject, relation, new NoneToAsyncProcedure<Resource>(
4391 public <T> void forPossibleValue(Resource subject, AsyncListener<T> listener) {
4392 asyncRequest(new PossibleValueImplied<T>(subject), listener);
4396 public <T> void forPossibleValue(Resource subject, SyncListener<T> listener) {
4397 asyncRequest(new PossibleValueImplied<T>(subject), listener);
4401 public <T> void forPossibleValue(Resource subject, Listener<T> listener) {
4402 asyncRequest(new PossibleValueImplied<T>(subject), listener);
4406 final public <T> void forPossibleValue(final Resource subject,
4407 final AsyncProcedure<T> procedure) {
4409 assert (subject != null);
4410 assert (procedure != null);
4412 forPossibleRelatedValue(subject, processor.getL0(this).HasDataType, DATA_TYPE_BINDING_INTERNAL, new AsyncProcedure<Datatype>() {
4415 public void execute(AsyncReadGraph graph, final Datatype type) {
4417 procedure.execute(graph, null);
4420 // TODO: consider trying Bindings.getBeanBinding(type);
4421 Binding binding = Bindings.getBinding(type);
4422 graph.forPossibleValue(subject, binding, procedure);
4423 } catch (RuntimeBindingConstructionException e) {
4424 procedure.exception(graph, e);
4430 public void exception(AsyncReadGraph graph, Throwable t) {
4431 procedure.exception(graph, t);
4435 public String toString() {
4436 return "forPossibleValue -> " + procedure;
4444 public <T> void forPossibleValue(Resource subject,
4445 SyncProcedure<T> procedure) {
4446 forPossibleValue(subject, new SyncToAsyncProcedure<T>(procedure));
4450 public <T> void forPossibleValue(Resource subject, Procedure<T> procedure) {
4451 forPossibleValue(subject, new NoneToAsyncProcedure<T>(procedure));
4455 public <T> void forPossibleValue(Resource subject, Binding binding,
4456 AsyncListener<T> listener) {
4457 asyncRequest(new PossibleValue<T>(subject, binding), listener);
4461 public <T> void forPossibleValue(Resource subject, Binding binding,
4462 SyncListener<T> listener) {
4463 asyncRequest(new PossibleValue<T>(subject, binding), listener);
4467 public <T> void forPossibleValue(Resource subject, Binding binding,
4468 Listener<T> listener) {
4469 asyncRequest(new PossibleValue<T>(subject, binding), listener);
4473 final public <T> void forPossibleValue(final Resource resource,
4474 final Binding binding, final AsyncProcedure<T> procedure) {
4476 assert (resource != null);
4477 assert (binding != null);
4478 assert (procedure != null);
4480 processor.forValue(this, resource, new AsyncProcedure<byte[]>() {
4483 public void execute(AsyncReadGraph graph, byte[] result) {
4487 if (result == null) {
4488 procedure.execute(graph, null);
4492 Serializer serializer = Bindings.getSerializer( binding );
4493 Object obj = serializer.deserialize(result);
4494 if (!binding.isInstance(obj))
4495 procedure.exception(graph, new ClassCastException(
4496 "Cannot get value " + obj + " with binding "
4499 procedure.execute(graph, (T) obj);
4501 } catch (IOException e) {
4502 procedure.exception(graph, e);
4503 } catch (BufferUnderflowException e) {
4504 procedure.exception(graph, e);
4505 } catch (Throwable t) {
4506 procedure.exception(graph, t);
4512 public void exception(AsyncReadGraph graph, Throwable t) {
4514 procedure.exception(graph, t);
4515 } catch (Throwable t2) {
4516 Logger.defaultLogError(t2);
4521 public String toString() {
4522 return "forPossibleValue -> " + procedure;
4530 public <T> void forPossibleValue(Resource subject, Binding binding,
4531 SyncProcedure<T> procedure) {
4532 forPossibleValue(subject, binding, new SyncToAsyncProcedure<T>(
4537 public <T> void forPossibleValue(Resource subject, Binding binding,
4538 Procedure<T> procedure) {
4539 forPossibleValue(subject, binding, new NoneToAsyncProcedure<T>(
4544 public <T> void forPossibleRelatedValue(Resource subject,
4545 Resource relation, AsyncListener<T> listener) {
4546 asyncRequest(new PossibleRelatedValueImplied<T>(subject, relation),
4551 public <T> void forPossibleRelatedValue(Resource subject,
4552 Resource relation, SyncListener<T> listener) {
4553 asyncRequest(new PossibleRelatedValueImplied<T>(subject, relation),
4558 public <T> void forPossibleRelatedValue(Resource subject,
4559 Resource relation, Listener<T> listener) {
4560 asyncRequest(new PossibleRelatedValueImplied<T>(subject, relation),
4565 final public <T> void forPossibleRelatedValue(final Resource subject,
4566 final Resource relation, final AsyncProcedure<T> procedure) {
4568 assert (subject != null);
4569 assert (relation != null);
4570 assert (procedure != null);
4572 final DeepSingleOrNullProcedure<T> checkedProcedure = new DeepSingleOrNullProcedure<T>(procedure);
4574 processor.forEachObject(this, subject, relation,
4575 new AsyncMultiProcedureAdapter<Resource>() {
4578 public void execute(AsyncReadGraph graph,
4579 final Resource object) {
4581 checkedProcedure.inc();
4583 graph.forValue(object, new AsyncProcedure<Object>() {
4586 public void execute(AsyncReadGraph graph,
4588 checkedProcedure.offer(graph, (T) result);
4589 checkedProcedure.dec(graph);
4593 public void exception(AsyncReadGraph graph,
4595 checkedProcedure.exception(graph, t);
4596 checkedProcedure.dec(graph);
4604 public void finished(AsyncReadGraph graph) {
4606 checkedProcedure.dec(graph);
4610 public void exception(AsyncReadGraph graph, Throwable t) {
4611 checkedProcedure.exception(graph, t);
4612 checkedProcedure.dec(graph);
4616 public String toString() {
4617 return "forPossibleRelatedValue -> " + procedure;
4624 public <T> void forPossibleRelatedValue(Resource subject,
4625 Resource relation, SyncProcedure<T> procedure) {
4626 forPossibleRelatedValue(subject, relation, new SyncToAsyncProcedure<T>(
4631 public <T> void forPossibleRelatedValue(Resource subject,
4632 Resource relation, Procedure<T> procedure) {
4633 forPossibleRelatedValue(subject, relation, new NoneToAsyncProcedure<T>(
4638 public <T> void forPossibleRelatedValue(Resource subject,
4639 Resource relation, Binding binding, AsyncListener<T> listener) {
4640 asyncRequest(new PossibleRelatedValue<T>(subject, relation, binding),
4645 public <T> void forPossibleRelatedValue(Resource subject,
4646 Resource relation, Binding binding, SyncListener<T> listener) {
4647 asyncRequest(new PossibleRelatedValue<T>(subject, relation, binding),
4652 public <T> void forPossibleRelatedValue(Resource subject,
4653 Resource relation, Binding binding, Listener<T> listener) {
4654 asyncRequest(new PossibleRelatedValue<T>(subject, relation, binding),
4659 // final public <T> void forPossibleRelatedValue(final Resource subject, final Resource relation, final Binding binding,
4660 // final AsyncProcedure<T> procedure) {
4662 // forPossibleRelatedValue(subject, relation, binding, procedure, false);
4666 final public <T> void forPossibleRelatedValue(final Resource subject, final Resource relation, final Binding binding,
4667 final AsyncProcedure<T> procedure) {
4669 assert (subject != null);
4670 assert (relation != null);
4671 assert (procedure != null);
4673 processor.forPossibleObject(this, subject, relation, new AsyncProcedure<Resource>() {
4676 public void execute(AsyncReadGraph graph, Resource object) {
4678 if(object == null) {
4679 procedure.execute(graph, null);
4683 processor.forPossibleValue((ReadGraphImpl)graph, object, new AsyncProcedure<byte[]>() {
4686 public void execute(AsyncReadGraph graph, byte[] bytes) {
4692 Serializer serializer = binding.serializer();
4693 Object obj = serializer.deserialize(bytes);
4694 if (!binding.isInstance(obj)) {
4695 procedure.exception(graph, new ClassCastException("Cannot get value " + obj + " with binding " + binding));
4697 procedure.execute(graph, (T) obj);
4700 } catch (Throwable t) {
4702 procedure.exception(graph, t);
4708 procedure.execute(graph, null);
4715 public void exception(AsyncReadGraph graph, Throwable t) {
4716 procedure.exception(graph, t);
4724 public void exception(AsyncReadGraph graph, Throwable throwable) {
4725 throwable.printStackTrace();
4726 procedure.exception(graph, throwable);
4734 public <T> void forPossibleRelatedValue(Resource subject,
4735 Resource relation, Binding binding, SyncProcedure<T> procedure) {
4736 forPossibleRelatedValue(subject, relation, binding,
4737 new SyncToAsyncProcedure<T>(procedure));
4741 public <T> void forPossibleRelatedValue(Resource subject,
4742 Resource relation, Binding binding, Procedure<T> procedure) {
4743 forPossibleRelatedValue(subject, relation, binding,
4744 new NoneToAsyncProcedure<T>(procedure));
4748 public void forIsInstanceOf(Resource subject, Resource relation,
4749 AsyncListener<Boolean> listener) {
4750 asyncRequest(new IsInstanceOf(subject, relation), listener);
4754 public void forIsInstanceOf(Resource subject, Resource relation,
4755 SyncListener<Boolean> listener) {
4756 asyncRequest(new IsInstanceOf(subject, relation), listener);
4760 public void forIsInstanceOf(Resource subject, Resource relation,
4761 Listener<Boolean> listener) {
4762 asyncRequest(new IsInstanceOf(subject, relation), listener);
4766 final public void forIsInstanceOf(final Resource resource,
4767 final Resource type, final AsyncProcedure<Boolean> procedure) {
4769 assert (resource != null);
4770 assert (type != null);
4771 assert (procedure != null);
4773 forTypes(resource, new AsyncProcedure<Set<Resource>>() {
4776 public void execute(AsyncReadGraph graph, Set<Resource> result) {
4779 if (result.contains(type))
4780 procedure.execute(graph, true);
4782 procedure.execute(graph, false);
4783 } catch (Throwable t) {
4784 Logger.defaultLogError(t);
4789 public void exception(AsyncReadGraph graph, Throwable t) {
4791 procedure.exception(graph, t);
4792 } catch (Throwable t2) {
4793 Logger.defaultLogError(t2);
4798 public String toString() {
4799 return "forIsInstanceOf -> " + procedure;
4807 public void forIsInstanceOf(Resource subject, Resource relation,
4808 SyncProcedure<Boolean> procedure) {
4809 forIsInstanceOf(subject, relation, new SyncToAsyncProcedure<Boolean>(
4814 public void forIsInstanceOf(Resource subject, Resource relation,
4815 Procedure<Boolean> procedure) {
4816 forIsInstanceOf(subject, relation, new NoneToAsyncProcedure<Boolean>(
4821 public void forIsInheritedFrom(Resource subject, Resource relation,
4822 AsyncListener<Boolean> listener) {
4823 asyncRequest(new IsInheritedFrom(subject, relation), listener);
4827 public void forIsInheritedFrom(Resource subject, Resource relation,
4828 SyncListener<Boolean> listener) {
4829 asyncRequest(new IsInheritedFrom(subject, relation), listener);
4833 public void forIsInheritedFrom(Resource subject, Resource relation,
4834 Listener<Boolean> listener) {
4835 asyncRequest(new IsInheritedFrom(subject, relation), listener);
4839 final public void forIsInheritedFrom(final Resource resource,
4840 final Resource type, final AsyncProcedure<Boolean> procedure) {
4842 assert (resource != null);
4843 assert (type != null);
4844 assert (procedure != null);
4846 if (resource.equals(type)) {
4848 procedure.execute(this, true);
4849 } catch (Throwable t) {
4850 Logger.defaultLogError(t);
4855 forSupertypes(resource, new AsyncProcedure<Set<Resource>>() {
4858 public void execute(AsyncReadGraph graph, Set<Resource> result) {
4860 if (result.contains(type))
4861 procedure.execute(graph, true);
4863 procedure.execute(graph, false);
4864 } catch (Throwable t) {
4865 Logger.defaultLogError(t);
4870 public void exception(AsyncReadGraph graph, Throwable t) {
4872 procedure.exception(graph, t);
4873 } catch (Throwable t2) {
4874 Logger.defaultLogError(t2);
4879 public String toString() {
4880 return "forIsInheritedFrom -> " + procedure;
4888 public void forIsInheritedFrom(Resource subject, Resource relation,
4889 SyncProcedure<Boolean> procedure) {
4890 forIsInheritedFrom(subject, relation,
4891 new SyncToAsyncProcedure<Boolean>(procedure));
4895 public void forIsInheritedFrom(Resource subject, Resource relation,
4896 Procedure<Boolean> procedure) {
4897 forIsInheritedFrom(subject, relation,
4898 new NoneToAsyncProcedure<Boolean>(procedure));
4902 public void forIsSubrelationOf(Resource subject, Resource relation,
4903 AsyncListener<Boolean> listener) {
4904 asyncRequest(new IsSubrelationOf(subject, relation), listener);
4908 public void forIsSubrelationOf(Resource subject, Resource relation,
4909 SyncListener<Boolean> listener) {
4910 asyncRequest(new IsSubrelationOf(subject, relation), listener);
4914 public void forIsSubrelationOf(Resource subject, Resource relation,
4915 Listener<Boolean> listener) {
4916 asyncRequest(new IsSubrelationOf(subject, relation), listener);
4920 final public void forIsSubrelationOf(final Resource resource,
4921 final Resource relation, final AsyncProcedure<Boolean> procedure) {
4923 assert (resource != null);
4924 assert (relation != null);
4925 assert (procedure != null);
4927 if (resource.equals(relation)) {
4928 procedure.execute(this, true);
4932 forSuperrelations(resource, new AsyncProcedure<Set<Resource>>() {
4935 public void execute(AsyncReadGraph graph, Set<Resource> result) {
4937 if (result.contains(relation))
4938 procedure.execute(graph, true);
4940 procedure.execute(graph, false);
4941 } catch (Throwable t) {
4942 Logger.defaultLogError(t);
4947 public void exception(AsyncReadGraph graph, Throwable t) {
4949 procedure.exception(graph, t);
4950 } catch (Throwable t2) {
4951 Logger.defaultLogError(t2);
4956 public String toString() {
4957 return "forIsSubrelationOf -> " + procedure;
4965 public void forIsSubrelationOf(Resource subject, Resource relation,
4966 SyncProcedure<Boolean> procedure) {
4967 forIsSubrelationOf(subject, relation,
4968 new SyncToAsyncProcedure<Boolean>(procedure));
4972 public void forIsSubrelationOf(Resource subject, Resource relation,
4973 Procedure<Boolean> procedure) {
4974 forIsSubrelationOf(subject, relation,
4975 new NoneToAsyncProcedure<Boolean>(procedure));
4979 public void forHasStatement(Resource subject,
4980 AsyncListener<Boolean> listener) {
4981 asyncRequest(new HasStatementSubject(subject), listener);
4985 public void forHasStatement(Resource subject, SyncListener<Boolean> listener) {
4986 asyncRequest(new HasStatementSubject(subject), listener);
4990 public void forHasStatement(Resource subject, Listener<Boolean> listener) {
4991 asyncRequest(new HasStatementSubject(subject), listener);
4995 final public void forHasStatement(final Resource subject,
4996 final AsyncProcedure<Boolean> procedure) {
4998 assert (subject != null);
4999 assert (procedure != null);
5001 processor.forHasStatement(this, subject, procedure);
5006 public void forHasStatement(Resource subject,
5007 SyncProcedure<Boolean> procedure) {
5008 forHasStatement(subject, new SyncToAsyncProcedure<Boolean>(procedure));
5012 public void forHasStatement(Resource subject, Procedure<Boolean> procedure) {
5013 forHasStatement(subject, new NoneToAsyncProcedure<Boolean>(procedure));
5017 public void forHasStatement(Resource subject, Resource relation,
5018 AsyncListener<Boolean> listener) {
5019 asyncRequest(new HasStatement(subject, relation), listener);
5023 public void forHasStatement(Resource subject, Resource relation,
5024 SyncListener<Boolean> listener) {
5025 asyncRequest(new HasStatement(subject, relation), listener);
5029 public void forHasStatement(Resource subject, Resource relation,
5030 Listener<Boolean> listener) {
5031 asyncRequest(new HasStatement(subject, relation), listener);
5035 final public void forHasStatement(final Resource subject,
5036 final Resource relation, final AsyncProcedure<Boolean> procedure) {
5038 assert (subject != null);
5039 assert (relation != null);
5040 assert (procedure != null);
5042 processor.forHasStatement(this, subject, relation, procedure);
5047 public void forHasStatement(Resource subject, Resource relation,
5048 SyncProcedure<Boolean> procedure) {
5049 forHasStatement(subject, relation, new SyncToAsyncProcedure<Boolean>(
5054 public void forHasStatement(Resource subject, Resource relation,
5055 Procedure<Boolean> procedure) {
5056 forHasStatement(subject, relation, new NoneToAsyncProcedure<Boolean>(
5061 public void forHasStatement(Resource subject, Resource relation,
5062 Resource object, AsyncListener<Boolean> listener) {
5063 asyncRequest(new HasStatementSubjectObject(subject, relation, object),
5068 public void forHasStatement(Resource subject, Resource relation,
5069 Resource object, SyncListener<Boolean> listener) {
5070 asyncRequest(new HasStatementSubjectObject(subject, relation, object),
5075 public void forHasStatement(Resource subject, Resource relation,
5076 Resource object, Listener<Boolean> listener) {
5077 asyncRequest(new HasStatementSubjectObject(subject, relation, object),
5082 final public void forHasStatement(final Resource subject,
5083 final Resource relation, final Resource object,
5084 final AsyncProcedure<Boolean> procedure) {
5086 assert (subject != null);
5087 assert (relation != null);
5088 assert (object != null);
5089 assert (procedure != null);
5091 processor.forHasStatement(this, subject, relation, object, procedure);
5096 public void forHasStatement(Resource subject, Resource relation,
5097 Resource object, SyncProcedure<Boolean> procedure) {
5098 forHasStatement(subject, relation, object,
5099 new SyncToAsyncProcedure<Boolean>(procedure));
5103 public void forHasStatement(Resource subject, Resource relation,
5104 Resource object, Procedure<Boolean> procedure) {
5105 forHasStatement(subject, relation, object,
5106 new NoneToAsyncProcedure<Boolean>(procedure));
5110 public void forHasValue(Resource subject, AsyncListener<Boolean> listener) {
5111 asyncRequest(new HasValue(subject), listener);
5115 public void forHasValue(Resource subject, SyncListener<Boolean> listener) {
5116 asyncRequest(new HasValue(subject), listener);
5120 public void forHasValue(Resource subject, Listener<Boolean> listener) {
5121 asyncRequest(new HasValue(subject), listener);
5125 final public void forHasValue(final Resource subject,
5126 final AsyncProcedure<Boolean> procedure) {
5128 assert (subject != null);
5129 assert (procedure != null);
5131 processor.forValue(this, subject, new AsyncProcedure<byte[]>() {
5134 public void execute(AsyncReadGraph graph, byte[] result) {
5137 procedure.execute(graph, false);
5139 procedure.execute(graph, true);
5140 } catch (Throwable t) {
5141 Logger.defaultLogError(t);
5146 public void exception(AsyncReadGraph graph, Throwable t) {
5148 procedure.exception(graph, t);
5149 } catch (Throwable t2) {
5150 Logger.defaultLogError(t2);
5155 public String toString() {
5156 return "forHasValue -> " + procedure;
5164 public void forHasValue(Resource subject, SyncProcedure<Boolean> procedure) {
5165 forHasValue(subject, new SyncToAsyncProcedure<Boolean>(procedure));
5169 public void forHasValue(Resource subject, Procedure<Boolean> procedure) {
5170 forHasValue(subject, new NoneToAsyncProcedure<Boolean>(procedure));
5174 public void forOrderedSet(Resource subject,
5175 AsyncMultiListener<Resource> listener) {
5176 asyncRequest(new OrderedSet(subject), listener);
5180 public void forOrderedSet(Resource subject,
5181 SyncMultiListener<Resource> listener) {
5182 asyncRequest(new OrderedSet(subject), listener);
5186 public void forOrderedSet(Resource subject, MultiListener<Resource> listener) {
5187 asyncRequest(new OrderedSet(subject), listener);
5191 final public void forOrderedSet(final Resource subject,
5192 final AsyncMultiProcedure<Resource> procedure) {
5194 assert (subject != null);
5195 assert (procedure != null);
5197 processor.forOrderedSet(this, subject,
5198 new AsyncMultiProcedure<Resource>() {
5201 public void finished(AsyncReadGraph graph) {
5203 procedure.finished(graph);
5204 } catch (Throwable t) {
5205 Logger.defaultLogError(t);
5210 public void execute(AsyncReadGraph graph, Resource result) {
5212 procedure.execute(graph, result);
5213 } catch (Throwable t) {
5214 Logger.defaultLogError(t);
5219 public void exception(AsyncReadGraph graph, Throwable t) {
5221 procedure.exception(graph, t);
5222 } catch (Throwable t2) {
5223 Logger.defaultLogError(t2);
5228 public String toString() {
5229 return "forOrderedSet -> " + procedure;
5237 public void forOrderedSet(Resource subject,
5238 SyncMultiProcedure<Resource> procedure) {
5239 forOrderedSet(subject, new SyncToAsyncMultiProcedure<Resource>(
5244 public void forOrderedSet(Resource subject,
5245 MultiProcedure<Resource> procedure) {
5246 forOrderedSet(subject, new NoneToAsyncMultiProcedure<Resource>(
5251 public <T> void forPossibleAdapted(Resource resource, Class<T> clazz,
5252 AsyncListener<T> listener) {
5253 asyncRequest(new PossibleAdapter<T>(resource, clazz), listener);
5257 public <T> void forPossibleAdapted(Resource resource, Class<T> clazz,
5258 SyncListener<T> listener) {
5259 asyncRequest(new PossibleAdapter<T>(resource, clazz), listener);
5263 public <T> void forPossibleAdapted(Resource resource, Class<T> clazz,
5264 Listener<T> listener) {
5265 asyncRequest(new PossibleAdapter<T>(resource, clazz), listener);
5269 final public <T> void forPossibleAdapted(final Resource resource,
5270 final Class<T> clazz, final AsyncProcedure<T> procedure) {
5272 assert (resource != null);
5273 assert (clazz != null);
5274 assert (procedure != null);
5276 final AdaptionService service = getSession().peekService(AdaptionService.class);
5277 if (service == null)
5278 procedure.exception(this, new ServiceException("No AdaptionService available"));
5280 service.adapt(this, resource, resource, Resource.class, clazz, true, procedure);
5284 public <T> void forPossibleAdapted(Resource resource, Class<T> clazz,
5285 SyncProcedure<T> procedure) {
5286 forPossibleAdapted(resource, clazz, new SyncToAsyncProcedure<T>(
5291 public <T> void forPossibleAdapted(Resource resource, Class<T> clazz,
5292 Procedure<T> procedure) {
5293 forPossibleAdapted(resource, clazz, new NoneToAsyncProcedure<T>(
5298 public <T> void forPossibleUniqueAdapted(Resource resource, Class<T> clazz,
5299 AsyncListener<T> listener) {
5300 asyncRequest(new PossibleUniqueAdapter<T>(resource, clazz), listener);
5304 public <T> void forPossibleUniqueAdapted(Resource resource, Class<T> clazz,
5305 SyncListener<T> listener) {
5306 asyncRequest(new PossibleUniqueAdapter<T>(resource, clazz), listener);
5310 public <T> void forPossibleUniqueAdapted(Resource resource, Class<T> clazz,
5311 Listener<T> listener) {
5312 asyncRequest(new PossibleUniqueAdapter<T>(resource, clazz), listener);
5316 final public <T> void forPossibleUniqueAdapted(final Resource resource,
5317 final Class<T> clazz, final AsyncProcedure<T> procedure) {
5319 assert (resource != null);
5320 assert (clazz != null);
5321 assert (procedure != null);
5323 final AdaptionService service = getSession().peekService(AdaptionService.class);
5324 if (service == null)
5325 procedure.exception(this, new ServiceException("No AdaptionService available"));
5327 service.adaptNew(this, resource, clazz, true, procedure);
5332 public <T> void forPossibleUniqueAdapted(Resource resource, Class<T> clazz,
5333 SyncProcedure<T> procedure) {
5334 forPossibleUniqueAdapted(resource, clazz, new SyncToAsyncProcedure<T>(
5339 public <T> void forPossibleUniqueAdapted(Resource resource, Class<T> clazz,
5340 Procedure<T> procedure) {
5341 forPossibleUniqueAdapted(resource, clazz, new NoneToAsyncProcedure<T>(
5346 * Implementation of the interface AsyncRequestProcessor
5350 final public Session getSession() {
5351 return processor.getSession();
5355 // final public Builtins getBuiltins() {
5356 // return processor.getSession().getBuiltins();
5360 public <T> void asyncRequest(final Read<T> request) {
5362 asyncRequest(request, new AsyncProcedure<T>() {
5365 public void execute(AsyncReadGraph graph, T result) {
5369 public void exception(AsyncReadGraph graph, Throwable t) {
5370 Logger.defaultLogError(t);
5374 public String toString() {
5375 return "asyncRequest(Read) -> " + request;
5383 public <T> void asyncRequest(Read<T> request, AsyncListener<T> procedure) {
5384 asyncRequest(request, (AsyncProcedure<T>) procedure);
5388 public <T> void asyncRequest(Read<T> request,
5389 final SyncListener<T> procedure) {
5390 asyncRequest(request, new SyncToAsyncListener<T>(procedure));
5394 public <T> void asyncRequest(Read<T> request, final Listener<T> procedure) {
5395 asyncRequest(request, new NoneToAsyncListener<T>(procedure));
5399 public <T> void asyncRequest(final Read<T> request, final AsyncProcedure<T> procedure) {
5401 assert (request != null);
5402 assert (procedure != null);
5404 final ListenerBase listener = getListenerBase(procedure);
5406 if (parent != null || listener != null) {
5409 QueryCache.runnerReadEntry(this, request, parent, listener, procedure);
5410 //processor.query(this, request, parent, procedure,listener);
5411 } catch (DatabaseException e) {
5412 Logger.defaultLogError(e);
5413 // This throwable has already been transferred to procedure at this point - do nothing about it
5419 // final ReadGraphImpl newGraph = newSync();
5423 T result = request.perform(this);
5426 procedure.execute(this, result);
5427 } catch (Throwable t) {
5428 Logger.defaultLogError(t);
5431 } catch (Throwable t) {
5434 procedure.exception(this, t);
5435 } catch (Throwable t2) {
5436 Logger.defaultLogError(t2);
5447 public static ReadGraphImpl createAsync(QueryProcessor support) {
5448 return new ReadGraphImpl(null, support);
5451 public static ReadGraphImpl forRecompute(CacheEntry entry, QueryProcessor support) {
5452 return new ReadGraphImpl(entry, support);
5456 public <T> void asyncRequest(Read<T> request, SyncProcedure<T> procedure) {
5457 asyncRequest(request, new SyncToAsyncProcedure<T>(procedure));
5461 public <T> void asyncRequest(Read<T> request, final Procedure<T> procedure) {
5462 asyncRequest(request, new NoneToAsyncProcedure<T>(procedure));
5466 final public <T> void asyncRequest(final AsyncRead<T> request) {
5468 assert (request != null);
5470 asyncRequest(request, new AsyncProcedure<T>() {
5473 public void execute(AsyncReadGraph graph, T result) {
5477 public void exception(AsyncReadGraph graph, Throwable t) {
5478 Logger.defaultLogError(t);
5482 public String toString() {
5483 return "asyncRequest(AsyncRead) -> " + request;
5491 public <T> void asyncRequest(AsyncRead<T> request,
5492 AsyncListener<T> procedure) {
5493 asyncRequest(request, (AsyncProcedure<T>) procedure);
5497 final public <T> void asyncRequest(AsyncRead<T> request,
5498 final SyncListener<T> procedure) {
5499 asyncRequest(request, new SyncToAsyncListener<T>(procedure));
5503 final public <T> void asyncRequest(AsyncRead<T> request,
5504 final Listener<T> procedure) {
5505 asyncRequest(request, new NoneToAsyncListener<T>(procedure));
5509 final public <T> void asyncRequest(final AsyncRead<T> request,
5510 final AsyncProcedure<T> procedure) {
5512 assert (request != null);
5513 assert (procedure != null);
5515 final ListenerBase listener = getListenerBase(procedure);
5517 if (parent != null || listener != null) {
5520 QueryCache.runnerAsyncReadEntry(this, request, parent, listener, procedure);
5521 //processor.query(this, request, parent, procedure, listener);
5522 } catch (DatabaseException e) {
5523 Logger.defaultLogError(e);
5530 request.perform(this, new CallWrappedSingleQueryProcedure4<T>(procedure, request));
5532 } catch (Throwable t) {
5534 if (t instanceof DatabaseException)
5535 procedure.exception(this, t);
5540 new DatabaseException(
5541 "Unexpected exception in ReadGraph.asyncRequest(SingleAsyncRead, SingleProcedure)",
5551 public <T> void asyncRequest(AsyncRead<T> request,
5552 SyncProcedure<T> procedure) {
5553 asyncRequest(request, new SyncToAsyncProcedure<T>(procedure));
5557 final public <T> void asyncRequest(final AsyncRead<T> request,
5558 final Procedure<T> procedure) {
5559 asyncRequest(request, new NoneToAsyncProcedure<T>(procedure));
5563 public <T> void asyncRequest(final MultiRead<T> request) {
5565 assert (request != null);
5567 asyncRequest(request, new AsyncMultiProcedureAdapter<T>() {
5569 public void exception(AsyncReadGraph graph, Throwable t) {
5570 Logger.defaultLogError(t);
5574 public String toString() {
5575 return "asyncRequest(MultiRead) -> " + request;
5582 public <T> void asyncRequest(MultiRead<T> request,
5583 AsyncMultiListener<T> procedure) {
5584 asyncRequest(request, (AsyncMultiProcedure<T>) procedure);
5588 public <T> void asyncRequest(MultiRead<T> request,
5589 SyncMultiListener<T> procedure) {
5590 asyncRequest(request, new SyncToAsyncMultiListener<T>(procedure));
5594 public <T> void asyncRequest(MultiRead<T> request,
5595 MultiListener<T> procedure) {
5596 asyncRequest(request, new NoneToAsyncMultiListener<T>(procedure));
5600 public <T> void asyncRequest(final MultiRead<T> request,
5601 final AsyncMultiProcedure<T> procedure) {
5603 assert (request != null);
5604 assert (procedure != null);
5606 final ListenerBase listener = getListenerBase(procedure);
5608 if (parent != null || listener != null) {
5610 // final ReadGraphImpl newGraph = newSync();
5611 processor.query(this, request, parent, procedure,listener);
5615 // final ReadGraphImpl newGraph = newSync();
5619 request.perform(this, procedure);
5621 } catch (Throwable t) {
5623 procedure.exception(this, t);
5632 public <T> void asyncRequest(MultiRead<T> request,
5633 SyncMultiProcedure<T> procedure) {
5634 asyncRequest(request, new SyncToAsyncMultiProcedure<T>(procedure));
5638 public <T> void asyncRequest(MultiRead<T> request,
5639 MultiProcedure<T> procedure) {
5640 asyncRequest(request, new NoneToAsyncMultiProcedure<T>(procedure));
5644 final public <T> void asyncRequest(final AsyncMultiRead<T> request) {
5646 assert (request != null);
5648 asyncRequest(request, new AsyncMultiProcedureAdapter<T>() {
5650 public void exception(AsyncReadGraph graph, Throwable t) {
5651 Logger.defaultLogError(t);
5655 public String toString() {
5656 return "asyncRequest(AsyncMultiRead) -> " + request;
5663 public <T> void asyncRequest(AsyncMultiRead<T> request,
5664 AsyncMultiListener<T> procedure) {
5665 asyncRequest(request, (AsyncMultiProcedure<T>) procedure);
5669 public <T> void asyncRequest(AsyncMultiRead<T> request,
5670 SyncMultiListener<T> procedure) {
5671 asyncRequest(request, new SyncToAsyncMultiListener<T>(procedure));
5675 public <T> void asyncRequest(AsyncMultiRead<T> request,
5676 MultiListener<T> procedure) {
5677 asyncRequest(request, new NoneToAsyncMultiListener<T>(procedure));
5681 final public <T> void asyncRequest(AsyncMultiRead<T> request,
5682 final AsyncMultiProcedure<T> procedure) {
5684 assert (request != null);
5685 assert (procedure != null);
5687 ListenerBase listener = getListenerBase(procedure);
5689 if (parent != null || listener != null) {
5691 processor.query(this, request, parent, procedure, listener);
5697 request.perform(this, new AsyncMultiProcedure<T>() {
5700 public void execute(AsyncReadGraph graph, T result) {
5701 procedure.execute(graph, result);
5705 public void finished(AsyncReadGraph graph) {
5706 procedure.finished(graph);
5710 public void exception(AsyncReadGraph graph, Throwable t) {
5711 procedure.exception(graph, t);
5715 public String toString() {
5716 return "asyncRequest(AsyncMultiRead) -> " + procedure;
5721 } catch (Throwable t) {
5723 procedure.exception(this, new DatabaseException(t));
5731 public <T> void asyncRequest(AsyncMultiRead<T> request,
5732 SyncMultiProcedure<T> procedure) {
5733 asyncRequest(request, new SyncToAsyncMultiProcedure<T>(procedure));
5737 final public <T> void asyncRequest(AsyncMultiRead<T> request,
5738 final MultiProcedure<T> procedure) {
5739 asyncRequest(request, new NoneToAsyncMultiProcedure<T>(procedure));
5743 final public <T> void asyncRequest(final ExternalRead<T> request) {
5745 assert (request != null);
5747 asyncRequest(request, new Procedure<T>() {
5750 public void execute(T result) {
5754 public void exception(Throwable t) {
5755 Logger.defaultLogError(t);
5759 public String toString() {
5760 return "asyncRequest(PrimitiveRead) -> " + request;
5768 public <T> void asyncRequest(ExternalRead<T> request,
5769 final Listener<T> procedure) {
5770 asyncRequest(request, (Procedure<T>) procedure);
5774 final public <T> void asyncRequest(final ExternalRead<T> request,
5775 final Procedure<T> procedure) {
5778 assert (request != null);
5779 assert (procedure != null);
5781 final ListenerBase listener = getListenerBase(procedure);
5783 if (parent != null || listener != null) {
5786 QueryCacheBase.resultExternalReadEntry(this, request, parent, listener, procedure);
5787 //processor.query(this, request, parent, procedure,listener);
5788 } catch (DatabaseException e) {
5789 Logger.defaultLogError(e);
5790 // This throwable has already been transferred to procedure at this point - do nothing about it
5796 request.register(this, new Listener<T>() {
5799 public void execute(T result) {
5800 procedure.execute(result);
5804 public void exception(Throwable t) {
5805 procedure.exception(t);
5809 public String toString() {
5810 return "asyncRequest(PrimitiveRead) -> " + request;
5814 public boolean isDisposed() {
5820 // final ReadGraphImpl newGraph = newSync();
5824 // T result = request.perform(this);
5827 // procedure.execute(this, result);
5828 // } catch (Throwable t) {
5829 // Logger.defaultLogError(t);
5832 // } catch (Throwable t) {
5835 // procedure.exception(this, t);
5836 // } catch (Throwable t2) {
5837 // Logger.defaultLogError(t2);
5846 // assert (request != null);
5847 // assert (procedure != null);
5849 // ListenerBase listener = getListenerBase(procedure);
5851 // if (parent != null || listener != null) {
5853 // processor.query(this, request, parent, procedure, listener);
5859 // request.register(this, new Listener<T>() {
5862 // public void execute(T result) {
5863 // procedure.execute(result);
5867 // public void exception(Throwable t) {
5868 // procedure.exception(t);
5872 // public String toString() {
5873 // return "asyncRequest(PrimitiveRead) -> " + request;
5877 // public boolean isDisposed() {
5883 // } catch (Throwable t) {
5885 // if (t instanceof DatabaseException)
5886 // procedure.exception(t);
5889 // .exception(new DatabaseException(
5890 // "Unexpected exception in ReadGraph.asyncRequest(SingleAsyncRead, SingleProcedure)",
5900 public void asyncRequest(final Write request) {
5902 assert (request != null);
5904 getSession().asyncRequest(request);
5906 // processor.asyncWrite(request);
5911 public <T> void asyncRequest(final WriteResult<T> request, Procedure<T> procedure) {
5912 throw new Error("Not implemented.");
5916 public void asyncRequest(Write request, Consumer<DatabaseException> callback) {
5918 assert (request != null);
5920 getSession().asyncRequest(request, callback);
5925 public void asyncRequest(final DelayedWrite request) {
5927 assert (request != null);
5929 getSession().asyncRequest(request);
5934 public <T> void asyncRequest(final DelayedWriteResult<T> request, Procedure<T> procedure) {
5935 throw new Error("Not implemented.");
5939 public void asyncRequest(DelayedWrite r,
5940 Consumer<DatabaseException> callback) {
5941 throw new Error("Not implemented.");
5945 public void asyncRequest(final WriteOnly request) {
5947 assert (request != null);
5949 getSession().asyncRequest(request);
5954 public <T> void asyncRequest(final WriteOnlyResult<T> request, Procedure<T> procedure) {
5955 throw new Error("Not implemented.");
5959 public void asyncRequest(WriteOnly r, Consumer<DatabaseException> callback) {
5960 throw new Error("Not implemented.");
5964 * Implementation of the interface ServiceLocator
5968 public <T> T getService(Class<T> api) {
5969 if(WriteSupport.class == api) {
5970 if(this instanceof WriteGraphImpl) {
5971 WriteGraphImpl impl = (WriteGraphImpl)this;
5972 return (T)impl.writeSupport;
5975 return getSession().getService(api);
5979 public <T> T peekService(Class<T> api) {
5980 return getSession().peekService(api);
5984 public boolean hasService(Class<?> api) {
5985 return getSession().hasService(api);
5989 public <T> void registerService(Class<T> api, T service) {
5990 getSession().registerService(api, service);
5994 public boolean isImmutable(Resource resource) throws DatabaseException {
5995 ResourceImpl impl = (ResourceImpl)resource;
5996 return processor.isImmutable(impl.id);
6003 protected static String INTERNAL_ERROR_STRING = "Transaction aborted due to internal client error. Contact application support.";
6006 * callerThread is the currently running thread state.syncThread is blocking for
6007 * this execution state.syncParent is the blocking request
6010 final private boolean isExternal(int thread) {
6011 return thread == Integer.MIN_VALUE;
6014 // final private boolean isSync(int thread) {
6015 // return thread < -1 && thread > Integer.MIN_VALUE;
6018 ReadGraphImpl(ReadGraphImpl graph) {
6019 this(graph.parent, graph.processor);
6022 ReadGraphImpl(CacheEntry parent, QueryProcessor support) {
6023 // this.state = new ReadGraphState(barrier, support);
6024 this.parent = parent;
6025 this.processor = support;
6028 ReadGraphImpl(final QueryProcessor support) {
6030 // this.state = state;
6031 this.processor = support;
6036 // public static ReadGraphImpl createSync(int syncThread, Object syncParent,
6037 // ReadGraphSupportImpl support) {
6038 // return new ReadGraphImpl(syncThread, syncThread, syncParent, null,
6039 // support, new AsyncBarrierImpl(null));
6042 public static ReadGraphImpl create(QueryProcessor support) {
6043 return new ReadGraphImpl(support);
6046 // public ReadGraphImpl newAsync() {
6048 //// if(!state.synchronizedExecution) {
6051 //// return new ReadGraphImpl(false, parent, state.support, state.barrier);
6055 // public ReadGraphImpl newSync() {
6056 // return new ReadGraphImpl(parent, processor);
6059 public ReadGraphImpl newSync(CacheEntry parentEntry) {
6060 return new ReadGraphImpl(parentEntry, processor);
6063 public ReadGraphImpl newRestart(ReadGraphImpl impl) {
6065 WriteGraphImpl write = processor.getSession().getService(
6066 WriteGraphImpl.class);
6068 // if (write.callerThread != impl.callerThread)
6069 // return new WriteGraphImpl(impl.callerThread, parent, state.support, write.writeSupport, write.provider, write.state.barrier);
6074 // public ReadGraphImpl newSync(Object parentRequest) {
6075 // return new ReadGraphImpl(callerThread, state.parent, state.support, new AsyncBarrierImpl(state.barrier));
6078 // public ReadGraphImpl newSync(final int callerThread, Object parentRequest) {
6079 // assert (state.syncThread == callerThread || (state.syncThread == Integer.MIN_VALUE && callerThread != Integer.MIN_VALUE));
6080 // return new ReadGraphImpl(callerThread, callerThread, parentRequest,
6081 // state.parent, state.support, new AsyncBarrierImpl(state.barrier));
6084 // public ReadGraphImpl newSyncAsync(Object parentRequest) {
6085 //// assert (callerThread < 0);
6086 // return new ReadGraphImpl(callerThread, state.syncThread, parentRequest,
6087 // state.parent, state.support, new AsyncBarrierImpl(state.barrier));
6090 // public ReadGraphImpl newSyncAsync(final int callerThread,
6091 // Object parentRequest) {
6092 //// assert (callerThread < 0);
6093 // // assert(state.syncThread == callerThread || (state.syncThread == Integer.MIN_VALUE
6094 // // && callerThread != Integer.MIN_VALUE) );
6095 // return new ReadGraphImpl(callerThread, callerThread, parentRequest,
6096 // state.parent, state.support, new AsyncBarrierImpl(state.barrier));
6099 public ReadGraphImpl withAsyncParent(CacheEntry parent) {
6100 return new ReadGraphImpl(parent, processor);
6103 public ReadGraphImpl withParent(CacheEntry parent) {
6104 if(parent == this.parent) return this;
6105 else return new ReadGraphImpl(parent, processor);
6108 final private ListenerBase getListenerBase(final Object procedure) {
6109 if (procedure instanceof ListenerBase)
6110 return (ListenerBase) procedure;
6115 public <T> void waitAsyncProcedure(AsyncMultiReadProcedure<T> procedure) {
6117 assert(procedure.done());
6119 // while (!procedure.done()) {
6121 // boolean executed = processor.resumeTasks(callerThread, null, null);
6125 // // sema.tryAcquire(1, TimeUnit.MILLISECONDS);
6126 // } catch (InterruptedException e) {
6127 // e.printStackTrace();
6135 public <T> void waitAsyncProcedure(AsyncReadProcedure<T> procedure) {
6137 assert(procedure.done());
6139 // while (!procedure.done()) {
6141 // boolean executed = processor.processor.resume(this);
6145 // // sema.tryAcquire(1, TimeUnit.MILLISECONDS);
6146 // } catch (InterruptedException e) {
6147 // e.printStackTrace();
6155 // public void waitAsync(Object request) {
6157 // state.barrier.waitBarrier(request, this);
6158 // } catch (Throwable t) {
6159 // t.printStackTrace();
6160 // processor.scanPending();
6161 // processor.querySupport.checkTasks();
6162 // throw new RuntimeDatabaseException(t);
6166 // public void restart() {
6167 // state.barrier.restart();
6170 public boolean resumeTasks() {
6171 return processor.resumeTasks(this);
6174 Class<?> singleClass(Set<Resource> types) {
6175 Class<?> result = null;
6176 for (Resource type : types) {
6177 Class<?> clazz = processor.getBuiltinValue(type);
6178 if (clazz != null) {
6188 private String debugString(Resource r) {
6191 name = getPossibleRelatedValue(r, processor.getL0(this).HasName);
6192 } catch (ManyObjectsForFunctionalRelationException e) {
6193 Logger.defaultLogError(e);
6194 } catch (ServiceException e) {
6195 Logger.defaultLogError(e);
6197 return "[" + name + " - " + r + "]";
6201 public String toString() {
6202 return "ReadGraphImpl[thread=" + Thread.currentThread() + "]";
6206 final public int thread() {
6210 static class MultiTripleIntProcedure implements TripleIntProcedure {
6212 final private AsyncMultiProcedure<Statement> procedure;
6213 final private ReadGraphImpl impl;
6214 final private QuerySupport support;
6216 public MultiTripleIntProcedure(AsyncMultiProcedure<Statement> procedure, ReadGraphImpl impl, QuerySupport support) {
6217 this.procedure = procedure;
6219 this.support = support;
6223 public void execute(ReadGraphImpl graph, int s, int p, int o) {
6225 procedure.execute(graph, support.getStatement(s, p, o));
6226 } catch (Throwable t2) {
6227 Logger.defaultLogError(t2);
6232 public void finished(ReadGraphImpl graph) {
6234 procedure.finished(graph);
6235 // impl.state.barrier.dec("ReadGraphSupportImpl.516");
6236 } catch (Throwable t2) {
6237 Logger.defaultLogError(t2);
6242 public void exception(ReadGraphImpl graph, Throwable t) {
6244 procedure.exception(graph, t);
6245 } catch (Throwable t2) {
6246 Logger.defaultLogError(t2);
6248 // impl.state.barrier.dec("ReadGraphSupportImpl.516");
6252 public String toString() {
6253 return "forEachObject with " + procedure;
6258 // private AsyncMultiProcedure<Resource> cacheKey = null;
6259 // private MultiIntProcedure cacheResult = null;
6261 // final IntProcedure forMultiProcedure(final AsyncMultiProcedure<Resource> procedure) {
6263 // if(procedure == cacheKey) return cacheResult;
6265 // cacheResult = new MultiIntProcedure(procedure, this, processor.support);
6266 // cacheKey = procedure;
6268 // return cacheResult;
6272 // private AsyncMultiProcedure<Statement> cacheKey2 = null;
6273 // private MultiTripleIntProcedure cacheResult2 = null;
6275 // final synchronized TripleIntProcedure forMultiProcedure(final AsyncMultiProcedure<Statement> procedure) {
6277 // if(procedure == cacheKey2) return cacheResult2;
6279 // cacheResult2 = new MultiTripleIntProcedure(procedure, this, processor.support);
6280 // cacheKey2 = procedure;
6282 // return cacheResult2;
6287 public Datatype getDataType(Resource subject) throws DatabaseException {
6288 for(Resource dataTypeResource : getObjects(subject, processor.getL0(this).HasDataType))
6289 return getValue(dataTypeResource, Bindings.getBindingUnchecked(Datatype.class));
6290 throw new DoesNotContainValueException("The literal has no data type.");
6293 protected <T extends Accessor> T getAccessor4File(Resource subject)
6294 throws DatabaseException {
6297 byte[] bytes = processor.support.getValue(g, subject);
6301 BinaryVariant va = (BinaryVariant) Accessors.getAccessor(bytes, Datatypes.VARIANT);
6302 Accessor ca = va.getContentAccessor();
6304 } catch (AccessorConstructionException e) {
6305 throw new DatabaseException(e);
6311 Binding datatype_binding = Bindings.getBindingUnchecked(DataType.class);
6312 Serializer datatype_serializer = datatype_binding.serializer();
6315 BinaryMemory in = new BinaryMemory(ByteBuffer.wrap(bytes));
6316 datatype = (DataType)datatype_serializer.deserialize(in);
6317 Binding data_binding = Bindings.getBinding(datatype);
6318 Serializer data_serializer = data_binding.serializer(BinarySerializationFormat.INSTANCE);
6319 Object o = data_serializer.deserialize(in);
6321 return (T)Accessors.getAccessor(data_binding, o);
6322 } catch(AccessorConstructionException e) {
6325 } catch (Exception e) {
6326 throw new DatabaseException(e);
6329 @SuppressWarnings("unchecked")
6331 public <T extends Accessor> T getAccessor(Resource subject) throws DatabaseException {
6332 RandomAccessBinary rab = getRandomAccessBinary(subject);
6334 return (T)Accessors.getAccessor(rab, getDataType(subject));
6335 } catch(AccessorConstructionException e) {
6336 throw new DatabaseException(e);
6339 @SuppressWarnings("unchecked")
6340 protected <T extends Accessor> T createAccessor(Resource resource, Datatype datatype, Object intialValue)
6341 throws DatabaseException {
6342 RandomAccessBinary rab = createRandomAccessBinary(resource, datatype, intialValue);
6344 return (T)Accessors.getAccessor(rab, datatype);
6345 } catch(AccessorConstructionException e) {
6346 throw new DatabaseException(e);
6350 public RandomAccessBinary getRandomAccessBinary(Resource subject) throws DatabaseException {
6351 RandomAccessValueSupport ravs = getSession().getService(RandomAccessValueSupport.class);
6352 ResourceData rd = ravs.get(subject);
6356 ExternalValueSupport evs = getService(ExternalValueSupport.class);
6357 long size = evs.getValueSize(this, subject); // Throws DatabaseException if no old external value.
6359 File platform = Platform.getLocation().toFile();
6360 File tempFiles = new File(platform, "tempFiles");
6361 File dbDir = new File(tempFiles, "db");
6363 File file = new File(dbDir, "ResourceFile" + subject.getResourceId());
6364 rd = new ResourceData(new BinaryFile(file), true); // Old external value.
6365 final int N = 1<<20;
6369 int length = N < left ? N : (int)left;
6370 byte[] bytes = evs.readValue(this, subject, offset, length);
6371 offset += bytes.length;
6372 left -= bytes.length;
6373 rd.binaryFile.write(bytes);
6375 ravs.put(subject, rd);
6377 } catch (Exception e) {
6378 throw new DatabaseException("Resource " + subject + " have value but there was problem with accessing value data.", e);
6380 } catch (Exception e) {
6381 if(Development.DEVELOPMENT) {
6382 if(Development.<Boolean>getProperty(DevelopmentKeys.WRITEGRAPH_EXCEPTION_STACKTRACES, Bindings.BOOLEAN)) {
6383 e.printStackTrace();
6387 Datatype datatype = getDataType(subject);
6388 Object value = getPossibleValue(subject, Bindings.getBinding(datatype));
6389 return createRandomAccessBinary(subject, datatype, value);
6391 public RandomAccessBinary createRandomAccessBinary(Resource resource, Datatype datatype, Object initialValue)
6392 throws DatabaseException {
6393 RandomAccessValueSupport ravs = getSession().getService(RandomAccessValueSupport.class);
6395 File platform = Platform.getLocation().toFile();
6396 File tempFiles = new File(platform, "tempFiles");
6397 File dbDir = new File(tempFiles, "db");
6399 File file = new File(dbDir, "ResourceFile" + resource.getResourceId());
6400 ResourceData rd = new ResourceData(new BinaryFile(file), false);
6401 Binding binding = Bindings.getBinding(datatype);
6402 if (null == initialValue) {
6403 initialValue = binding.createDefault();
6405 Serializer serializer = binding.serializer();
6406 byte[] bytes = serializer.serialize(initialValue);
6407 rd.binaryFile.write(bytes);
6408 ravs.put(resource, rd);
6410 } catch (Exception e) {
6411 if (e instanceof DatabaseException)
6412 throw (DatabaseException)e;
6414 throw new DatabaseException(e);
6418 // static class ExternalValueRequest<T> extends ResourceRead<T> {
6420 // public ExternalValueRequest(Resource resource) {
6424 // @SuppressWarnings("unchecked")
6426 // public T perform(ReadGraph graph) throws DatabaseException {
6429 // String uri = graph.getURI(resource);
6430 // if(Layer0.URIs.Functions_functionApplication.equals(uri)) return (T)functionApplication;
6432 // return (T)ReflectionUtils.getValue(uri).getValue();
6434 // } catch(ValueNotFoundException e) {
6435 // throw new DatabaseException("Couldn't convert to external value (r=" + resource + ")", e);
6436 // } catch(ClassCastException e) {
6437 // throw new DatabaseException("Couldn't convert to external value (r=" + resource + ")", e);
6443 @SuppressWarnings("unchecked")
6445 public <T> T getValue2(Resource r, Object context) throws DatabaseException {
6446 Layer0 L0 = processor.getL0(this);
6447 Set<Resource> types = getTypes(r);
6449 if(types.contains(L0.Literal)) {
6450 if(isImmutable(r)) {
6451 return syncRequest(new ValueImplied<T>(r));
6456 else if(types.contains(L0.Function)) {
6457 return Functions.exec(this, r, this, r, context);
6459 else if(types.contains(L0.ExternalValue)) {
6460 return (T)syncRequest(new AdaptValue(r), TransientCacheListener.<Object>instance());
6464 Function3<ReadGraph,Resource,Object,T> function = requestValueFunction(r);
6465 if(function == null) throw new DoesNotContainValueException("Couldn't convert to a value function " + r);
6467 return function.apply(this, r, context);
6468 } catch(RuntimeException e) {
6469 DatabaseException dte = findPossibleRootException(e);
6470 if(dte != null) throw dte;
6471 else throw new DatabaseException(e);
6478 public Variant getVariantValue2(Resource r, Object context) throws DatabaseException {
6479 Layer0 L0 = processor.getL0(this);
6480 Set<Resource> types = getTypes(r);
6482 if(types.contains(L0.Literal)) {
6483 if(isImmutable(r)) {
6484 return syncRequest(new VariantValueImplied(r));
6486 return getVariantValue(r);
6489 else if(types.contains(L0.Function)) {
6490 Object value = Functions.exec(this, r, this, r, context);
6492 return new Variant(Bindings.OBJECT.getContentBinding(value), value);
6493 } catch ( org.simantics.databoard.binding.error.BindingException e ) {
6494 throw new BindingException( "No binding found for class " + value.getClass().getName(), e );
6497 else if(types.contains(L0.ExternalValue)) {
6498 Object value = syncRequest(new AdaptValue(r), TransientCacheListener.<Object>instance());
6500 return new Variant(Bindings.OBJECT.getContentBinding(value), value);
6501 } catch ( org.simantics.databoard.binding.error.BindingException e ) {
6502 throw new BindingException( "No binding found for class " + value.getClass().getName(), e );
6507 Function3<ReadGraph,Resource,Object,Object> function = requestValueFunction(r);
6508 if(function == null) throw new DoesNotContainValueException("Couldn't convert to a value function " + r);
6510 Object value = function.apply(this, r, context);
6512 return new Variant(Bindings.OBJECT.getContentBinding(value), value);
6513 } catch ( org.simantics.databoard.binding.error.BindingException e ) {
6514 throw new BindingException( "No binding found for class " + value.getClass().getName(), e );
6516 } catch(RuntimeException e) {
6517 DatabaseException dte = findPossibleRootException(e);
6518 if(dte != null) throw dte;
6519 else throw new DatabaseException(e);
6525 public <T> T getPossibleValue2(Resource subject, Object context) throws DatabaseException {
6527 return getValue2(subject, context);
6528 } catch (DatabaseException e) {
6533 static class PossibleConverterFunction<T> extends ResourceRead<Function3<ReadGraph,Resource,Object,T>> {
6535 public PossibleConverterFunction(Resource resource) {
6540 public Function3<ReadGraph,Resource,Object,T> perform(ReadGraph graph) throws DatabaseException {
6541 return compute(graph, resource);
6544 @SuppressWarnings("unchecked")
6545 public static <T> Function3<ReadGraph,Resource,Object,T> compute(ReadGraph graph, Resource resource) throws DatabaseException {
6546 Layer0 L0 = Layer0.getInstance(graph);
6547 for(Resource converter : graph.getObjects(resource, L0.ConvertsToValueWith)) {
6549 if(L0.Functions_functionApplication.equals(converter)) {
6550 return AdaptValue.functionApplication;
6551 //return (Function3<ReadGraph,Resource,Object,T>)graph.syncRequest(new AdaptValue(resource));
6553 return graph.getValue2(converter, resource);
6555 } catch(RuntimeException e) {
6556 DatabaseException dte = findPossibleRootException(e);
6557 if(dte != null) throw dte;
6558 else throw new DatabaseException(e);
6566 <T> Function3<ReadGraph,Resource,Object,T> requestValueFunction(Resource r) throws DatabaseException {
6568 return syncRequest(new PossibleConverterFunction<T>(r), TransientCacheAsyncListener.<Function3<ReadGraph,Resource,Object,T>>instance());
6570 return syncRequest(new PossibleConverterFunction<T>(r));
6574 * Get a value associated with a graph {@link Resource}, using a possible context object and
6575 * a desired value binding. The following methods are tried in order to retreive the value:
6577 * <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>
6578 * <li>If the resource is a {@code L0.ExternalValue}, the value is acquired using
6579 * {@link ReflectionUtils#getValue(String)}.</li>
6580 * <li>If the resource is associated with a suitable value converter with relation {@code L0.ConvertsToValueWith}
6581 * (see {@link #requestValueFunction(Resource)}), the value function is called with the graph, the resource
6582 * and the context object.</li>
6585 * @param r A graph resource with which the value is associated
6586 * @param context A context object that is used for acquiring the value (only applied in case 3)
6587 * @param binding A binding for the value type (only applied in case 1)
6588 * @return The value of the graph node.
6589 * @throws DoesNotContainValueException No value is associated with the graph node.
6590 * @throws DatabaseException Other errors, such as an error in casting the value to the return type or
6591 * a runtime error in the value function.
6593 @SuppressWarnings("unchecked")
6595 public <T> T getValue2(Resource r, Object context, Binding binding) throws DatabaseException {
6596 if (binding instanceof ObjectVariantBinding)
6597 return getValue2(r, context);
6599 Layer0 L0 = processor.getL0(this);
6600 Set<Resource> types = getTypes(r);
6601 if(types.contains(L0.Literal)) {
6602 if(isImmutable(r)) {
6603 return syncRequest(new Value<T>(r, binding));
6605 return getValue(r, binding);
6607 } else if(types.contains(L0.Function)) {
6608 Object value = Functions.exec(this, r, this, r, context);
6609 if(binding.isInstance(value)) return (T)value;
6611 Binding srcBinding = Bindings.OBJECT.getContentBinding(value);
6612 return (T)Bindings.adapt(value, srcBinding, binding);
6613 } catch(RuntimeException e) {
6614 DatabaseException dte = findPossibleRootException(e);
6615 if(dte != null) throw dte;
6616 else throw new DatabaseException(e);
6617 } catch (AdaptException e) {
6618 throw new DatabaseException(e);
6619 } catch (org.simantics.databoard.binding.error.BindingException e) {
6620 throw new DatabaseException(e);
6622 } else if(types.contains(L0.ExternalValue)) {
6624 ExternalValue ev = adapt(r, ExternalValue.class);
6625 return ev.getValue(this, r);
6626 //return (T)ReflectionUtils.getValue(getURI(r)).getValue();
6627 // } catch(ValueNotFoundException e) {
6628 // throw new DatabaseException(e);
6629 } catch(ClassCastException e) {
6630 throw new DatabaseException(e);
6634 Function3<ReadGraph,Resource,Object,T> function = requestValueFunction(r);
6635 if(function == null) throw new DoesNotContainValueException("Couldn't convert to a value function.");
6637 Object value = function.apply(this, r, context);
6638 if(binding.isInstance(value)) return (T)value;
6639 Binding srcBinding = Bindings.OBJECT.getContentBinding(value);
6640 return (T)Bindings.adapt(value, srcBinding, binding);
6641 } catch(RuntimeException e) {
6642 DatabaseException dte = findPossibleRootException(e);
6643 if(dte != null) throw dte;
6644 else throw new DatabaseException(e);
6645 } catch (AdaptException e) {
6646 throw new DatabaseException(e);
6647 } catch (org.simantics.databoard.binding.error.BindingException e) {
6648 throw new DatabaseException(e);
6654 public <T> T getPossibleValue2(Resource subject, Object context, Binding binding) throws DatabaseException {
6656 return getValue2(subject, context, binding);
6657 } catch (DatabaseException e) {
6662 private static DatabaseException findPossibleRootException(Throwable t) {
6663 if(t == null) return null;
6664 if(t instanceof DatabaseException) return (DatabaseException)t;
6665 if(t instanceof RuntimeException || t instanceof InvocationTargetException) {
6666 return findPossibleRootException(t.getCause());
6672 public <T> T getRelatedValue2(Resource subject, Resource relation) throws DatabaseException {
6673 return getRelatedValue2(subject, relation, subject);
6677 public Variant getRelatedVariantValue2(Resource subject, Resource relation) throws DatabaseException {
6678 return getRelatedVariantValue2(subject, relation, subject);
6682 public <T> T getPossibleRelatedValue2(Resource subject, Resource relation) throws DatabaseException {
6684 Resource object = getPossibleObject(subject, relation);
6685 if(object == null) return null;
6686 else return getValue2(object, subject);
6687 } catch (DatabaseException e) {
6693 public <T> T getRelatedValue2(Resource subject, Resource relation, Object context) throws DatabaseException {
6694 if(Development.DEVELOPMENT) {
6695 String error = L0Validations.checkValueType(this, subject, relation);
6697 Logger.defaultLogError(new ValidationException(error));
6698 //throw new ValidationException(error);
6699 new ValidationException(error).printStackTrace();
6702 return getValue2(getSingleObject(subject, relation), context);
6706 public Variant getRelatedVariantValue2(Resource subject, Resource relation, Object context) throws DatabaseException {
6707 if(Development.DEVELOPMENT) {
6708 String error = L0Validations.checkValueType(this, subject, relation);
6710 Logger.defaultLogError(new ValidationException(error));
6711 //throw new ValidationException(error);
6712 new ValidationException(error).printStackTrace();
6715 return getVariantValue2(getSingleObject(subject, relation), context);
6719 public <T> T getPossibleRelatedValue2(Resource subject, Resource relation, Object context) throws DatabaseException {
6721 Resource object = getPossibleObject(subject, relation);
6722 if(object == null) return null;
6723 else return getValue2(object, context);
6724 } catch (DatabaseException e) {
6730 public <T> T getRelatedValue2(Resource subject, Resource relation, Binding binding) throws DatabaseException {
6731 return getRelatedValue2(subject, relation, subject, binding);
6735 public <T> T getPossibleRelatedValue2(Resource subject, Resource relation, Binding binding) throws DatabaseException {
6737 Resource object = getPossibleObject(subject, relation);
6738 if(object == null) return null;
6739 return getValue2(object, subject, binding);
6740 } catch (DatabaseException e) {
6746 public <T> T getRelatedValue2(Resource subject, Resource relation, Object context, Binding binding) throws DatabaseException {
6747 return getValue2(getSingleObject(subject, relation), context, binding);
6751 public <T> T getPossibleRelatedValue2(Resource subject, Resource relation, Object context, Binding binding) throws DatabaseException {
6753 Resource object = getPossibleObject(subject, relation);
6754 if(object == null) return null;
6755 else return getValue2(object, context, binding);
6756 } catch (DatabaseException e) {
6762 public Type getRelatedValueType(Resource subject, Resource relation) throws DatabaseException {
6763 Layer0 L0 = processor.getL0(this);
6764 Resource property = getSingleObject(subject, relation);
6765 String typeText = (String)getRelatedValue(property, L0.HasValueType, Bindings.STRING);
6767 return org.simantics.scl.compiler.types.Types.parseType(typeText);
6768 } catch (SCLTypeParseException e) {
6769 throw new DatabaseException(e);
6773 private static ThreadLocal<Boolean> syncGraph = new ThreadLocal<Boolean>() {
6774 protected Boolean initialValue() {
6780 public boolean setSynchronous(boolean value) {
6781 boolean old = getSynchronous();
6782 syncGraph.set(value);
6787 public boolean getSynchronous() {
6788 return syncGraph.get();
6791 public void ensureLoaded(int resource) {
6792 processor.querySupport.ensureLoaded(this, resource);
6795 public void ensureLoaded(int resource, int predicate) {
6796 processor.querySupport.ensureLoaded(this, resource, predicate);
6799 public byte[] getValue(int resource) {
6800 return processor.querySupport.getValue(this, resource);
6803 public int thread(int resource) {
6804 return (resource >>> 16) & processor.THREAD_MASK;
6807 public int thread(Resource resource) {
6808 return (((ResourceImpl)resource).id >>> 16) & processor.THREAD_MASK;
6811 public ResourceSupport getResourceSupport() {
6812 return processor.getResourceSupport();
6816 public Object getModificationCounter() {
6817 return processor.getSession().getModificationCounter();