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.ExternalValueSupport;
49 import org.simantics.db.ReadGraph;
50 import org.simantics.db.RelationContext;
51 import org.simantics.db.Resource;
52 import org.simantics.db.Session;
53 import org.simantics.db.Statement;
54 import org.simantics.db.adaption.AdaptionService;
55 import org.simantics.db.common.primitiverequest.Adapter;
56 import org.simantics.db.common.primitiverequest.Builtin;
57 import org.simantics.db.common.primitiverequest.DatatypeBinding;
58 import org.simantics.db.common.primitiverequest.ForEachAssertedObject;
59 import org.simantics.db.common.primitiverequest.ForEachAssertedStatement;
60 import org.simantics.db.common.primitiverequest.HasStatement;
61 import org.simantics.db.common.primitiverequest.HasStatementSubject;
62 import org.simantics.db.common.primitiverequest.HasStatementSubjectObject;
63 import org.simantics.db.common.primitiverequest.HasValue;
64 import org.simantics.db.common.primitiverequest.Inverse;
65 import org.simantics.db.common.primitiverequest.IsInheritedFrom;
66 import org.simantics.db.common.primitiverequest.IsInstanceOf;
67 import org.simantics.db.common.primitiverequest.IsSubrelationOf;
68 import org.simantics.db.common.primitiverequest.OrderedSet;
69 import org.simantics.db.common.primitiverequest.PossibleAdapter;
70 import org.simantics.db.common.primitiverequest.PossibleInverse;
71 import org.simantics.db.common.primitiverequest.PossibleObject;
72 import org.simantics.db.common.primitiverequest.PossibleRelatedValue;
73 import org.simantics.db.common.primitiverequest.PossibleRelatedValueImplied;
74 import org.simantics.db.common.primitiverequest.PossibleStatement;
75 import org.simantics.db.common.primitiverequest.PossibleType;
76 import org.simantics.db.common.primitiverequest.PossibleUniqueAdapter;
77 import org.simantics.db.common.primitiverequest.PossibleValue;
78 import org.simantics.db.common.primitiverequest.PossibleValueImplied;
79 import org.simantics.db.common.primitiverequest.RelatedValue;
80 import org.simantics.db.common.primitiverequest.RelatedValueImplied;
81 import org.simantics.db.common.primitiverequest.SingleObject;
82 import org.simantics.db.common.primitiverequest.SingleStatement;
83 import org.simantics.db.common.primitiverequest.SingleType;
84 import org.simantics.db.common.primitiverequest.SingleTypeAny;
85 import org.simantics.db.common.primitiverequest.Types;
86 import org.simantics.db.common.primitiverequest.UniqueAdapter;
87 import org.simantics.db.common.primitiverequest.Value;
88 import org.simantics.db.common.primitiverequest.ValueImplied;
89 import org.simantics.db.common.primitiverequest.VariantValueImplied;
90 import org.simantics.db.common.procedure.adapter.AsyncMultiProcedureAdapter;
91 import org.simantics.db.common.procedure.adapter.ProcedureAdapter;
92 import org.simantics.db.common.procedure.adapter.TransientCacheAsyncListener;
93 import org.simantics.db.common.procedure.adapter.TransientCacheListener;
94 import org.simantics.db.common.procedure.single.SyncReadProcedure;
95 import org.simantics.db.common.procedure.single.wrapper.DeepSingleOrErrorProcedure;
96 import org.simantics.db.common.procedure.single.wrapper.DeepSingleOrNullProcedure;
97 import org.simantics.db.common.procedure.single.wrapper.ExceptionToNullProcedure;
98 import org.simantics.db.common.procedure.single.wrapper.NullSingleOrNullProcedure;
99 import org.simantics.db.common.procedure.single.wrapper.SingleFunctionalOrNullProcedure;
100 import org.simantics.db.common.procedure.single.wrapper.SingleOrErrorProcedure;
101 import org.simantics.db.common.procedure.single.wrapper.SingleOrNullProcedure;
102 import org.simantics.db.common.procedure.wrapper.NoneToAsyncListener;
103 import org.simantics.db.common.procedure.wrapper.NoneToAsyncMultiListener;
104 import org.simantics.db.common.procedure.wrapper.NoneToAsyncMultiProcedure;
105 import org.simantics.db.common.procedure.wrapper.NoneToAsyncProcedure;
106 import org.simantics.db.common.procedure.wrapper.NoneToAsyncSetProcedure;
107 import org.simantics.db.common.procedure.wrapper.SyncToAsyncListener;
108 import org.simantics.db.common.procedure.wrapper.SyncToAsyncMultiListener;
109 import org.simantics.db.common.procedure.wrapper.SyncToAsyncMultiProcedure;
110 import org.simantics.db.common.procedure.wrapper.SyncToAsyncProcedure;
111 import org.simantics.db.common.procedure.wrapper.SyncToAsyncSetProcedure;
112 import org.simantics.db.common.request.AdaptValue;
113 import org.simantics.db.common.request.ResourceRead;
114 import org.simantics.db.common.utils.Logger;
115 import org.simantics.db.common.utils.NameUtils;
116 import org.simantics.db.common.validation.L0Validations;
117 import org.simantics.db.exception.AdaptionException;
118 import org.simantics.db.exception.ArgumentException;
119 import org.simantics.db.exception.AssumptionException;
120 import org.simantics.db.exception.BindingException;
121 import org.simantics.db.exception.DatabaseException;
122 import org.simantics.db.exception.DoesNotContainValueException;
123 import org.simantics.db.exception.EmptyResourceException;
124 import org.simantics.db.exception.InternalException;
125 import org.simantics.db.exception.InvalidLiteralException;
126 import org.simantics.db.exception.ManyObjectsForFunctionalRelationException;
127 import org.simantics.db.exception.NoInverseException;
128 import org.simantics.db.exception.NoSingleResultException;
129 import org.simantics.db.exception.ResourceNotFoundException;
130 import org.simantics.db.exception.ServiceException;
131 import org.simantics.db.exception.ValidationException;
132 import org.simantics.db.impl.RelationContextImpl;
133 import org.simantics.db.impl.ResourceImpl;
134 import org.simantics.db.impl.internal.RandomAccessValueSupport;
135 import org.simantics.db.impl.internal.ResourceData;
136 import org.simantics.db.impl.procedure.CallWrappedSingleQueryProcedure4;
137 import org.simantics.db.impl.procedure.ResultCallWrappedQueryProcedure4;
138 import org.simantics.db.impl.procedure.ResultCallWrappedSingleQueryProcedure4;
139 import org.simantics.db.impl.query.CacheEntry;
140 import org.simantics.db.impl.query.QueryCache;
141 import org.simantics.db.impl.query.QueryProcessor;
142 import org.simantics.db.impl.query.QuerySupport;
143 import org.simantics.db.impl.query.TripleIntProcedure;
144 import org.simantics.db.impl.support.ResourceSupport;
145 import org.simantics.db.procedure.AsyncListener;
146 import org.simantics.db.procedure.AsyncMultiListener;
147 import org.simantics.db.procedure.AsyncMultiProcedure;
148 import org.simantics.db.procedure.AsyncProcedure;
149 import org.simantics.db.procedure.AsyncSetListener;
150 import org.simantics.db.procedure.Listener;
151 import org.simantics.db.procedure.ListenerBase;
152 import org.simantics.db.procedure.MultiListener;
153 import org.simantics.db.procedure.MultiProcedure;
154 import org.simantics.db.procedure.Procedure;
155 import org.simantics.db.procedure.SetListener;
156 import org.simantics.db.procedure.StatementProcedure;
157 import org.simantics.db.procedure.SyncListener;
158 import org.simantics.db.procedure.SyncMultiListener;
159 import org.simantics.db.procedure.SyncMultiProcedure;
160 import org.simantics.db.procedure.SyncProcedure;
161 import org.simantics.db.procedure.SyncSetListener;
162 import org.simantics.db.request.AsyncMultiRead;
163 import org.simantics.db.request.AsyncRead;
164 import org.simantics.db.request.DelayedWrite;
165 import org.simantics.db.request.DelayedWriteResult;
166 import org.simantics.db.request.ExternalRead;
167 import org.simantics.db.request.MultiRead;
168 import org.simantics.db.request.Read;
169 import org.simantics.db.request.ReadInterface;
170 import org.simantics.db.request.RequestFlags;
171 import org.simantics.db.request.Write;
172 import org.simantics.db.request.WriteInterface;
173 import org.simantics.db.request.WriteOnly;
174 import org.simantics.db.request.WriteOnlyResult;
175 import org.simantics.db.request.WriteResult;
176 import org.simantics.layer0.Layer0;
177 import org.simantics.scl.compiler.types.Type;
178 import org.simantics.scl.compiler.types.exceptions.SCLTypeParseException;
179 import org.simantics.scl.reflection.ReflectionUtils;
180 import org.simantics.scl.reflection.ValueNotFoundException;
181 import org.simantics.scl.runtime.function.Function3;
182 import org.simantics.utils.DataContainer;
183 import org.simantics.utils.Development;
184 import org.simantics.utils.datastructures.Pair;
185 import org.simantics.utils.datastructures.collections.CollectionUtils;
187 import gnu.trove.map.hash.TObjectIntHashMap;
189 public class ReadGraphImpl implements ReadGraph {
191 final static boolean EMPTY_RESOURCE_CHECK = false;
193 final public CacheEntry parent;
194 final public QueryProcessor processor;
196 final static Binding DATA_TYPE_BINDING_INTERNAL = Bindings.getBindingUnchecked(Datatype.class);
197 final static Serializer DATA_TYPE_SERIALIZER = Bindings.getSerializerUnchecked(DATA_TYPE_BINDING_INTERNAL);
199 final public static TObjectIntHashMap<String> counters = new TObjectIntHashMap<String>();
201 public static void resetCounters() {
205 public static String listCounters(File file) throws IOException {
207 PrintStream b = new PrintStream(new BufferedOutputStream(new FileOutputStream(file)));
209 for(Pair<String,Integer> p : CollectionUtils.valueSortedEntries(counters)) {
210 b.print(-p.second + " " + p.first + "\n");
215 return "Dumped " + counters.size() + " queries.";
220 * Implementation of the interface ReadGraph
222 final public String getURI(final Resource resource) throws AssumptionException, ValidationException, ServiceException {
224 assert (resource != null);
228 return syncRequest(new org.simantics.db.common.uri.ResourceToURI(resource));
230 } catch (AssumptionException e) {
232 throw new AssumptionException(e);
234 } catch (ValidationException e) {
236 throw new ValidationException(e);
238 } catch (ServiceException e) {
240 throw new ServiceException(e);
242 } catch (DatabaseException e) {
244 throw new ServiceException(INTERNAL_ERROR_STRING, e);
250 final public String getPossibleURI(final Resource resource) throws ValidationException, ServiceException {
252 assert (resource != null);
256 return syncRequest(new org.simantics.db.common.uri.ResourceToPossibleURI(resource));
258 } catch (ValidationException e) {
260 throw new ValidationException(e);
262 } catch (ServiceException e) {
264 throw new ServiceException(e);
266 } catch (DatabaseException e) {
268 throw new ServiceException(INTERNAL_ERROR_STRING, e);
274 final public Resource getResource(final String id)
275 throws ResourceNotFoundException, ValidationException,
282 return syncRequest(new org.simantics.db.common.primitiverequest.Resource(
285 } catch (ResourceNotFoundException e) {
287 throw new ResourceNotFoundException(id, e);
289 } catch (ValidationException e) {
291 throw new ValidationException(e);
293 } catch (ServiceException e) {
295 throw new ServiceException(e);
297 } catch (DatabaseException e) {
299 throw new ServiceException(INTERNAL_ERROR_STRING, e);
305 final public Resource getPossibleResource(final String id)
306 throws ResourceNotFoundException, ValidationException,
313 return syncRequest(new org.simantics.db.common.primitiverequest.Resource(
316 } catch (ResourceNotFoundException e) {
320 } catch (ValidationException e) {
322 throw new ValidationException(e);
324 } catch (ServiceException e) {
326 throw new ServiceException(e);
328 } catch (DatabaseException e) {
330 throw new ServiceException(INTERNAL_ERROR_STRING, e);
336 final public Resource getRootLibrary() {
337 return processor.getRootLibraryResource();
340 final public Resource getBuiltin(final String id)
341 throws ResourceNotFoundException, ServiceException {
347 return syncRequest(new Builtin(id));
349 } catch (ResourceNotFoundException e) {
351 throw new ResourceNotFoundException(id, e);
353 } catch (ServiceException e) {
355 throw new ServiceException(e);
357 } catch (DatabaseException e) {
359 throw new ServiceException(INTERNAL_ERROR_STRING, e);
365 static class StatementReadProcedure extends TIntArrayListInternal implements StatementProcedure {
367 private static Throwable DONE = new Throwable();
369 Throwable exception = null;
371 final ResourceSupport support;
373 public StatementReadProcedure(ResourceSupport support) {
374 this.support = support;
378 public synchronized void execute(AsyncReadGraph graph, int s, int p, int o) {
385 public void finished(AsyncReadGraph graph) {
390 public void exception(AsyncReadGraph graph, Throwable t) {
394 public void checkAndThrow() throws DatabaseException {
395 if(exception != DONE) {
396 if (exception instanceof DatabaseException)
397 throw (DatabaseException) exception;
399 throw new DatabaseException(
400 "Unexpected exception in ReadGraph.syncRequest(AsyncMultiRead)",
405 public boolean done() {
406 return exception != null;
410 public boolean contains(Object obj) {
411 if(!(obj instanceof InternalStatement))
413 InternalStatement statement = (InternalStatement)obj;
417 for(int i=0;i<sizeInternal();i+=3)
418 if(s==getQuick(i) && p==getQuick(i+1) && o==getQuick(i+2))
423 @SuppressWarnings("unchecked")
425 public <T> T[] toArray(T[] a) {
426 int length = sizeInternal() / 3;
427 if(length > a.length) {
428 Class<?> arrayType = a.getClass();
429 a = (arrayType == Object[].class)
430 ? (T[]) new Object[length]
431 : (T[]) Array.newInstance(arrayType.getComponentType(), length);
434 for(int i=length;i<a.length;++i)
437 for(int i=0,j=0;i<sizeInternal();i+=3,++j)
438 a[j] = (T)new InternalStatement(support, getQuick(i), getQuick(i+1), getQuick(i+2));
443 public boolean add(Statement e) {
444 throw new UnsupportedOperationException();
448 public boolean remove(Object o) {
449 throw new UnsupportedOperationException();
453 public boolean addAll(Collection<? extends Statement> c) {
454 throw new UnsupportedOperationException();
457 class IteratorImpl implements ListIterator<Statement> {
461 public IteratorImpl(int index) {
466 public boolean hasNext() {
467 return index < sizeInternal();
471 public Statement next() {
472 Statement result = new InternalStatement(support, getQuick(index), getQuick(index+1), getQuick(index+2));
478 public void remove() {
479 throw new Error("Not supported");
483 public boolean hasPrevious() {
488 public Statement previous() {
490 Statement result = new InternalStatement(support, getQuick(index), getQuick(index+1), getQuick(index+2));
495 public int nextIndex() {
500 public int previousIndex() {
505 public void set(Statement e) {
506 throw new UnsupportedOperationException();
510 public void add(Statement e) {
511 throw new UnsupportedOperationException();
517 public Iterator<Statement> iterator() {
518 return new IteratorImpl(0);
523 return sizeInternal() / 3;
527 public Object[] toArray() {
528 Object[] result = new Object[sizeInternal() / 3];
529 for(int i=0,j=0;j<sizeInternal();i++,j+=3)
530 result[i] = new InternalStatement(support, getQuick(j), getQuick(j+1), getQuick(j+2));
535 public boolean addAll(int index, Collection<? extends Statement> c) {
536 throw new UnsupportedOperationException();
540 public Statement get(int index) {
542 if(index < 0 || index >= sizeInternal())
543 throw new IndexOutOfBoundsException();
544 return new InternalStatement(support, getQuick(index), getQuick(index+1), getQuick(index+2));
548 public Statement set(int index, Statement element) {
549 throw new UnsupportedOperationException();
553 public void add(int index, Statement element) {
554 throw new UnsupportedOperationException();
558 public Statement remove(int index) {
559 throw new UnsupportedOperationException();
563 public int indexOf(Object obj) {
564 if(!(obj instanceof InternalStatement))
566 InternalStatement statement = (InternalStatement)obj;
570 for(int i=0;i<sizeInternal();i+=3)
571 if(s==getQuick(i) && p==getQuick(i+1) && o==getQuick(i+2))
577 public int lastIndexOf(Object obj) {
578 if(!(obj instanceof InternalStatement))
580 InternalStatement statement = (InternalStatement)obj;
584 for(int i=sizeInternal()-3;i>=0;i-=3)
585 if(s==getQuick(i) && p==getQuick(i+1) && o==getQuick(i+2))
591 public ListIterator<Statement> listIterator() {
592 return new IteratorImpl(0);
596 public ListIterator<Statement> listIterator(int index) {
597 return new IteratorImpl(index*3);
601 public List<Statement> subList(int fromIndex, int toIndex) {
602 if(fromIndex < 0 || toIndex*3 >= sizeInternal() || fromIndex > toIndex)
603 throw new IndexOutOfBoundsException();
604 return new RandomAccessSubList<Statement>(this, fromIndex, toIndex-fromIndex);
609 final public Collection<Statement> getStatements(final Resource subject,
610 final Resource relation)
611 throws ManyObjectsForFunctionalRelationException, ServiceException {
613 assert (subject != null);
614 assert (relation != null);
618 StatementReadProcedure procedure = new StatementReadProcedure(getResourceSupport());
619 processor.forEachStatement(this, subject, relation, procedure);
620 procedure.checkAndThrow();
623 } catch (DatabaseException e) {
625 System.err.println(INTERNAL_ERROR_STRING + " getStatements " + subject + " " + relation);
627 StatementReadProcedure procedure = new StatementReadProcedure(getResourceSupport());
628 processor.forEachStatement(this, subject, relation, procedure);
630 return Collections.emptyList();
632 // throw new ServiceException(INTERNAL_ERROR_STRING + " getStatements " + subject + " " + relation, e);
639 final public Collection<Statement> getAssertedStatements(final Resource subject, final Resource relation)
640 throws ManyObjectsForFunctionalRelationException, ServiceException {
642 assert (subject != null);
643 assert (relation != null);
647 return syncRequest(new ForEachAssertedStatement(subject, relation));
649 } catch (ManyObjectsForFunctionalRelationException e) {
651 throw new ManyObjectsForFunctionalRelationException(e);
653 } catch (ServiceException e) {
655 throw new ServiceException(e);
657 } catch (DatabaseException e) {
659 throw new ServiceException(INTERNAL_ERROR_STRING, e);
666 final public Collection<Resource> getPredicates(final Resource subject) throws ServiceException {
668 assert (subject != null);
672 return processor.getPredicates(this, subject);
674 // AsyncMultiReadProcedure<Resource> procedure = new AsyncMultiReadProcedure<Resource>();
675 // processor.forEachPredicate(this, subject, procedure);
676 // procedure.checkAndThrow();
679 } catch (ServiceException e) {
681 throw new ServiceException(e);
683 } catch (DatabaseException e) {
685 throw new ServiceException(INTERNAL_ERROR_STRING, e);
687 } catch (Throwable e) {
689 throw new ServiceException(e);
696 final public Collection<Resource> getPrincipalTypes(final Resource subject)
697 throws ServiceException {
699 assert (subject != null);
703 AsyncMultiReadProcedure<Resource> procedure = new AsyncMultiReadProcedure<Resource>();
704 processor.forEachPrincipalType(this, subject, procedure);
705 procedure.checkAndThrow();
708 } catch (ServiceException e) {
710 throw new ServiceException(e);
712 } catch (DatabaseException e) {
714 throw new ServiceException(INTERNAL_ERROR_STRING, e);
721 final public Set<Resource> getTypes(final Resource subject) throws ServiceException {
723 assert (subject != null);
727 return processor.getTypes(this, subject);
729 } catch (ServiceException e) {
731 throw new ServiceException(e);
733 } catch (DatabaseException e) {
735 throw new ServiceException(INTERNAL_ERROR_STRING, e);
737 } catch (Throwable e) {
739 throw new ServiceException(e);
746 final public Set<Resource> getSupertypes(final Resource subject)
747 throws ServiceException {
749 assert (subject != null);
753 SyncReadProcedure<Set<Resource>> procedure = new SyncReadProcedure<Set<Resource>>();
754 processor.forSupertypes(this, subject, procedure);
755 procedure.checkAndThrow();
756 return procedure.result;
758 } catch (ServiceException e) {
760 throw new ServiceException(e);
762 } catch (DatabaseException e) {
764 throw new ServiceException(INTERNAL_ERROR_STRING, e);
771 final public Set<Resource> getSuperrelations(final Resource subject)
772 throws ServiceException {
774 assert (subject != null);
778 SyncReadProcedure<Set<Resource>> procedure = new SyncReadProcedure<Set<Resource>>();
779 processor.forSuperrelations(this, subject, procedure);
780 procedure.checkAndThrow();
781 return procedure.result;
783 } catch (ServiceException e) {
785 throw new ServiceException(e);
787 } catch (DatabaseException e) {
789 throw new ServiceException(INTERNAL_ERROR_STRING, e);
796 public Resource getPossibleSuperrelation(Resource subject) throws ServiceException {
800 SyncReadProcedure<Resource> procedure = new SyncReadProcedure<Resource>();
801 processor.forPossibleSuperrelation(this, subject, procedure);
802 procedure.checkAndThrow();
803 return procedure.result;
805 } catch (ServiceException e) {
807 throw new ServiceException(e);
809 } catch (DatabaseException e) {
811 throw new ServiceException(INTERNAL_ERROR_STRING, e);
818 final public Collection<Resource> getObjects(final Resource subject, final Resource relation)
819 throws ServiceException {
821 assert (subject != null);
822 assert (relation != null);
824 if(Development.DEVELOPMENT) {
825 if(Development.isTrue(DevelopmentKeys.READGRAPH_COUNT)) {
826 counters.adjustOrPutValue("objects $" + subject.getResourceId() + " $" + relation.getResourceId(), 1, 1);
828 //if(subject.getResourceId()==xx && relation.getResourceId()==xx) new Exception().printStackTrace();
833 AsyncMultiReadProcedure<Resource> procedure = new AsyncMultiReadProcedure<Resource>();
834 processor.forEachObject(this, subject, relation, procedure);
835 procedure.checkAndThrow();
838 } catch (DatabaseException e) {
840 throw new ServiceException(INTERNAL_ERROR_STRING, e);
847 final public Collection<Resource> getAssertedObjects(
848 final Resource subject, final Resource relation)
849 throws ManyObjectsForFunctionalRelationException, ServiceException {
852 throw new ArgumentException("Subject must not be null.");
853 if (relation == null)
854 throw new ArgumentException("Relation must not be null. Subject=" + subject);
858 return syncRequest(new ForEachAssertedObject(subject, relation));
860 } catch (ManyObjectsForFunctionalRelationException e) {
862 throw new ManyObjectsForFunctionalRelationException(e);
864 } catch (ServiceException e) {
866 throw new ServiceException(e);
868 } catch (DatabaseException e) {
870 throw new ServiceException(INTERNAL_ERROR_STRING, e);
877 final public Resource getInverse(final Resource relation) throws NoInverseException, ServiceException {
879 assert (relation != null);
883 return getSingleObject(relation, processor.querySupport.getResource(processor.getInverseOf()));
885 } catch (NoSingleResultException e) {
887 throw new NoInverseException(e);
889 } catch (ServiceException e) {
891 throw new ServiceException(e);
898 final public Resource getSingleObject(final Resource subject, final Resource relation) throws NoSingleResultException, ServiceException {
900 if( subject == null) throw new IllegalArgumentException("subject can not be null");
901 if( relation == null) throw new IllegalArgumentException("relation can not be null");
904 int single = processor.getSingleObject(this, subject, relation);
906 if (EMPTY_RESOURCE_CHECK) {
907 if (!hasStatement(subject)) {
908 throw new EmptyResourceException("Resource " + debugString(subject));
911 throw new NoSingleResultException("No single object for subject " + debugString(subject)
912 + " and relation " + debugString(relation), single);
914 return processor.querySupport.getResource(single);
915 } catch (NoSingleResultException e) {
917 } catch (DatabaseException e) {
918 throw new ServiceException(e);
923 final public Statement getSingleStatement(final Resource subject, final Resource relation) throws NoSingleResultException, ManyObjectsForFunctionalRelationException, ServiceException {
924 assert (subject != null);
925 assert (relation != null);
927 Collection<Statement> statements = getStatements(subject, relation);
928 if (statements.size() == 1) {
929 return statements.iterator().next();
931 if (EMPTY_RESOURCE_CHECK)
932 if (!hasStatement(subject))
933 throw new EmptyResourceException("Resource " + debugString(subject));
934 throw new NoSingleResultException("No single statement for subject " + debugString(subject)
935 + " and relation " + debugString(relation), statements.size());
937 } catch (ServiceException e) {
938 throw new ServiceException(e);
943 final public Resource getSingleType(final Resource subject) throws NoSingleResultException, ServiceException {
944 assert (subject != null);
946 ArrayList<Resource> principalTypes = (ArrayList<Resource>)getPrincipalTypes(subject);
947 if (principalTypes.size() == 1) {
948 return principalTypes.get(0);
950 throw new NoSingleResultException("No single type for subject " + debugString(subject), principalTypes.size());
952 } catch (ServiceException e) {
953 throw new ServiceException(e);
958 final public Resource getSingleType(final Resource subject,
959 final Resource baseType) throws NoSingleResultException,
962 assert (subject != null);
963 assert (baseType != null);
966 return syncRequest(new SingleType(subject, baseType));
967 } catch (DatabaseException e) {
968 throw new NoSingleResultException("subject=" + subject + ", baseType=" + baseType, 0, e);
973 final public <T> T getValue(final Resource subject) throws DoesNotContainValueException, ServiceException {
975 assert (subject != null);
979 Layer0 L0 = processor.getL0(this);
980 int object = processor.getSingleObject(this, subject, L0.HasDataType);
981 if(object == 0) throw new DoesNotContainValueException("No data type for " + subject);
983 if(processor.isImmutable(object)) {
984 Binding binding = syncRequest(new DatatypeBinding(processor.querySupport.getResource(object)), TransientCacheListener.<Binding>instance());
985 return getValue(subject, binding);
987 byte[] dt = processor.getValue(this, object);
988 if(dt == null) throw new ServiceException("No data type for " + subject);
989 Datatype datatype = (Datatype)DATA_TYPE_SERIALIZER.deserialize(dt);
990 Binding binding = Bindings.getBinding(datatype);
991 return getValue(subject, binding);
994 } catch (IOException e) {
996 throw new ServiceException(e);
998 } catch (DoesNotContainValueException e) {
1000 throw new DoesNotContainValueException(e, subject);
1002 } catch (ServiceException e) {
1004 throw new ServiceException(e);
1006 } catch (DatabaseException e) {
1008 throw new ServiceException(INTERNAL_ERROR_STRING, e);
1015 final public Variant getVariantValue(final Resource subject) throws DoesNotContainValueException, ServiceException {
1017 assert (subject != null);
1021 Layer0 L0 = processor.getL0(this);
1022 int object = processor.getSingleObject(this, subject, L0.HasDataType);
1023 if(object == 0) throw new DoesNotContainValueException("No data type for " + subject);
1025 if(processor.isImmutable(object)) {
1026 Binding binding = syncRequest(new DatatypeBinding(processor.querySupport.getResource(object)), TransientCacheListener.<Binding>instance());
1027 return new Variant(binding, getValue(subject, binding));
1029 byte[] dt = processor.getValue(this, object);
1030 if(dt == null) throw new ServiceException("No data type for " + subject);
1031 Datatype datatype = (Datatype)DATA_TYPE_SERIALIZER.deserialize(dt);
1032 Binding binding = Bindings.getBinding(datatype);
1033 return new Variant(binding, getValue(subject, binding));
1036 } catch (IOException e) {
1038 throw new ServiceException(e);
1040 } catch (DoesNotContainValueException e) {
1042 throw new DoesNotContainValueException(e, subject);
1044 } catch (ServiceException e) {
1046 throw new ServiceException(e);
1048 } catch (DatabaseException e) {
1050 throw new ServiceException(INTERNAL_ERROR_STRING, e);
1055 static final IdentityHashMap<Binding,Serializer> serializers = new IdentityHashMap<Binding,Serializer>();
1058 serializers.put(Bindings.STRING, Bindings.STRING.serializer());
1061 final protected Serializer getSerializer(Binding binding) {
1062 return binding.serializer();
1066 final public <T> T getValue(final Resource subject, final Binding binding) throws DoesNotContainValueException, BindingException,
1069 assert (subject != null);
1073 byte[] bytes = processor.getValue(this, subject);
1074 if (bytes == null) throw new DoesNotContainValueException("No value for resource " + subject);
1076 Serializer serializer = getSerializer(binding);
1077 return (T)serializer.deserialize(bytes);
1079 } catch (DoesNotContainValueException e) {
1081 throw new DoesNotContainValueException(e);
1083 } catch (IOException e) {
1085 throw new ServiceException(e);
1087 } catch (DatabaseException e) {
1089 throw new ServiceException(e);
1091 } catch (BufferUnderflowException e) {
1092 // This is sometimes thrown when deserialize fails because wrong format.
1093 // For callers of this method this is just an service exception.
1094 throw new ServiceException(e);
1100 final public <T> T getRelatedValue(final Resource subject, final Resource relation) throws NoSingleResultException,
1101 DoesNotContainValueException, ServiceException {
1103 assert (subject != null);
1104 assert (relation != null);
1107 Resource object = getSingleObject(subject, relation);
1108 return getValue(object);
1109 } catch (NoSingleResultException e) {
1110 throw new NoSingleResultException("No single value found for subject " + debugString(subject) + " and relation " + debugString(relation), e.getResultCount(), e);
1111 } catch (DoesNotContainValueException e) {
1113 Layer0 L0 = processor.getL0(this);
1114 Resource object = getPossibleObject(subject, relation);
1115 if(isInstanceOf(object, L0.Value)) {
1116 if(isInstanceOf(object, L0.Literal)) {
1117 throw new DoesNotContainValueException(e);
1119 throw new InvalidLiteralException("The object " + object + " is not an instance of L0.Literal (use getRelatedValue2 instead)", e);
1122 throw new DoesNotContainValueException("The object " + object + " is not an instance of L0.Value", e);
1124 } catch (DoesNotContainValueException e2) {
1126 } catch (DatabaseException e2) {
1127 throw new InternalException("The client failed to analyse the cause of the following exception", e);
1129 } catch (ServiceException e) {
1130 throw new ServiceException(e);
1135 final public Variant getRelatedVariantValue(final Resource subject, final Resource relation) throws NoSingleResultException,
1136 DoesNotContainValueException, ServiceException {
1138 assert (subject != null);
1139 assert (relation != null);
1142 Resource object = getSingleObject(subject, relation);
1143 return getVariantValue(object);
1144 } catch (NoSingleResultException e) {
1145 throw new NoSingleResultException("No single object for subject " + debugString(subject) + " and relation " + debugString(relation), e.getResultCount(), e);
1146 } catch (DoesNotContainValueException e) {
1148 Layer0 L0 = processor.getL0(this);
1149 Resource object = getPossibleObject(subject, relation);
1150 if(isInstanceOf(object, L0.Value)) {
1151 if(isInstanceOf(object, L0.Literal)) {
1152 throw new DoesNotContainValueException(e);
1154 throw new InvalidLiteralException("The object " + object + " is not an instance of L0.Literal (use getRelatedValue2 instead)", e);
1157 throw new DoesNotContainValueException("The object " + object + " is not an instance of L0.Value", e);
1159 } catch (DoesNotContainValueException e2) {
1161 } catch (DatabaseException e2) {
1162 throw new InternalException("The client failed to analyse the cause of the following exception", e);
1164 } catch (ServiceException e) {
1165 throw new ServiceException(e);
1170 final public <T> T getRelatedValue(final Resource subject, final Resource relation, final Binding binding)
1171 throws NoSingleResultException, DoesNotContainValueException, BindingException, ServiceException {
1173 assert (subject != null);
1174 assert (relation != null);
1177 Resource object = getSingleObject(subject, relation);
1178 return getValue(object, binding);
1179 } catch (NoSingleResultException e) {
1180 String message = "";
1182 String subjectName = NameUtils.getSafeName(this, subject, true);
1183 String relationName = NameUtils.getSafeName(this, relation, true);
1184 message = "Subject: " + subjectName + ", Relation: " + relationName;
1185 } catch (DatabaseException e2) {
1188 throw new NoSingleResultException(message, e.getResultCount(), e);
1189 } catch (DoesNotContainValueException e) {
1190 throw new DoesNotContainValueException(e);
1191 } catch (ServiceException e) {
1192 throw new ServiceException(e);
1197 final public <T> T adapt(final Resource resource, final Class<T> clazz)
1198 throws AdaptionException, ValidationException, ServiceException {
1200 assert (resource != null);
1201 assert (clazz != null);
1205 return syncRequest(new Adapter<T>(resource, clazz));
1207 } catch (AdaptionException e) {
1209 throw new AdaptionException(e);
1211 } catch (ValidationException e) {
1213 throw new ValidationException(e);
1215 } catch (ServiceException e) {
1217 throw new ServiceException(e);
1219 } catch (DatabaseException e) {
1221 throw new ServiceException(INTERNAL_ERROR_STRING, e);
1228 final public <T,C> T adaptContextual(final Resource resource, final C context, final Class<C> contextClass, final Class<T> clazz)
1229 throws AdaptionException, ValidationException, ServiceException {
1231 assert (resource != null);
1232 assert (context != null);
1234 class ContextualAdapter implements AsyncRead<T> {
1236 final private Resource resource;
1237 final private C context;
1238 final private Class<T> clazz;
1241 public int hashCode() {
1242 return resource.hashCode() + 31 * (clazz.hashCode() + 41 * context.hashCode());
1246 final public int threadHash() {
1247 return resource.getThreadHash();
1251 public boolean equals(Object object) {
1254 else if (object == null)
1256 else if (getClass() != object.getClass())
1258 ContextualAdapter r = (ContextualAdapter)object;
1259 return resource.equals(r.resource) && context.equals(r.context) && clazz.equals(r.clazz);
1263 public int getFlags() {
1267 public ContextualAdapter(Resource resource, C context, Class<T> clazz) {
1268 this.resource = resource;
1269 this.context = context;
1274 public void perform(AsyncReadGraph graph, AsyncProcedure<T> procedure) {
1276 final AdaptionService service = getSession().peekService(AdaptionService.class);
1277 if (service == null)
1278 procedure.exception(graph, new ServiceException("No AdaptionService available"));
1280 service.adapt(graph, resource, context, contextClass, clazz, false, procedure);
1285 public String toString() {
1286 return "Adapter for (" + resource + "," + context + ") as " + clazz.getName();
1293 return syncRequest(new ContextualAdapter(resource, context, clazz));
1295 } catch (AdaptionException e) {
1297 throw new AdaptionException(e);
1299 } catch (ValidationException e) {
1301 throw new ValidationException(e);
1303 } catch (ServiceException e) {
1305 throw new ServiceException(e);
1307 } catch (DatabaseException e) {
1309 throw new ServiceException(INTERNAL_ERROR_STRING, e);
1316 final public <T> T adaptRelated(final Resource resource, final Resource relation, final Class<T> clazz)
1317 throws AdaptionException, NoSingleResultException, ValidationException, ServiceException {
1319 assert (resource != null);
1320 assert (clazz != null);
1322 Statement stm = getSingleStatement(resource, relation);
1324 return adaptContextual(stm.getObject(), new RelationContextImpl(resource, stm), RelationContext.class, clazz);
1329 final public <T> T getPossibleRelatedAdapter(final Resource resource, final Resource relation, final Class<T> clazz)
1330 throws ValidationException, ServiceException {
1333 return adaptRelated(resource, relation, clazz);
1334 } catch (DatabaseException e) {
1341 final public <T,C> T getPossibleContextualAdapter(final Resource resource, final C context, final Class<C> contextClass, final Class<T> clazz)
1342 throws ValidationException, ServiceException {
1344 assert (resource != null);
1345 assert (context != null);
1347 class PossibleContextualAdapter implements AsyncRead<T> {
1349 final private Resource resource;
1350 final private C context;
1351 final private Class<T> clazz;
1354 public int hashCode() {
1355 return resource.hashCode() + 31 * (clazz.hashCode() + 41 * context.hashCode());
1359 final public int threadHash() {
1360 return resource.getThreadHash();
1364 public boolean equals(Object object) {
1367 else if (object == null)
1369 else if (getClass() != object.getClass())
1371 PossibleContextualAdapter r = (PossibleContextualAdapter)object;
1372 return resource.equals(r.resource) && context.equals(r.context) && clazz.equals(r.clazz);
1376 public int getFlags() {
1380 public PossibleContextualAdapter(Resource resource, C context, Class<T> clazz) {
1381 this.resource = resource;
1382 this.context = context;
1387 public void perform(AsyncReadGraph graph, AsyncProcedure<T> procedure) {
1389 final AdaptionService service = getSession().peekService(AdaptionService.class);
1390 if (service == null)
1391 procedure.exception(graph, new ServiceException("No AdaptionService available"));
1393 service.adapt(graph, resource, context, contextClass, clazz, true, procedure);
1398 public String toString() {
1399 return "Possible adapter for (" + resource + "," + context + ") as " + clazz.getName();
1406 return syncRequest(new PossibleContextualAdapter(resource, context, clazz));
1408 } catch (ValidationException e) {
1410 throw new ValidationException(e);
1412 } catch (ServiceException e) {
1414 throw new ServiceException(e);
1416 } catch (DatabaseException e) {
1418 throw new ServiceException(INTERNAL_ERROR_STRING, e);
1425 final public <T> T adaptUnique(final Resource resource, final Class<T> clazz)
1426 throws AdaptionException, ValidationException, ServiceException {
1428 assert (resource != null);
1429 assert (clazz != null);
1433 return syncRequest(new UniqueAdapter<T>(resource, clazz));
1435 } catch (AdaptionException e) {
1437 throw new AdaptionException(e);
1439 } catch (ValidationException e) {
1441 throw new ValidationException(e);
1443 } catch (ServiceException e) {
1445 throw new ServiceException(e);
1447 } catch (DatabaseException e) {
1449 throw new ServiceException(INTERNAL_ERROR_STRING, e);
1456 final public Resource getPossibleInverse(final Resource relation)
1457 throws ServiceException {
1459 assert (relation != null);
1463 return getPossibleObject(relation, processor.querySupport.getResource(processor.getInverseOf()));
1465 } catch (ServiceException e) {
1467 throw new ServiceException(e);
1469 } catch (DatabaseException e) {
1471 throw new ServiceException(INTERNAL_ERROR_STRING, e);
1478 public Resource getPossibleObject(final Resource subject, final Resource relation)
1479 throws ManyObjectsForFunctionalRelationException, ServiceException {
1481 assert (subject != null);
1482 assert (relation != null);
1486 int result = processor.getSingleObject(this, subject, relation);
1487 if(result == 0) return null;
1489 return processor.querySupport.getResource(result);
1491 } catch (ManyObjectsForFunctionalRelationException e) {
1493 throw new ManyObjectsForFunctionalRelationException("subject=" + subject + ", relation=" + relation, e);
1495 } catch (DatabaseException e) {
1497 throw new ServiceException(e);
1504 final public Statement getPossibleStatement(final Resource subject, final Resource relation)
1505 throws ManyObjectsForFunctionalRelationException, ServiceException {
1507 assert (subject != null);
1508 assert (relation != null);
1512 Collection<Statement> statements = getStatements(subject, relation);
1513 if(statements.size() == 1) return statements.iterator().next();
1516 } catch (ManyObjectsForFunctionalRelationException e) {
1518 throw new ManyObjectsForFunctionalRelationException("Many objects in " + subject + " for functional relation " + relation);
1520 } catch (ServiceException e) {
1522 throw new ServiceException(e);
1529 final public Resource getPossibleType(final Resource subject, final Resource baseType) throws ServiceException {
1531 assert (subject != null);
1532 assert (baseType != null);
1536 AsyncReadProcedure<Resource> procedure = new AsyncReadProcedure<Resource>();
1537 forPossibleType(subject, baseType, procedure);
1538 procedure.checkAndThrow();
1539 return procedure.result;
1541 } catch (ServiceException e) {
1543 throw new ServiceException(e);
1545 } catch (DatabaseException e) {
1547 throw new ServiceException(INTERNAL_ERROR_STRING, e);
1554 final public <T> T getPossibleValue(final Resource subject) throws ServiceException {
1556 assert (subject != null);
1560 int object = processor.getSingleObject(this, subject, processor.getL0(this).HasDataType);
1561 if(object == 0) return null;
1563 if(processor.isImmutable(object)) {
1564 Binding binding = syncRequest(new DatatypeBinding(processor.querySupport.getResource(object)), TransientCacheListener.<Binding>instance());
1565 return getPossibleValue(subject, binding);
1567 byte[] dt = processor.getValue(this, object);
1568 if(dt == null) return null;
1569 Datatype datatype = (Datatype)DATA_TYPE_SERIALIZER.deserialize(dt);
1570 Binding binding = Bindings.getBinding(datatype);
1571 return getPossibleValue(subject, binding);
1574 } catch (IOException e) {
1576 throw new ServiceException(e);
1578 } catch (ServiceException e) {
1580 throw new ServiceException(e);
1582 } catch (DatabaseException e) {
1584 throw new ServiceException(INTERNAL_ERROR_STRING, e);
1591 final public <T> T getPossibleValue(final Resource subject, final Binding binding) throws BindingException, ServiceException {
1593 assert (subject != null);
1594 assert (binding != null);
1598 byte[] dt = processor.getValue(this, subject);
1599 if(dt == null) return null;
1600 Serializer serializer = getSerializer(binding);
1601 return (T)serializer.deserialize(dt);
1603 } catch (IOException e) {
1605 throw new ServiceException(e);
1607 } catch (BindingException e) {
1609 throw new BindingException(e);
1611 } catch (ServiceException e) {
1613 throw new ServiceException(e);
1615 } catch (DatabaseException e) {
1616 e.printStackTrace();
1617 throw new ServiceException(INTERNAL_ERROR_STRING, e);
1623 public <T> T getPossibleRelatedValue(final Resource subject, final Resource relation)
1624 throws ManyObjectsForFunctionalRelationException, ServiceException {
1626 assert (subject != null);
1627 assert (relation != null);
1631 Resource object = getPossibleObject(subject, relation);
1632 if(object == null) return null;
1633 else return getPossibleValue(object);
1635 } catch (ManyObjectsForFunctionalRelationException e) {
1637 throw new ManyObjectsForFunctionalRelationException(e);
1639 } catch (ServiceException e) {
1641 throw new ServiceException(e);
1648 public <T> T getPossibleRelatedValue(final Resource subject, final Resource relation, final Binding binding)
1649 throws ManyObjectsForFunctionalRelationException, BindingException, ServiceException {
1651 assert (subject != null);
1652 assert (relation != null);
1653 assert (binding != null);
1657 Resource object = getPossibleObject(subject, relation);
1658 if(object == null) return null;
1659 else return getPossibleValue(object, binding);
1661 } catch (ManyObjectsForFunctionalRelationException e) {
1663 throw new ManyObjectsForFunctionalRelationException(e);
1665 } catch (BindingException e) {
1667 throw new BindingException(e);
1669 } catch (ServiceException e) {
1671 throw new ServiceException(e);
1678 public <T> T getPossibleAdapter(Resource resource, Class<T> clazz) throws ValidationException, ServiceException {
1680 assert (resource != null);
1681 assert (clazz != null);
1685 return syncRequest(new PossibleAdapter<T>(resource, clazz));
1687 } catch (ValidationException e) {
1689 throw new ValidationException(e);
1691 } catch (AdaptionException e) {
1695 } catch (DatabaseException e) {
1697 throw new ServiceException(INTERNAL_ERROR_STRING, e);
1703 public <T> T getPossibleUniqueAdapter(Resource resource, Class<T> clazz) throws ValidationException, ServiceException {
1705 assert (resource != null);
1706 assert (clazz != null);
1710 return syncRequest(new PossibleUniqueAdapter<T>(resource, clazz));
1712 } catch (AdaptionException e) {
1716 } catch (ValidationException e) {
1718 throw new ValidationException(e);
1720 } catch (DatabaseException e) {
1722 throw new ServiceException(INTERNAL_ERROR_STRING, e);
1729 final public boolean isInstanceOf(final Resource resource, final Resource type) throws ServiceException {
1731 assert (resource != null);
1732 assert (type != null);
1734 Set<Resource> resources = getTypes(resource);
1735 // This check was necessary because some of the callers of this method got stuck when the NPE was thrown from here.
1736 if (null == resources)
1739 if(EMPTY_RESOURCE_CHECK) {
1740 if (resources.isEmpty()) {
1741 if(!hasStatement(resource)) throw new EmptyResourceException("Resource " + debugString(resource));
1745 return resources.contains(type);
1750 final public boolean isInheritedFrom(final Resource resource, final Resource type) throws ServiceException {
1752 assert (resource != null);
1753 assert (type != null);
1757 if(resource.equals(type)) return true;
1759 return getSupertypes(resource).contains(type);
1761 } catch (ServiceException e) {
1763 throw new ServiceException(e);
1770 final public boolean isSubrelationOf(final Resource resource, final Resource type) throws ServiceException {
1772 assert (resource != null);
1773 assert (type != null);
1777 if(resource.equals(type)) return true;
1779 return getSuperrelations(resource).contains(type);
1781 } catch (ServiceException e) {
1783 throw new ServiceException(e);
1790 final public boolean hasStatement(final Resource subject) throws ServiceException {
1792 assert (subject != null);
1796 SyncReadProcedure<Boolean> procedure = new SyncReadProcedure<Boolean>();
1797 processor.forHasStatement(this, subject, procedure);
1798 procedure.checkAndThrow();
1799 return procedure.result;
1801 } catch (ServiceException e) {
1803 throw new ServiceException(e);
1805 } catch (DatabaseException e) {
1807 throw new ServiceException(INTERNAL_ERROR_STRING, e);
1814 final public boolean hasStatement(final Resource subject, final Resource relation) throws ServiceException {
1816 assert (subject != null);
1817 assert (relation != null);
1821 Collection<Resource> objects = getObjects(subject, relation);
1822 return !objects.isEmpty();
1824 } catch (ServiceException e) {
1826 throw new ServiceException(e);
1833 final public boolean hasStatement(final Resource subject, final Resource relation, final Resource object) throws ServiceException {
1835 assert (subject != null);
1836 assert (relation != null);
1837 assert (object != null);
1841 for(Resource o : getObjects(subject, relation)) {
1842 if(object.equals(o)) return true;
1847 } catch (ServiceException e) {
1849 throw new ServiceException(e);
1856 final public boolean hasValue(final Resource subject) throws ServiceException {
1858 assert (subject != null);
1862 SyncReadProcedure<Boolean> procedure = new SyncReadProcedure<Boolean>();
1863 processor.forHasValue(this, subject, procedure);
1864 procedure.checkAndThrow();
1865 return procedure.result;
1867 } catch (ServiceException e) {
1869 throw new ServiceException(e);
1871 } catch (DatabaseException e) {
1873 throw new ServiceException(INTERNAL_ERROR_STRING, e);
1879 final AsyncProcedure<?> NONE = new AsyncProcedure<Object>() {
1882 public void execute(AsyncReadGraph graph, Object result) {
1886 public void exception(AsyncReadGraph graph, Throwable throwable) {
1892 * Implementation of the interface RequestProcessor
1896 public <T> T syncRequest(final Read<T> request) throws DatabaseException {
1898 assert (request != null);
1900 return QueryCache.resultReadEntry(this, request, parent, null, null);
1902 //return processor.query(this, request, parent, null, null);
1904 // if (parent != null) {
1907 // } catch (Throwable e) {
1908 // if(e instanceof DatabaseException) throw (DatabaseException)e;
1909 // else throw new DatabaseException(e);
1916 // return processor.tryQuery(this, request);
1918 // } catch (Throwable throwable) {
1920 // //Logger.defaultLogError("Internal read request failure", throwable);
1922 // if (throwable instanceof DatabaseException)
1923 // throw (DatabaseException) throwable;
1925 // throw new DatabaseException(
1926 // "Unexpected exception in ReadGraph.syncRequest(Read,Procedure)",
1936 public <T> T syncRequest(Read<T> request, SyncListener<T> procedure)
1937 throws DatabaseException {
1938 return syncRequest(request, new SyncToAsyncListener<T>(procedure));
1942 public <T> T syncRequest(Read<T> request, final Listener<T> procedure)
1943 throws DatabaseException {
1944 return syncRequest(request, new NoneToAsyncListener<T>(procedure));
1948 public <T> T syncRequest(final Read<T> request, final AsyncProcedure<T> procedure) throws DatabaseException {
1950 assert (request != null);
1952 ListenerBase listener = procedure != null ? getListenerBase(procedure) : null;
1954 return QueryCache.resultReadEntry(this, request, parent, listener, procedure);
1956 // return processor.query(this, request, parent, procedure, listener);
1959 // if (parent != null || listener != null) {
1962 // } catch (Throwable e) {
1963 // if(e instanceof DatabaseException) throw (DatabaseException)e;
1964 // else throw new DatabaseException(e);
1971 // T t = processor.tryQuery(this, request);
1972 // if(procedure != null)
1973 // procedure.execute(this, t);
1977 // } catch (Throwable throwable) {
1979 // Logger.defaultLogError("Internal read request failure", throwable);
1981 // if(procedure != null)
1982 // procedure.exception(this, throwable);
1984 // if (throwable instanceof DatabaseException)
1985 // throw (DatabaseException) throwable;
1987 // throw new DatabaseException(
1988 // "Unexpected exception in ReadGraph.syncRequest(Read,Procedure)",
1998 public <T> T syncRequest(final Read<T> request,
1999 final SyncProcedure<T> procedure) throws DatabaseException {
2000 return syncRequest(request, new SyncToAsyncProcedure<T>(procedure));
2004 public <T> T syncRequest(Read<T> request, Procedure<T> procedure)
2005 throws DatabaseException {
2006 return syncRequest(request, new NoneToAsyncProcedure<T>(procedure));
2009 static class AsyncReadProcedure<T> implements AsyncProcedure<T> {
2011 private static Throwable DONE = new Throwable();
2014 Throwable exception = null;
2017 public void execute(AsyncReadGraph graph, T t) {
2023 public void exception(AsyncReadGraph graph, Throwable t) {
2027 public void checkAndThrow() throws DatabaseException {
2028 if(exception != DONE) {
2029 if (exception instanceof DatabaseException)
2030 throw (DatabaseException) exception;
2032 throw new DatabaseException(
2033 "Unexpected exception in ReadGraph.syncRequest(AsyncMultiRead)",
2038 public boolean done() {
2039 return exception != null;
2045 public <T> T syncRequest(final AsyncRead<T> request)
2046 throws DatabaseException {
2048 assert (request != null);
2049 AsyncReadProcedure<T> procedure = new AsyncReadProcedure<T>();
2050 syncRequest(request, procedure);
2051 procedure.checkAndThrow();
2052 return procedure.result;
2054 // return syncRequest(request, new AsyncProcedureAdapter<T>());
2059 public <T> T syncRequest(AsyncRead<T> request, AsyncListener<T> procedure)
2060 throws DatabaseException {
2061 return syncRequest(request, (AsyncProcedure<T>) procedure);
2065 public <T> T syncRequest(AsyncRead<T> request, SyncListener<T> procedure)
2066 throws DatabaseException {
2067 return syncRequest(request, new SyncToAsyncListener<T>(procedure));
2071 public <T> T syncRequest(AsyncRead<T> request, Listener<T> procedure)
2072 throws DatabaseException {
2073 return syncRequest(request, new NoneToAsyncListener<T>(procedure));
2077 final public <T> T syncRequest(final AsyncRead<T> request,
2078 final AsyncProcedure<T> procedure) throws DatabaseException {
2080 assert (request != null);
2082 ListenerBase listener = getListenerBase(procedure);
2084 final ResultCallWrappedSingleQueryProcedure4<T> wrapper = new ResultCallWrappedSingleQueryProcedure4<T>(
2085 procedure, request);
2087 QueryCache.runnerAsyncReadEntry(this, request, parent, listener, wrapper);
2089 //processor.query(this, request, parent, wrapper, listener);
2091 return wrapper.getResult();
2093 // if (parent != null || listener != null || ((request.getFlags() & RequestFlags.SCHEDULE) > 0)) {
2095 //// Object syncParent = request;
2097 //// final ReadGraphImpl newGraph = newSync();
2100 //// newGraph.waitAsync(syncParent);
2102 // Throwable e = wrapper.getException();
2104 // // The request was async - produce meaningful stack trace by
2106 // if (e instanceof DatabaseException)
2107 // throw (DatabaseException) e;
2109 // throw new DatabaseException(e);
2112 // return wrapper.getResult();
2116 // // System.out.println("direct call " + request );
2118 // // Do not set the sync state.parent for external threads
2119 //// Object syncParent = request;
2121 //// final ReadGraphImpl newGraph = newSync();
2123 // final ResultCallWrappedSingleQueryProcedure4<T> wrapper = new ResultCallWrappedSingleQueryProcedure4<T>(
2124 // procedure, request);
2128 // processor.tryQuery(this, request, wrapper);
2130 // } catch (Throwable t) {
2132 // wrapper.exception(this, t);
2136 // Throwable e = wrapper.getException();
2138 // // The request was async - produce meaningful stack trace by
2140 // if (e instanceof DatabaseException)
2141 // throw (DatabaseException) e;
2143 // throw new DatabaseException(e);
2146 // return wrapper.getResult();
2152 final private <T> void syncRequest(final AsyncRead<T> request, final AsyncReadProcedure<T> procedure) throws DatabaseException {
2154 assert (request != null);
2156 ListenerBase listener = getListenerBase(procedure);
2157 assert(listener == null);
2159 // final ResultCallWrappedSingleQueryProcedure4<T> wrapper = new ResultCallWrappedSingleQueryProcedure4<T>(
2160 // procedure, request);
2162 QueryCache.runnerAsyncReadEntry(this, request, parent, listener, procedure);
2167 public <T> T syncRequest(AsyncRead<T> request,
2168 final SyncProcedure<T> procedure) throws DatabaseException {
2169 return syncRequest(request, new SyncToAsyncProcedure<T>(procedure));
2173 final public <T> T syncRequest(final AsyncRead<T> request,
2174 final Procedure<T> procedure) throws DatabaseException {
2175 return syncRequest(request, new NoneToAsyncProcedure<T>(procedure));
2179 public <T> Collection<T> syncRequest(final MultiRead<T> request)
2180 throws DatabaseException {
2182 assert (request != null);
2184 final ArrayList<T> result = new ArrayList<T>();
2185 final DataContainer<Throwable> exception = new DataContainer<Throwable>();
2187 syncRequest(request, new AsyncMultiProcedure<T>() {
2190 public void execute(AsyncReadGraph graph, T t) {
2191 synchronized (result) {
2197 public void finished(AsyncReadGraph graph) {
2201 public void exception(AsyncReadGraph graph, Throwable t) {
2206 public String toString() {
2207 return "syncRequest(MultiRead) -> " + request;
2212 Throwable t = exception.get();
2214 if (t instanceof DatabaseException)
2215 throw (DatabaseException) t;
2217 throw new DatabaseException(
2218 "Unexpected exception in ReadGraph.syncRequest(Read)",
2227 public <T> Collection<T> syncRequest(MultiRead<T> request,
2228 AsyncMultiListener<T> procedure) {
2229 return syncRequest(request, (AsyncMultiProcedure<T>) procedure);
2233 public <T> Collection<T> syncRequest(MultiRead<T> request,
2234 SyncMultiListener<T> procedure) {
2235 return syncRequest(request, new SyncToAsyncMultiListener<T>(procedure));
2239 public <T> Collection<T> syncRequest(MultiRead<T> request,
2240 MultiListener<T> procedure) {
2241 return syncRequest(request, new NoneToAsyncMultiListener<T>(procedure));
2245 public <T> Collection<T> syncRequest(MultiRead<T> request,
2246 AsyncMultiProcedure<T> procedure) {
2248 assert (request != null);
2250 ListenerBase listener = getListenerBase(procedure);
2252 if (parent != null || listener != null) {
2254 // Object syncParent = request;
2256 // final ReadGraphImpl newGraph = newSync();
2258 processor.query(this, request, parent, procedure, listener);
2260 // newGraph.waitAsync(syncParent);
2264 // Object syncParent = request;
2266 // final ReadGraphImpl newGraph = newSync();
2268 final ResultCallWrappedQueryProcedure4<T> wrapper = new ResultCallWrappedQueryProcedure4<T>(procedure);
2272 request.perform(this, wrapper);
2274 } catch (Throwable t) {
2276 wrapper.exception(this, t);
2277 // newGraph.waitAsync(syncParent);
2289 public <T> Collection<T> syncRequest(MultiRead<T> request,
2290 SyncMultiProcedure<T> procedure) {
2291 return syncRequest(request, new SyncToAsyncMultiProcedure<T>(procedure));
2295 public <T> Collection<T> syncRequest(MultiRead<T> request,
2296 MultiProcedure<T> procedure) {
2297 return syncRequest(request, new NoneToAsyncMultiProcedure<T>(procedure));
2300 static class AsyncMultiReadProcedure<T> extends ArrayList<T> implements AsyncMultiProcedure<T> {
2302 private static Throwable DONE = new Throwable();
2304 private static final long serialVersionUID = -6494230465108115812L;
2306 Throwable exception = null;
2309 public synchronized void execute(AsyncReadGraph graph, T t) {
2314 public void finished(AsyncReadGraph graph) {
2319 public void exception(AsyncReadGraph graph, Throwable t) {
2323 public void checkAndThrow() throws DatabaseException {
2324 if(exception != DONE) {
2325 if (exception instanceof DatabaseException)
2326 throw (DatabaseException) exception;
2328 throw new DatabaseException(
2329 "Unexpected exception in ReadGraph.syncRequest(AsyncMultiRead)",
2334 public boolean done() {
2335 return exception != null;
2341 final public <T> Collection<T> syncRequest(AsyncMultiRead<T> request)
2342 throws DatabaseException {
2344 assert (request != null);
2346 final AsyncMultiReadProcedure<T> procedure = new AsyncMultiReadProcedure<T>();
2348 syncRequest(request, procedure);
2350 procedure.checkAndThrow();
2356 public <T> Collection<T> syncRequest(AsyncMultiRead<T> request,
2357 AsyncMultiListener<T> procedure) {
2358 return syncRequest(request, (AsyncMultiProcedure<T>) procedure);
2362 public <T> Collection<T> syncRequest(AsyncMultiRead<T> request,
2363 SyncMultiListener<T> procedure) {
2364 return syncRequest(request, new SyncToAsyncMultiListener<T>(procedure));
2368 public <T> Collection<T> syncRequest(AsyncMultiRead<T> request,
2369 MultiListener<T> procedure) {
2370 return syncRequest(request, new NoneToAsyncMultiListener<T>(procedure));
2373 final private <T> void syncRequest(final AsyncMultiRead<T> request,
2374 final AsyncMultiReadProcedure<T> procedure) {
2376 assert (request != null);
2377 assert (procedure != null);
2379 ListenerBase listener = getListenerBase(procedure);
2381 if (parent != null || listener != null) {
2383 // Object syncParent = request;
2385 // final ReadGraphImpl newGraph = newSync();
2387 processor.query(this, request, parent, procedure, listener);
2389 // newGraph.waitAsync(syncParent);
2390 waitAsyncProcedure(procedure);
2394 // Object syncParent = callerThread == Integer.MIN_VALUE ? null
2397 // final ReadGraphImpl newGraph = newSyncAsync(syncParent);
2402 // ReadGraphImpl sync = newSync();
2403 request.perform(this, procedure);
2404 // sync.waitAsync(null);
2405 waitAsyncProcedure(procedure);
2408 } catch (Throwable t) {
2410 waitAsyncProcedure(procedure);
2421 final public <T> Collection<T> syncRequest(final AsyncMultiRead<T> request,
2422 final AsyncMultiProcedure<T> procedure) {
2424 assert (request != null);
2425 assert (procedure != null);
2427 ListenerBase listener = getListenerBase(procedure);
2429 if (parent != null || listener != null) {
2431 // Object syncParent = request;
2433 // final ReadGraphImpl newGraph = newSync();
2435 processor.query(this, request, parent, procedure, listener);
2437 // newGraph.waitAsync(syncParent);
2441 // Object syncParent = request;
2443 // final ReadGraphImpl newGraph = newSync();
2447 request.perform(this, new AsyncMultiProcedure<T>() {
2450 public void execute(AsyncReadGraph graph, T result) {
2451 procedure.execute(graph, result);
2455 public void finished(AsyncReadGraph graph) {
2456 procedure.finished(graph);
2460 public void exception(AsyncReadGraph graph, Throwable t) {
2461 procedure.exception(graph, t);
2465 public String toString() {
2466 return "syncRequest(AsyncMultiRead) -> " + procedure;
2471 } catch (Throwable t) {
2483 public <T> Collection<T> syncRequest(AsyncMultiRead<T> request,
2484 final SyncMultiProcedure<T> procedure) {
2485 return syncRequest(request, new SyncToAsyncMultiProcedure<T>(procedure));
2489 final public <T> Collection<T> syncRequest(final AsyncMultiRead<T> request,
2490 final MultiProcedure<T> procedure) {
2491 return syncRequest(request, new NoneToAsyncMultiProcedure<T>(procedure));
2495 public <T> T syncRequest(final ExternalRead<T> request)
2496 throws DatabaseException {
2498 assert (request != null);
2500 return syncRequest(request, new Procedure<T>() {
2503 public void execute(T t) {
2507 public void exception(Throwable t) {
2511 public String toString() {
2512 return "syncRequest(AsyncRead) -> " + request;
2520 public <T> T syncRequest(ExternalRead<T> request, Listener<T> procedure) throws DatabaseException {
2521 return syncRequest(request, (Procedure<T>) procedure);
2525 final public <T> T syncRequest(final ExternalRead<T> request,
2526 final Procedure<T> procedure) throws DatabaseException {
2528 assert (request != null);
2530 ListenerBase listener = getListenerBase(procedure);
2532 final DataContainer<Throwable> exception = new DataContainer<Throwable>();
2533 final DataContainer<T> result = new DataContainer<T>();
2535 processor.query(this, request, parent, new Procedure<T>() {
2538 public void exception(Throwable throwable) {
2539 exception.set(throwable);
2540 procedure.exception(throwable);
2544 public void execute(T t) {
2546 procedure.execute(t);
2553 // if (parent != null || listener != null) {
2555 //// final ReadGraphImpl newGraph = newSync();
2558 //// newGraph.waitAsync(request);
2564 // T t = processor.tryQuery(this, request);
2566 // procedure.execute(t);
2568 // } catch (Throwable t) {
2570 // if (t instanceof DatabaseException) {
2571 // exception.set((DatabaseException)t);
2572 // procedure.exception(exception.get());
2574 // exception.set(new DatabaseException(
2575 // "Unexpected exception in ReadGraph.syncRequest(Read)",
2577 // procedure.exception(exception.get());
2584 Throwable t = exception.get();
2586 if (t instanceof DatabaseException)
2587 throw (DatabaseException) t;
2589 throw new DatabaseException(
2590 "Unexpected exception in ReadGraph.syncRequest(Read)",
2594 return result.get();
2599 public void syncRequest(final Write request) throws DatabaseException {
2601 assert (request != null);
2603 throw new DatabaseException(
2604 "Write operations are not supported during read transactions!");
2609 public <T> T syncRequest(final WriteResult<T> request) throws DatabaseException {
2611 assert (request != null);
2613 throw new DatabaseException(
2614 "Write operations are not supported during read transactions!");
2619 public void syncRequest(final DelayedWrite request)
2620 throws DatabaseException {
2622 assert (request != null);
2624 throw new DatabaseException(
2625 "Write operations are not supported during read transactions!");
2630 public <T> T syncRequest(final DelayedWriteResult<T> request) throws DatabaseException {
2632 assert (request != null);
2634 throw new DatabaseException(
2635 "Write operations are not supported during read transactions!");
2640 public void syncRequest(final WriteOnly request) throws DatabaseException {
2642 assert (request != null);
2644 throw new DatabaseException(
2645 "Write operations are not supported during read transactions!");
2650 public <T> T syncRequest(final WriteOnlyResult<T> request) throws DatabaseException {
2652 assert (request != null);
2654 throw new DatabaseException(
2655 "Write operations are not supported during read transactions!");
2660 public <T> void async(ReadInterface<T> r, AsyncProcedure<T> procedure) {
2661 r.request(this, procedure);
2665 public <T> void async(ReadInterface<T> r, Procedure<T> procedure) {
2666 r.request(this, procedure);
2670 public <T> void async(ReadInterface<T> r, SyncProcedure<T> procedure) {
2671 r.request(this, procedure);
2675 public <T> void async(ReadInterface<T> r, AsyncListener<T> procedure) {
2676 r.request(this, procedure);
2680 public <T> void async(ReadInterface<T> r, Listener<T> procedure) {
2681 r.request(this, procedure);
2685 public <T> void async(ReadInterface<T> r, SyncListener<T> procedure) {
2686 r.request(this, procedure);
2690 public <T> T sync(ReadInterface<T> r) throws DatabaseException {
2691 return r.request(this);
2695 public <T> T sync(WriteInterface<T> r) throws DatabaseException {
2696 return r.request(this);
2700 public <T> void async(WriteInterface<T> r, Procedure<T> procedure) {
2701 r.request(this, procedure);
2705 public <T> void async(WriteInterface<T> r) {
2706 r.request(this, new ProcedureAdapter<T>());
2710 * Implementation of the interface AsyncReadGraph
2714 public void forURI(Resource resource, AsyncListener<String> listener) {
2715 asyncRequest(new org.simantics.db.common.uri.ResourceToURI(resource),
2720 public void forURI(Resource resource, SyncListener<String> listener) {
2721 asyncRequest(new org.simantics.db.common.uri.ResourceToURI(resource),
2726 public void forURI(Resource resource, Listener<String> listener) {
2727 asyncRequest(new org.simantics.db.common.uri.ResourceToURI(resource),
2732 final public void forURI(final Resource resource,
2733 final AsyncProcedure<String> procedure) {
2735 assert (resource != null);
2736 assert (procedure != null);
2738 asyncRequest(new org.simantics.db.common.uri.ResourceToURI(resource),
2744 public void forURI(Resource resource, SyncProcedure<String> procedure) {
2745 forURI(resource, new SyncToAsyncProcedure<String>(procedure));
2749 public void forURI(Resource resource, Procedure<String> procedure) {
2750 forURI(resource, new NoneToAsyncProcedure<String>(procedure));
2754 public void forResource(String id, AsyncListener<Resource> listener) {
2755 asyncRequest(new org.simantics.db.common.primitiverequest.Resource(id),
2760 public void forResource(String id, SyncListener<Resource> listener) {
2761 asyncRequest(new org.simantics.db.common.primitiverequest.Resource(id),
2766 public void forResource(String id, Listener<Resource> listener) {
2767 asyncRequest(new org.simantics.db.common.primitiverequest.Resource(id),
2772 final public void forResource(final String id,
2773 final AsyncProcedure<Resource> procedure) {
2775 assert (id != null);
2776 assert (procedure != null);
2778 processor.forResource(this, id, procedure);
2783 public void forResource(String id, SyncProcedure<Resource> procedure) {
2784 forResource(id, new SyncToAsyncProcedure<Resource>(procedure));
2788 public void forResource(String id, Procedure<Resource> procedure) {
2789 forResource(id, new NoneToAsyncProcedure<Resource>(procedure));
2793 public void forBuiltin(String id, AsyncListener<Resource> listener) {
2794 asyncRequest(new Builtin(id), listener);
2798 public void forBuiltin(String id, SyncListener<Resource> listener) {
2799 asyncRequest(new Builtin(id), listener);
2803 public void forBuiltin(String id, Listener<Resource> listener) {
2804 asyncRequest(new Builtin(id), listener);
2808 final public void forBuiltin(final String id,
2809 final AsyncProcedure<Resource> procedure) {
2811 assert (id != null);
2812 assert (procedure != null);
2814 processor.forBuiltin(this, id, procedure);
2819 public void forBuiltin(String id, SyncProcedure<Resource> procedure) {
2820 forBuiltin(id, new SyncToAsyncProcedure<Resource>(procedure));
2824 public void forBuiltin(String id, Procedure<Resource> procedure) {
2825 forBuiltin(id, new NoneToAsyncProcedure<Resource>(procedure));
2829 final public void forEachStatement(Resource subject, Resource relation,
2830 AsyncMultiProcedure<Statement> procedure) {
2832 assert (subject != null);
2833 assert (relation != null);
2834 assert (procedure != null);
2836 processor.forEachStatement(this, subject, relation, procedure);
2841 public void forEachStatement(Resource subject, Resource relation,
2842 SyncMultiProcedure<Statement> procedure) {
2843 forEachStatement(subject, relation,
2844 new SyncToAsyncMultiProcedure<Statement>(procedure));
2848 final public void forEachStatement(Resource subject, Resource relation,
2849 MultiProcedure<Statement> procedure) {
2851 assert (subject != null);
2852 assert (relation != null);
2853 assert (procedure != null);
2855 processor.forEachStatement(this, subject, relation, procedure);
2860 final public void forStatementSet(Resource subject, Resource relation,
2861 AsyncSetListener<Statement> procedure) {
2863 assert (subject != null);
2864 assert (relation != null);
2865 assert (procedure != null);
2867 processor.forStatementSet(this, subject, relation, procedure);
2872 final public void forStatementSet(Resource subject, Resource relation,
2873 SyncSetListener<Statement> procedure) {
2874 forStatementSet(subject, relation,
2875 new SyncToAsyncSetProcedure<Statement>(procedure));
2879 public void forStatementSet(Resource subject, Resource relation,
2880 SetListener<Statement> listener) {
2881 forStatementSet(subject, relation,
2882 new NoneToAsyncSetProcedure<Statement>(listener));
2886 final public void forEachAssertedStatement(final Resource subject,
2887 final Resource relation,
2888 final AsyncMultiProcedure<Statement> procedure) {
2890 assert (subject != null);
2891 assert (relation != null);
2892 assert (procedure != null);
2894 processor.forEachAssertedStatement(this, subject, relation, procedure);
2899 public void forEachAssertedStatement(Resource subject, Resource relation,
2900 SyncMultiProcedure<Statement> procedure) {
2901 forEachAssertedStatement(subject, relation,
2902 new SyncToAsyncMultiProcedure<Statement>(procedure));
2906 public void forEachAssertedStatement(Resource subject, Resource relation,
2907 MultiProcedure<Statement> procedure) {
2908 forEachAssertedStatement(subject, relation,
2909 new NoneToAsyncMultiProcedure<Statement>(procedure));
2913 public void forAssertedStatementSet(Resource subject, Resource relation,
2914 AsyncSetListener<Statement> procedure) {
2916 assert (subject != null);
2917 assert (relation != null);
2918 assert (procedure != null);
2920 processor.forAssertedStatementSet(this, subject, relation, procedure);
2925 public void forAssertedStatementSet(Resource subject, Resource relation,
2926 SyncSetListener<Statement> procedure) {
2928 assert (subject != null);
2929 assert (relation != null);
2930 assert (procedure != null);
2932 forAssertedStatementSet(subject, relation,
2933 new SyncToAsyncSetProcedure<Statement>(procedure));
2938 public void forAssertedStatementSet(Resource subject, Resource relation,
2939 SetListener<Statement> procedure) {
2941 assert (subject != null);
2942 assert (relation != null);
2943 assert (procedure != null);
2945 forAssertedStatementSet(subject, relation,
2946 new NoneToAsyncSetProcedure<Statement>(procedure));
2951 final public void forEachPredicate(final Resource subject,
2952 final AsyncMultiProcedure<Resource> procedure) {
2954 assert (subject != null);
2955 assert (procedure != null);
2957 processor.forEachPredicate(this, subject, procedure);
2962 public void forEachPredicate(Resource subject,
2963 SyncMultiProcedure<Resource> procedure) {
2964 forEachPredicate(subject, new SyncToAsyncMultiProcedure<Resource>(
2969 final public void forEachPredicate(final Resource subject,
2970 final MultiProcedure<Resource> procedure) {
2972 assert (subject != null);
2973 assert (procedure != null);
2975 processor.forEachPredicate(this, subject, procedure);
2980 final public void forPredicateSet(final Resource subject,
2981 final AsyncSetListener<Resource> procedure) {
2983 assert (subject != null);
2984 assert (procedure != null);
2986 processor.forPredicateSet(this, subject, procedure);
2991 final public void forPredicateSet(final Resource subject,
2992 final SyncSetListener<Resource> procedure) {
2994 assert (subject != null);
2995 assert (procedure != null);
2997 forPredicateSet(subject, new SyncToAsyncSetProcedure<Resource>(
3003 final public void forPredicateSet(final Resource subject,
3004 final SetListener<Resource> procedure) {
3006 assert (subject != null);
3007 assert (procedure != null);
3009 forPredicateSet(subject, new NoneToAsyncSetProcedure<Resource>(
3015 final public void forEachPrincipalType(final Resource subject,
3016 final AsyncMultiProcedure<Resource> procedure) {
3018 assert (subject != null);
3019 assert (procedure != null);
3021 processor.forEachPrincipalType(this, subject, procedure);
3026 public void forEachPrincipalType(Resource subject,
3027 SyncMultiProcedure<Resource> procedure) {
3028 forEachPrincipalType(subject, new SyncToAsyncMultiProcedure<Resource>(
3033 final public void forEachPrincipalType(final Resource subject,
3034 final MultiProcedure<Resource> procedure) {
3036 assert (subject != null);
3037 assert (procedure != null);
3039 processor.forEachPrincipalType(this, subject, procedure);
3044 final public void forPrincipalTypeSet(final Resource subject,
3045 final AsyncSetListener<Resource> procedure) {
3047 assert (subject != null);
3048 assert (procedure != null);
3050 processor.forPrincipalTypeSet(this, subject, procedure);
3055 final public void forPrincipalTypeSet(final Resource subject,
3056 final SyncSetListener<Resource> procedure) {
3058 assert (subject != null);
3059 assert (procedure != null);
3061 forPrincipalTypeSet(subject, new SyncToAsyncSetProcedure<Resource>(
3067 final public void forPrincipalTypeSet(final Resource subject,
3068 final SetListener<Resource> procedure) {
3070 assert (subject != null);
3071 assert (procedure != null);
3073 forPrincipalTypeSet(subject, new NoneToAsyncSetProcedure<Resource>(
3079 public void forTypes(Resource subject, AsyncListener<Set<Resource>> listener) {
3080 asyncRequest(new Types(subject), listener);
3084 public void forTypes(Resource subject, SyncListener<Set<Resource>> listener) {
3085 asyncRequest(new Types(subject), listener);
3089 public void forTypes(Resource subject, Listener<Set<Resource>> listener) {
3090 asyncRequest(new Types(subject), listener);
3094 final public void forTypes(final Resource subject,
3095 final AsyncProcedure<Set<Resource>> procedure) {
3097 assert (subject != null);
3098 assert (procedure != null);
3100 processor.forTypes(this, subject, procedure);
3105 public void forTypes(Resource subject,
3106 SyncProcedure<Set<Resource>> procedure) {
3107 forTypes(subject, new SyncToAsyncProcedure<Set<Resource>>(procedure));
3111 public void forTypes(Resource subject, Procedure<Set<Resource>> procedure) {
3112 forTypes(subject, new NoneToAsyncProcedure<Set<Resource>>(procedure));
3116 public void forSupertypes(Resource subject,
3117 AsyncListener<Set<Resource>> listener) {
3118 asyncRequest(new Types(subject), listener);
3122 public void forSupertypes(Resource subject,
3123 SyncListener<Set<Resource>> listener) {
3124 asyncRequest(new Types(subject), listener);
3128 public void forSupertypes(Resource subject, Listener<Set<Resource>> listener) {
3129 asyncRequest(new Types(subject), listener);
3133 final public void forSupertypes(final Resource subject,
3134 final AsyncProcedure<Set<Resource>> procedure) {
3136 assert (subject != null);
3137 assert (procedure != null);
3139 processor.forSupertypes(this, subject, procedure);
3144 public void forSupertypes(Resource subject,
3145 SyncProcedure<Set<Resource>> procedure) {
3146 forSupertypes(subject, new SyncToAsyncProcedure<Set<Resource>>(
3151 public void forSupertypes(Resource subject,
3152 Procedure<Set<Resource>> procedure) {
3153 forSupertypes(subject, new NoneToAsyncProcedure<Set<Resource>>(
3158 public void forDirectSuperrelations(Resource subject,
3159 AsyncMultiProcedure<Resource> procedure) {
3161 assert (subject != null);
3162 assert (procedure != null);
3164 processor.forDirectSuperrelations(this, subject, procedure);
3169 public void forPossibleSuperrelation(Resource subject, AsyncProcedure<Resource> procedure) {
3171 assert (subject != null);
3172 assert (procedure != null);
3174 processor.forPossibleSuperrelation(this, subject, procedure);
3179 public void forSuperrelations(Resource subject,
3180 AsyncListener<Set<Resource>> listener) {
3181 asyncRequest(new Types(subject), listener);
3185 public void forSuperrelations(Resource subject,
3186 SyncListener<Set<Resource>> listener) {
3187 asyncRequest(new Types(subject), listener);
3191 public void forSuperrelations(Resource subject,
3192 Listener<Set<Resource>> listener) {
3193 asyncRequest(new Types(subject), listener);
3197 final public void forSuperrelations(final Resource subject,
3198 final AsyncProcedure<Set<Resource>> procedure) {
3200 assert (subject != null);
3201 assert (procedure != null);
3203 processor.forSuperrelations(this, subject, procedure);
3208 public void forSuperrelations(Resource subject,
3209 SyncProcedure<Set<Resource>> procedure) {
3210 forSuperrelations(subject, new SyncToAsyncProcedure<Set<Resource>>(
3215 public void forSuperrelations(Resource subject,
3216 Procedure<Set<Resource>> procedure) {
3217 forSuperrelations(subject, new NoneToAsyncProcedure<Set<Resource>>(
3222 final public void forEachObject(final Resource subject, final Resource relation, final AsyncMultiProcedure<Resource> procedure) {
3223 processor.forEachObject(this, subject, relation, procedure);
3227 public void forEachObject(Resource subject, Resource relation,
3228 SyncMultiProcedure<Resource> procedure) {
3229 forEachObject(subject, relation,
3230 new SyncToAsyncMultiProcedure<Resource>(procedure));
3234 public void forEachObject(Resource subject, Resource relation,
3235 MultiProcedure<Resource> procedure) {
3237 processor.forEachObject(this, subject, relation, procedure);
3242 // final public void forEachDirectObject(final Resource subject,
3243 // final Resource relation,
3244 // final AsyncMultiProcedure<Resource> procedure) {
3246 // processor.forEachDirectObject(this, subject, relation, procedure);
3251 // public void forEachDirectObject(Resource subject, Resource relation,
3252 // SyncMultiProcedure<Resource> procedure) {
3253 // forEachDirectObject(subject, relation,
3254 // new SyncToAsyncMultiProcedure<Resource>(procedure));
3258 // public void forEachDirectObject(Resource subject, Resource relation,
3259 // MultiProcedure<Resource> procedure) {
3260 // forEachDirectObject(subject, relation,
3261 // new NoneToAsyncMultiProcedure<Resource>(procedure));
3265 final public void forEachDirectPredicate(final Resource subject, final AsyncMultiProcedure<Resource> procedure) {
3266 processor.forEachDirectPredicate(this, subject, procedure);
3270 public void forEachDirectPredicate(Resource subject, SyncMultiProcedure<Resource> procedure) {
3271 forEachDirectPredicate(subject, new SyncToAsyncMultiProcedure<Resource>(procedure));
3275 public void forEachDirectPredicate(Resource subject, MultiProcedure<Resource> procedure) {
3276 forEachDirectPredicate(subject, new NoneToAsyncMultiProcedure<Resource>(procedure));
3280 final public void forObjectSet(final Resource subject,
3281 final Resource relation, final AsyncSetListener<Resource> procedure) {
3283 assert (subject != null);
3284 assert (relation != null);
3285 assert (procedure != null);
3287 processor.forObjectSet(this, subject, relation, procedure);
3292 final public void forObjectSet(final Resource subject,
3293 final Resource relation, final SyncSetListener<Resource> procedure) {
3295 assert (subject != null);
3296 assert (relation != null);
3297 assert (procedure != null);
3299 forObjectSet(subject, relation, new SyncToAsyncSetProcedure<Resource>(
3305 final public void forObjectSet(final Resource subject,
3306 final Resource relation, final SetListener<Resource> procedure) {
3308 assert (subject != null);
3309 assert (relation != null);
3310 assert (procedure != null);
3312 forObjectSet(subject, relation, new NoneToAsyncSetProcedure<Resource>(
3318 final public void forEachAssertedObject(final Resource subject,
3319 final Resource relation,
3320 final AsyncMultiProcedure<Resource> procedure) {
3322 assert (subject != null);
3323 assert (relation != null);
3324 assert (procedure != null);
3326 processor.forEachAssertedObject(this, subject, relation, procedure);
3331 public void forEachAssertedObject(Resource subject, Resource relation,
3332 SyncMultiProcedure<Resource> procedure) {
3334 assert (subject != null);
3335 assert (relation != null);
3336 assert (procedure != null);
3338 forEachAssertedObject(subject, relation,
3339 new SyncToAsyncMultiProcedure<Resource>(procedure));
3344 public void forEachAssertedObject(Resource subject, Resource relation,
3345 MultiProcedure<Resource> procedure) {
3347 assert (subject != null);
3348 assert (relation != null);
3349 assert (procedure != null);
3351 forEachAssertedObject(subject, relation,
3352 new NoneToAsyncMultiProcedure<Resource>(procedure));
3357 public void forAssertedObjectSet(Resource subject, Resource relation,
3358 AsyncSetListener<Resource> procedure) {
3360 assert (subject != null);
3361 assert (relation != null);
3362 assert (procedure != null);
3364 processor.forAssertedObjectSet(this, subject, relation, procedure);
3369 public void forAssertedObjectSet(Resource subject, Resource relation,
3370 SyncSetListener<Resource> procedure) {
3372 assert (subject != null);
3373 assert (relation != null);
3374 assert (procedure != null);
3376 forAssertedObjectSet(subject, relation,
3377 new SyncToAsyncSetProcedure<Resource>(procedure));
3382 public void forAssertedObjectSet(Resource subject, Resource relation,
3383 SetListener<Resource> procedure) {
3385 assert (subject != null);
3386 assert (relation != null);
3387 assert (procedure != null);
3389 forAssertedObjectSet(subject, relation,
3390 new NoneToAsyncSetProcedure<Resource>(procedure));
3395 public void forInverse(Resource relation, AsyncListener<Resource> listener) {
3396 asyncRequest(new Inverse(relation), listener);
3400 public void forInverse(Resource relation, SyncListener<Resource> listener) {
3401 asyncRequest(new Inverse(relation), listener);
3405 public void forInverse(Resource relation, Listener<Resource> listener) {
3406 asyncRequest(new Inverse(relation), listener);
3410 final public void forInverse(final Resource relation,
3411 final AsyncProcedure<Resource> procedure) {
3413 assert (relation != null);
3414 assert (procedure != null);
3416 processor.forInverse(this, relation, new AsyncProcedure<Resource>() {
3419 public void execute(AsyncReadGraph graph, Resource result) {
3421 procedure.execute(graph, result);
3423 procedure.exception(graph, new NoInverseException(relation
3429 public void exception(AsyncReadGraph graph, Throwable throwable) {
3430 procedure.exception(graph, throwable);
3434 public String toString() {
3435 return "forInverse -> " + procedure;
3443 public void forInverse(Resource relation, SyncProcedure<Resource> procedure) {
3444 forInverse(relation, new SyncToAsyncProcedure<Resource>(procedure));
3448 public void forInverse(Resource relation, Procedure<Resource> procedure) {
3449 forInverse(relation, new NoneToAsyncProcedure<Resource>(procedure));
3453 public void forSingleObject(Resource subject, Resource relation,
3454 AsyncListener<Resource> listener) {
3455 asyncRequest(new SingleObject(subject, relation), listener);
3459 public void forSingleObject(Resource subject, Resource relation,
3460 SyncListener<Resource> listener) {
3461 asyncRequest(new SingleObject(subject, relation), listener);
3465 public void forSingleObject(Resource subject, Resource relation,
3466 Listener<Resource> listener) {
3467 asyncRequest(new SingleObject(subject, relation), listener);
3471 final public void forSingleObject(final Resource subject,
3472 final Resource relation, final AsyncProcedure<Resource> procedure) {
3474 assert (subject != null);
3475 assert (relation != null);
3476 assert (procedure != null);
3478 processor.forEachObject(this, subject, relation,
3479 new SingleOrErrorProcedure<Resource>(procedure));
3484 public void forSingleObject(Resource subject, Resource relation,
3485 SyncProcedure<Resource> procedure) {
3486 forSingleObject(subject, relation, new SyncToAsyncProcedure<Resource>(
3491 public void forSingleObject(Resource subject, Resource relation,
3492 Procedure<Resource> procedure) {
3493 forSingleObject(subject, relation, new NoneToAsyncProcedure<Resource>(
3498 public void forSingleStatement(Resource subject, Resource relation,
3499 AsyncListener<Statement> listener) {
3500 asyncRequest(new SingleStatement(subject, relation), listener);
3504 public void forSingleStatement(Resource subject, Resource relation,
3505 SyncListener<Statement> listener) {
3506 asyncRequest(new SingleStatement(subject, relation), listener);
3510 public void forSingleStatement(Resource subject, Resource relation,
3511 Listener<Statement> listener) {
3512 asyncRequest(new SingleStatement(subject, relation), listener);
3516 final public void forSingleStatement(final Resource subject,
3517 final Resource relation, final AsyncProcedure<Statement> procedure) {
3519 assert (subject != null);
3520 assert (relation != null);
3521 assert (procedure != null);
3523 processor.forEachStatement(this, subject, relation,
3524 new SingleOrErrorProcedure<Statement>(procedure));
3529 public void forSingleStatement(Resource subject, Resource relation,
3530 SyncProcedure<Statement> procedure) {
3531 forSingleStatement(subject, relation,
3532 new SyncToAsyncProcedure<Statement>(procedure));
3536 public void forSingleStatement(Resource subject, Resource relation,
3537 Procedure<Statement> procedure) {
3538 forSingleStatement(subject, relation,
3539 new NoneToAsyncProcedure<Statement>(procedure));
3543 public void forSingleType(Resource subject,
3544 AsyncListener<Resource> listener) {
3545 asyncRequest(new SingleTypeAny(subject), listener);
3549 public void forSingleType(Resource subject,
3550 SyncListener<Resource> listener) {
3551 asyncRequest(new SingleTypeAny(subject), listener);
3555 public void forSingleType(Resource subject,
3556 Listener<Resource> listener) {
3557 asyncRequest(new SingleTypeAny(subject), listener);
3561 final public void forSingleType(final Resource subject, final AsyncProcedure<Resource> procedure) {
3563 assert (subject != null);
3564 assert (procedure != null);
3566 final DeepSingleOrErrorProcedure<Resource> checkedProcedure = new DeepSingleOrErrorProcedure<Resource>(procedure);
3568 processor.forEachPrincipalType(this, subject, new AsyncMultiProcedureAdapter<Resource>() {
3571 public void execute(AsyncReadGraph graph, final Resource principalType) {
3572 checkedProcedure.offer(graph, principalType);
3576 public void finished(AsyncReadGraph graph) {
3577 checkedProcedure.dec(graph);
3581 public void exception(AsyncReadGraph graph, Throwable t) {
3582 checkedProcedure.exception(graph, t);
3586 public String toString() {
3587 return "forSingleType -> " + procedure;
3595 public void forSingleType(Resource subject, SyncProcedure<Resource> procedure) {
3596 forSingleType(subject, new SyncToAsyncProcedure<Resource>(
3601 public void forSingleType(Resource subject, Procedure<Resource> procedure) {
3602 forSingleType(subject, new NoneToAsyncProcedure<Resource>(
3607 public void forSingleType(Resource subject, Resource relation,
3608 AsyncListener<Resource> listener) {
3609 asyncRequest(new SingleType(subject, relation), listener);
3613 public void forSingleType(Resource subject, Resource relation,
3614 SyncListener<Resource> listener) {
3615 asyncRequest(new SingleType(subject, relation), listener);
3619 public void forSingleType(Resource subject, Resource relation,
3620 Listener<Resource> listener) {
3621 asyncRequest(new SingleType(subject, relation), listener);
3625 final public void forSingleType(final Resource subject,
3626 final Resource baseType, final AsyncProcedure<Resource> procedure) {
3628 assert (subject != null);
3629 assert (procedure != null);
3631 final DeepSingleOrErrorProcedure<Resource> checkedProcedure = new DeepSingleOrErrorProcedure<Resource>(procedure);
3633 processor.forEachPrincipalType(this, subject,
3634 new AsyncMultiProcedureAdapter<Resource>() {
3637 public void execute(AsyncReadGraph graph,
3638 final Resource principalType) {
3640 checkedProcedure.inc();
3642 if(baseType == null) {
3644 checkedProcedure.offer(graph, principalType);
3645 checkedProcedure.dec(graph);
3647 } else if(principalType.equals(baseType)) {
3649 checkedProcedure.offer(graph, principalType);
3650 checkedProcedure.dec(graph);
3654 processor.forSupertypes((ReadGraphImpl)graph, principalType,
3655 new AsyncProcedure<Set<Resource>>() {
3658 public void execute(
3659 AsyncReadGraph graph,
3660 Set<Resource> result) {
3662 if (result.contains(baseType))
3663 checkedProcedure.offer(graph,
3665 checkedProcedure.dec(graph);
3670 public void exception(
3671 AsyncReadGraph graph,
3674 .exception(graph, t);
3684 public void finished(AsyncReadGraph graph) {
3685 checkedProcedure.dec(graph);
3689 public void exception(AsyncReadGraph graph, Throwable t) {
3690 checkedProcedure.exception(graph, t);
3694 public String toString() {
3695 return "forSingleType -> " + procedure;
3703 public void forSingleType(Resource subject, Resource relation,
3704 SyncProcedure<Resource> procedure) {
3705 forSingleType(subject, relation, new SyncToAsyncProcedure<Resource>(
3710 public void forSingleType(Resource subject, Resource relation,
3711 Procedure<Resource> procedure) {
3712 forSingleType(subject, relation, new NoneToAsyncProcedure<Resource>(
3717 public <T> void forValue(Resource subject, Binding binding,
3718 AsyncListener<T> listener) {
3719 asyncRequest(new Value<T>(subject, binding), listener);
3723 public <T> void forValue(Resource subject, Binding binding,
3724 SyncListener<T> listener) {
3725 asyncRequest(new Value<T>(subject, binding), listener);
3729 public <T> void forValue(Resource subject, Binding binding,
3730 Listener<T> listener) {
3731 asyncRequest(new Value<T>(subject, binding), listener);
3735 public <T> void forValue(final Resource resource, final Binding binding,
3736 final AsyncProcedure<T> procedure) {
3738 assert (resource != null);
3739 assert (binding != null);
3740 assert (procedure != null);
3742 processor.forValue(this, resource, new AsyncProcedure<byte[]>() {
3745 public void execute(AsyncReadGraph graph, byte[] result) {
3749 if (result == null) {
3750 procedure.exception(graph,
3751 new DoesNotContainValueException(
3752 "No value for resource " + resource));
3756 Serializer serializer = binding.serializer();
3757 // Serializer serializer = Bindings.getSerializer( binding );
3758 Object obj = serializer.deserialize(result);
3759 // if (!binding.isInstance(obj))
3760 // procedure.exception(graph, new ClassCastException(
3761 // "Cannot get value " + obj + " with binding "
3764 procedure.execute(graph, (T) obj);
3766 } catch (IOException e) {
3767 procedure.exception(graph, e);
3768 } catch (BufferUnderflowException e) {
3769 procedure.exception(graph, e);
3770 } catch (Throwable t) {
3771 procedure.exception(graph, t);
3777 public void exception(AsyncReadGraph graph, Throwable t) {
3779 procedure.exception(graph, t);
3780 } catch (Throwable t2) {
3781 Logger.defaultLogError(t2);
3786 public String toString() {
3787 return "forValue -> " + procedure;
3795 public <T> void forValue(Resource subject, Binding binding,
3796 SyncProcedure<T> procedure) {
3797 forValue(subject, binding, new SyncToAsyncProcedure<T>(procedure));
3801 public <T> void forValue(Resource subject, Binding binding,
3802 Procedure<T> procedure) {
3803 forValue(subject, binding, new NoneToAsyncProcedure<T>(procedure));
3807 public <T> void forValue(Resource subject, AsyncListener<T> listener) {
3808 asyncRequest(new ValueImplied<T>(subject), listener);
3812 public <T> void forValue(Resource subject, SyncListener<T> listener) {
3813 asyncRequest(new ValueImplied<T>(subject), listener);
3817 public <T> void forValue(Resource subject, Listener<T> listener) {
3818 asyncRequest(new ValueImplied<T>(subject), listener);
3822 final public <T> void forValue(final Resource subject, final AsyncProcedure<T> procedure) {
3824 assert (subject != null);
3825 assert (procedure != null);
3827 forRelatedValue(subject, processor.getL0(this).HasDataType, DATA_TYPE_BINDING_INTERNAL, new AsyncProcedure<Datatype>() {
3830 public void execute(AsyncReadGraph graph, Datatype type) {
3831 // TODO: consider trying Bindings.getBeanBinding(type);
3832 Binding binding = Bindings.getBinding(type);
3833 graph.forValue(subject, binding, procedure);
3837 public void exception(AsyncReadGraph graph, Throwable throwable) {
3838 procedure.exception(graph, new DoesNotContainValueException("Invalid data type", throwable));
3846 public <T> void forValue(Resource subject, SyncProcedure<T> procedure) {
3847 forValue(subject, new SyncToAsyncProcedure<T>(procedure));
3851 public <T> void forValue(Resource subject, Procedure<T> procedure) {
3852 forValue(subject, new NoneToAsyncProcedure<T>(procedure));
3856 public <T> void forRelatedValue(Resource subject, Resource relation,
3857 AsyncListener<T> listener) {
3858 asyncRequest(new RelatedValueImplied<T>(subject, relation), listener);
3862 public <T> void forRelatedValue(Resource subject, Resource relation,
3863 SyncListener<T> listener) {
3864 asyncRequest(new RelatedValueImplied<T>(subject, relation), listener);
3868 public <T> void forRelatedValue(Resource subject, Resource relation,
3869 Listener<T> listener) {
3870 asyncRequest(new RelatedValueImplied<T>(subject, relation), listener);
3874 final public <T> void forRelatedValue(final Resource subject,
3875 final Resource relation, final AsyncProcedure<T> procedure) {
3877 assert (subject != null);
3878 assert (relation != null);
3879 assert (procedure != null);
3881 final DeepSingleOrErrorProcedure<T> checkedProcedure = new DeepSingleOrErrorProcedure<T>(procedure);
3883 processor.forEachObject(this, subject, relation,
3884 new AsyncMultiProcedureAdapter<Resource>() {
3887 public void execute(AsyncReadGraph graph,
3888 final Resource object) {
3890 checkedProcedure.inc();
3892 graph.forValue(object, new AsyncProcedure<Object>() {
3895 public void execute(AsyncReadGraph graph,
3897 checkedProcedure.offer(graph, (T) result);
3898 checkedProcedure.dec(graph);
3902 public void exception(AsyncReadGraph graph,
3904 checkedProcedure.exception(graph, t);
3908 public String toString() {
3909 return "forRelatedValue -> " + procedure;
3917 public void finished(AsyncReadGraph graph) {
3918 checkedProcedure.dec(graph);
3922 public void exception(AsyncReadGraph graph, Throwable t) {
3923 checkedProcedure.exception(graph, t);
3931 public <T> void forRelatedValue(Resource subject, Resource relation,
3932 SyncProcedure<T> procedure) {
3933 forRelatedValue(subject, relation, new SyncToAsyncProcedure<T>(
3938 public <T> void forRelatedValue(Resource subject, Resource relation,
3939 Procedure<T> procedure) {
3940 forRelatedValue(subject, relation, new NoneToAsyncProcedure<T>(
3945 public <T> void forRelatedValue(Resource subject, Resource relation,
3946 Binding binding, AsyncListener<T> listener) {
3947 asyncRequest(new RelatedValue<T>(subject, relation, binding), listener);
3951 public <T> void forRelatedValue(Resource subject, Resource relation,
3952 Binding binding, SyncListener<T> listener) {
3953 asyncRequest(new RelatedValue<T>(subject, relation, binding), listener);
3957 public <T> void forRelatedValue(Resource subject, Resource relation,
3958 Binding binding, Listener<T> listener) {
3959 asyncRequest(new RelatedValue<T>(subject, relation, binding), listener);
3963 final public <T> void forRelatedValue(final Resource subject,
3964 final Resource relation, final Binding binding,
3965 final AsyncProcedure<T> procedure) {
3967 assert (subject != null);
3968 assert (relation != null);
3969 assert (binding != null);
3970 assert (procedure != null);
3972 final DeepSingleOrErrorProcedure<T> checkedProcedure = new DeepSingleOrErrorProcedure<T>(procedure);
3974 processor.forEachObject(this, subject, relation,
3975 new AsyncMultiProcedureAdapter<Resource>() {
3978 public void execute(AsyncReadGraph graph,
3979 final Resource object) {
3981 checkedProcedure.inc();
3983 graph.forValue(object, binding, new AsyncProcedure<Object>() {
3986 public void execute(AsyncReadGraph graph,
3989 checkedProcedure.offer(graph,
3991 checkedProcedure.dec(graph);
3995 public void exception(AsyncReadGraph graph,
3997 checkedProcedure.exception(graph, t);
4001 public String toString() {
4002 return "forRelatedValue -> "
4011 public void finished(AsyncReadGraph graph) {
4012 checkedProcedure.dec(graph);
4016 public void exception(AsyncReadGraph graph, Throwable t) {
4017 checkedProcedure.exception(graph, t);
4025 public <T> void forRelatedValue(Resource subject, Resource relation,
4026 Binding binding, SyncProcedure<T> procedure) {
4027 forRelatedValue(subject, relation, binding,
4028 new SyncToAsyncProcedure<T>(procedure));
4032 public <T> void forRelatedValue(Resource subject, Resource relation,
4033 Binding binding, Procedure<T> procedure) {
4034 forRelatedValue(subject, relation, binding,
4035 new NoneToAsyncProcedure<T>(procedure));
4039 public <T> void forAdapted(Resource resource, Class<T> clazz,
4040 AsyncListener<T> listener) {
4041 asyncRequest(new Adapter<T>(resource, clazz), listener);
4045 public <T> void forAdapted(Resource resource, Class<T> clazz,
4046 SyncListener<T> listener) {
4047 asyncRequest(new Adapter<T>(resource, clazz), listener);
4051 public <T> void forAdapted(Resource resource, Class<T> clazz,
4052 Listener<T> listener) {
4053 asyncRequest(new Adapter<T>(resource, clazz), listener);
4057 final public <T> void forAdapted(final Resource resource,
4058 final Class<T> clazz, final AsyncProcedure<T> procedure) {
4060 assert (resource != null);
4061 assert (clazz != null);
4062 assert (procedure != null);
4064 final AdaptionService service = getSession().peekService(AdaptionService.class);
4065 if (service == null)
4066 procedure.exception(this, new ServiceException("No AdaptionService available"));
4068 service.adapt(this, resource, resource, Resource.class, clazz, false, procedure);
4073 public <T> void forAdapted(Resource resource, Class<T> clazz,
4074 SyncProcedure<T> procedure) {
4075 forAdapted(resource, clazz, new SyncToAsyncProcedure<T>(procedure));
4079 public <T> void forAdapted(Resource resource, Class<T> clazz,
4080 Procedure<T> procedure) {
4081 forAdapted(resource, clazz, new NoneToAsyncProcedure<T>(procedure));
4085 public <T> void forUniqueAdapted(Resource resource, Class<T> clazz,
4086 AsyncListener<T> listener) {
4087 asyncRequest(new UniqueAdapter<T>(resource, clazz), listener);
4091 public <T> void forUniqueAdapted(Resource resource, Class<T> clazz,
4092 SyncListener<T> listener) {
4093 asyncRequest(new UniqueAdapter<T>(resource, clazz), listener);
4097 public <T> void forUniqueAdapted(Resource resource, Class<T> clazz,
4098 Listener<T> listener) {
4099 asyncRequest(new UniqueAdapter<T>(resource, clazz), listener);
4103 final public <T> void forUniqueAdapted(final Resource resource,
4104 final Class<T> clazz, final AsyncProcedure<T> procedure) {
4106 assert (resource != null);
4107 assert (clazz != null);
4108 assert (procedure != null);
4110 final AdaptionService service = getSession().peekService(AdaptionService.class);
4111 if (service == null)
4112 procedure.exception(this, new ServiceException("No AdaptionService available"));
4114 service.adaptNew(this, resource, clazz, false, procedure);
4119 public <T> void forUniqueAdapted(Resource resource, Class<T> clazz,
4120 SyncProcedure<T> procedure) {
4121 forUniqueAdapted(resource, clazz,
4122 new SyncToAsyncProcedure<T>(procedure));
4126 public <T> void forUniqueAdapted(Resource resource, Class<T> clazz,
4127 Procedure<T> procedure) {
4128 forUniqueAdapted(resource, clazz,
4129 new NoneToAsyncProcedure<T>(procedure));
4133 public void forPossibleInverse(Resource subject,
4134 AsyncListener<Resource> listener) {
4135 asyncRequest(new PossibleInverse(subject), listener);
4139 public void forPossibleInverse(Resource subject,
4140 SyncListener<Resource> listener) {
4141 asyncRequest(new PossibleInverse(subject), listener);
4145 public void forPossibleInverse(Resource subject, Listener<Resource> listener) {
4146 asyncRequest(new PossibleInverse(subject), listener);
4150 final public void forPossibleInverse(final Resource relation,
4151 final AsyncProcedure<Resource> procedure) {
4153 assert (relation != null);
4154 assert (procedure != null);
4156 processor.forInverse(this, relation, new ExceptionToNullProcedure<Resource>(procedure));
4161 public void forPossibleInverse(Resource subject,
4162 SyncProcedure<Resource> procedure) {
4163 forPossibleInverse(subject, new SyncToAsyncProcedure<Resource>(
4168 public void forPossibleInverse(Resource subject,
4169 Procedure<Resource> procedure) {
4170 forPossibleInverse(subject, new NoneToAsyncProcedure<Resource>(
4175 public void forPossibleObject(Resource subject, Resource relation,
4176 AsyncListener<Resource> listener) {
4177 asyncRequest(new PossibleObject(subject, relation), listener);
4181 public void forPossibleObject(Resource subject, Resource relation,
4182 SyncListener<Resource> listener) {
4183 asyncRequest(new PossibleObject(subject, relation), listener);
4187 public void forPossibleObject(Resource subject, Resource relation,
4188 Listener<Resource> listener) {
4189 asyncRequest(new PossibleObject(subject, relation), listener);
4193 final public void forPossibleObject(final Resource subject,
4194 final Resource relation, final AsyncProcedure<Resource> procedure) {
4196 assert (subject != null);
4197 assert (relation != null);
4198 assert (procedure != null);
4200 processor.forEachObject(this, subject, relation,
4201 new SingleOrNullProcedure<Resource>(procedure));
4206 public void forPossibleObject(Resource subject, Resource relation,
4207 SyncProcedure<Resource> procedure) {
4208 forPossibleObject(subject, relation,
4209 new SyncToAsyncProcedure<Resource>(procedure));
4213 public void forPossibleObject(Resource subject, Resource relation,
4214 Procedure<Resource> procedure) {
4215 forPossibleObject(subject, relation,
4216 new NoneToAsyncProcedure<Resource>(procedure));
4220 public void forPossibleStatement(Resource subject, Resource relation,
4221 AsyncListener<Statement> listener) {
4222 asyncRequest(new PossibleStatement(subject, relation), listener);
4226 public void forPossibleStatement(Resource subject, Resource relation,
4227 SyncListener<Statement> listener) {
4228 asyncRequest(new PossibleStatement(subject, relation), listener);
4232 public void forPossibleStatement(Resource subject, Resource relation,
4233 Listener<Statement> listener) {
4234 asyncRequest(new PossibleStatement(subject, relation), listener);
4238 final public void forPossibleStatement(final Resource subject,
4239 final Resource relation, final AsyncProcedure<Statement> procedure) {
4241 assert (subject != null);
4242 assert (relation != null);
4243 assert (procedure != null);
4245 processor.forEachStatement(this, subject, relation,
4246 new SingleFunctionalOrNullProcedure<Statement>(
4247 "forPossibleStatement", procedure));
4252 public void forPossibleStatement(Resource subject, Resource relation,
4253 SyncProcedure<Statement> procedure) {
4254 forPossibleStatement(subject, relation,
4255 new SyncToAsyncProcedure<Statement>(procedure));
4259 public void forPossibleStatement(Resource subject, Resource relation,
4260 Procedure<Statement> procedure) {
4261 forPossibleStatement(subject, relation,
4262 new NoneToAsyncProcedure<Statement>(procedure));
4266 public void forPossibleType(Resource subject, Resource relation,
4267 AsyncListener<Resource> listener) {
4268 asyncRequest(new PossibleType(subject, relation), listener);
4272 public void forPossibleType(Resource subject, Resource relation,
4273 SyncListener<Resource> listener) {
4274 asyncRequest(new PossibleType(subject, relation), listener);
4278 public void forPossibleType(Resource subject, Resource relation,
4279 Listener<Resource> listener) {
4280 asyncRequest(new PossibleType(subject, relation), listener);
4284 final public void forPossibleType(final Resource subject,
4285 final Resource baseType, final AsyncProcedure<Resource> procedure) {
4287 assert (subject != null);
4288 assert (procedure != null);
4290 final NullSingleOrNullProcedure<Resource> checkedProcedure = new NullSingleOrNullProcedure<Resource>(procedure);
4292 processor.forEachPrincipalType(this, subject, new AsyncMultiProcedureAdapter<Resource>() {
4295 public void execute(AsyncReadGraph graph,
4296 final Resource principalType) {
4298 if (baseType == null) {
4300 checkedProcedure.offer(graph, principalType);
4302 } else if (principalType.equals(baseType)) {
4304 checkedProcedure.offer(graph, principalType);
4308 checkedProcedure.inc();
4310 processor.forSupertypes((ReadGraphImpl)graph, principalType,
4311 new AsyncProcedure<Set<Resource>>() {
4314 public void execute(
4315 AsyncReadGraph graph,
4316 Set<Resource> result) {
4318 if (result.contains(baseType)) {
4319 checkedProcedure.offer(graph,
4323 checkedProcedure.dec(graph);
4328 public void exception(
4329 AsyncReadGraph graph,
4331 checkedProcedure.exception(graph, t);
4332 checkedProcedure.dec(graph);
4336 public String toString() {
4337 return "forPossibleType -> "
4348 public void finished(AsyncReadGraph graph) {
4349 checkedProcedure.dec(graph);
4353 public void exception(AsyncReadGraph graph, Throwable t) {
4354 checkedProcedure.exception(graph, t);
4355 checkedProcedure.dec(graph);
4363 public void forPossibleType(Resource subject, Resource relation,
4364 SyncProcedure<Resource> procedure) {
4365 forPossibleType(subject, relation, new SyncToAsyncProcedure<Resource>(
4370 public void forPossibleType(Resource subject, Resource relation,
4371 Procedure<Resource> procedure) {
4372 forPossibleType(subject, relation, new NoneToAsyncProcedure<Resource>(
4377 public <T> void forPossibleValue(Resource subject, AsyncListener<T> listener) {
4378 asyncRequest(new PossibleValueImplied<T>(subject), listener);
4382 public <T> void forPossibleValue(Resource subject, SyncListener<T> listener) {
4383 asyncRequest(new PossibleValueImplied<T>(subject), listener);
4387 public <T> void forPossibleValue(Resource subject, Listener<T> listener) {
4388 asyncRequest(new PossibleValueImplied<T>(subject), listener);
4392 final public <T> void forPossibleValue(final Resource subject,
4393 final AsyncProcedure<T> procedure) {
4395 assert (subject != null);
4396 assert (procedure != null);
4398 forPossibleRelatedValue(subject, processor.getL0(this).HasDataType, DATA_TYPE_BINDING_INTERNAL, new AsyncProcedure<Datatype>() {
4401 public void execute(AsyncReadGraph graph, final Datatype type) {
4403 procedure.execute(graph, null);
4406 // TODO: consider trying Bindings.getBeanBinding(type);
4407 Binding binding = Bindings.getBinding(type);
4408 graph.forPossibleValue(subject, binding, procedure);
4409 } catch (RuntimeBindingConstructionException e) {
4410 procedure.exception(graph, e);
4416 public void exception(AsyncReadGraph graph, Throwable t) {
4417 procedure.exception(graph, t);
4421 public String toString() {
4422 return "forPossibleValue -> " + procedure;
4430 public <T> void forPossibleValue(Resource subject,
4431 SyncProcedure<T> procedure) {
4432 forPossibleValue(subject, new SyncToAsyncProcedure<T>(procedure));
4436 public <T> void forPossibleValue(Resource subject, Procedure<T> procedure) {
4437 forPossibleValue(subject, new NoneToAsyncProcedure<T>(procedure));
4441 public <T> void forPossibleValue(Resource subject, Binding binding,
4442 AsyncListener<T> listener) {
4443 asyncRequest(new PossibleValue<T>(subject, binding), listener);
4447 public <T> void forPossibleValue(Resource subject, Binding binding,
4448 SyncListener<T> listener) {
4449 asyncRequest(new PossibleValue<T>(subject, binding), listener);
4453 public <T> void forPossibleValue(Resource subject, Binding binding,
4454 Listener<T> listener) {
4455 asyncRequest(new PossibleValue<T>(subject, binding), listener);
4459 final public <T> void forPossibleValue(final Resource resource,
4460 final Binding binding, final AsyncProcedure<T> procedure) {
4462 assert (resource != null);
4463 assert (binding != null);
4464 assert (procedure != null);
4466 processor.forValue(this, resource, new AsyncProcedure<byte[]>() {
4469 public void execute(AsyncReadGraph graph, byte[] result) {
4473 if (result == null) {
4474 procedure.execute(graph, null);
4478 Serializer serializer = Bindings.getSerializer( binding );
4479 Object obj = serializer.deserialize(result);
4480 if (!binding.isInstance(obj))
4481 procedure.exception(graph, new ClassCastException(
4482 "Cannot get value " + obj + " with binding "
4485 procedure.execute(graph, (T) obj);
4487 } catch (IOException e) {
4488 procedure.exception(graph, e);
4489 } catch (BufferUnderflowException e) {
4490 procedure.exception(graph, e);
4491 } catch (Throwable t) {
4492 procedure.exception(graph, t);
4498 public void exception(AsyncReadGraph graph, Throwable t) {
4500 procedure.exception(graph, t);
4501 } catch (Throwable t2) {
4502 Logger.defaultLogError(t2);
4507 public String toString() {
4508 return "forPossibleValue -> " + procedure;
4516 public <T> void forPossibleValue(Resource subject, Binding binding,
4517 SyncProcedure<T> procedure) {
4518 forPossibleValue(subject, binding, new SyncToAsyncProcedure<T>(
4523 public <T> void forPossibleValue(Resource subject, Binding binding,
4524 Procedure<T> procedure) {
4525 forPossibleValue(subject, binding, new NoneToAsyncProcedure<T>(
4530 public <T> void forPossibleRelatedValue(Resource subject,
4531 Resource relation, AsyncListener<T> listener) {
4532 asyncRequest(new PossibleRelatedValueImplied<T>(subject, relation),
4537 public <T> void forPossibleRelatedValue(Resource subject,
4538 Resource relation, SyncListener<T> listener) {
4539 asyncRequest(new PossibleRelatedValueImplied<T>(subject, relation),
4544 public <T> void forPossibleRelatedValue(Resource subject,
4545 Resource relation, Listener<T> listener) {
4546 asyncRequest(new PossibleRelatedValueImplied<T>(subject, relation),
4551 final public <T> void forPossibleRelatedValue(final Resource subject,
4552 final Resource relation, final AsyncProcedure<T> procedure) {
4554 assert (subject != null);
4555 assert (relation != null);
4556 assert (procedure != null);
4558 final DeepSingleOrNullProcedure<T> checkedProcedure = new DeepSingleOrNullProcedure<T>(procedure);
4560 processor.forEachObject(this, subject, relation,
4561 new AsyncMultiProcedureAdapter<Resource>() {
4564 public void execute(AsyncReadGraph graph,
4565 final Resource object) {
4567 checkedProcedure.inc();
4569 graph.forValue(object, new AsyncProcedure<Object>() {
4572 public void execute(AsyncReadGraph graph,
4574 checkedProcedure.offer(graph, (T) result);
4575 checkedProcedure.dec(graph);
4579 public void exception(AsyncReadGraph graph,
4581 checkedProcedure.exception(graph, t);
4582 checkedProcedure.dec(graph);
4590 public void finished(AsyncReadGraph graph) {
4592 checkedProcedure.dec(graph);
4596 public void exception(AsyncReadGraph graph, Throwable t) {
4597 checkedProcedure.exception(graph, t);
4598 checkedProcedure.dec(graph);
4602 public String toString() {
4603 return "forPossibleRelatedValue -> " + procedure;
4610 public <T> void forPossibleRelatedValue(Resource subject,
4611 Resource relation, SyncProcedure<T> procedure) {
4612 forPossibleRelatedValue(subject, relation, new SyncToAsyncProcedure<T>(
4617 public <T> void forPossibleRelatedValue(Resource subject,
4618 Resource relation, Procedure<T> procedure) {
4619 forPossibleRelatedValue(subject, relation, new NoneToAsyncProcedure<T>(
4624 public <T> void forPossibleRelatedValue(Resource subject,
4625 Resource relation, Binding binding, AsyncListener<T> listener) {
4626 asyncRequest(new PossibleRelatedValue<T>(subject, relation, binding),
4631 public <T> void forPossibleRelatedValue(Resource subject,
4632 Resource relation, Binding binding, SyncListener<T> listener) {
4633 asyncRequest(new PossibleRelatedValue<T>(subject, relation, binding),
4638 public <T> void forPossibleRelatedValue(Resource subject,
4639 Resource relation, Binding binding, Listener<T> listener) {
4640 asyncRequest(new PossibleRelatedValue<T>(subject, relation, binding),
4645 // final public <T> void forPossibleRelatedValue(final Resource subject, final Resource relation, final Binding binding,
4646 // final AsyncProcedure<T> procedure) {
4648 // forPossibleRelatedValue(subject, relation, binding, procedure, false);
4652 final public <T> void forPossibleRelatedValue(final Resource subject, final Resource relation, final Binding binding,
4653 final AsyncProcedure<T> procedure) {
4655 assert (subject != null);
4656 assert (relation != null);
4657 assert (procedure != null);
4659 processor.forPossibleObject(this, subject, relation, new AsyncProcedure<Resource>() {
4662 public void execute(AsyncReadGraph graph, Resource object) {
4664 if(object == null) {
4665 procedure.execute(graph, null);
4669 processor.forPossibleValue((ReadGraphImpl)graph, object, new AsyncProcedure<byte[]>() {
4672 public void execute(AsyncReadGraph graph, byte[] bytes) {
4678 Serializer serializer = binding.serializer();
4679 Object obj = serializer.deserialize(bytes);
4680 if (!binding.isInstance(obj)) {
4681 procedure.exception(graph, new ClassCastException("Cannot get value " + obj + " with binding " + binding));
4683 procedure.execute(graph, (T) obj);
4686 } catch (Throwable t) {
4688 procedure.exception(graph, t);
4694 procedure.execute(graph, null);
4701 public void exception(AsyncReadGraph graph, Throwable t) {
4702 procedure.exception(graph, t);
4710 public void exception(AsyncReadGraph graph, Throwable throwable) {
4711 throwable.printStackTrace();
4712 procedure.exception(graph, throwable);
4720 public <T> void forPossibleRelatedValue(Resource subject,
4721 Resource relation, Binding binding, SyncProcedure<T> procedure) {
4722 forPossibleRelatedValue(subject, relation, binding,
4723 new SyncToAsyncProcedure<T>(procedure));
4727 public <T> void forPossibleRelatedValue(Resource subject,
4728 Resource relation, Binding binding, Procedure<T> procedure) {
4729 forPossibleRelatedValue(subject, relation, binding,
4730 new NoneToAsyncProcedure<T>(procedure));
4734 public void forIsInstanceOf(Resource subject, Resource relation,
4735 AsyncListener<Boolean> listener) {
4736 asyncRequest(new IsInstanceOf(subject, relation), listener);
4740 public void forIsInstanceOf(Resource subject, Resource relation,
4741 SyncListener<Boolean> listener) {
4742 asyncRequest(new IsInstanceOf(subject, relation), listener);
4746 public void forIsInstanceOf(Resource subject, Resource relation,
4747 Listener<Boolean> listener) {
4748 asyncRequest(new IsInstanceOf(subject, relation), listener);
4752 final public void forIsInstanceOf(final Resource resource,
4753 final Resource type, final AsyncProcedure<Boolean> procedure) {
4755 assert (resource != null);
4756 assert (type != null);
4757 assert (procedure != null);
4759 forTypes(resource, new AsyncProcedure<Set<Resource>>() {
4762 public void execute(AsyncReadGraph graph, Set<Resource> result) {
4765 if (result.contains(type))
4766 procedure.execute(graph, true);
4768 procedure.execute(graph, false);
4769 } catch (Throwable t) {
4770 Logger.defaultLogError(t);
4775 public void exception(AsyncReadGraph graph, Throwable t) {
4777 procedure.exception(graph, t);
4778 } catch (Throwable t2) {
4779 Logger.defaultLogError(t2);
4784 public String toString() {
4785 return "forIsInstanceOf -> " + procedure;
4793 public void forIsInstanceOf(Resource subject, Resource relation,
4794 SyncProcedure<Boolean> procedure) {
4795 forIsInstanceOf(subject, relation, new SyncToAsyncProcedure<Boolean>(
4800 public void forIsInstanceOf(Resource subject, Resource relation,
4801 Procedure<Boolean> procedure) {
4802 forIsInstanceOf(subject, relation, new NoneToAsyncProcedure<Boolean>(
4807 public void forIsInheritedFrom(Resource subject, Resource relation,
4808 AsyncListener<Boolean> listener) {
4809 asyncRequest(new IsInheritedFrom(subject, relation), listener);
4813 public void forIsInheritedFrom(Resource subject, Resource relation,
4814 SyncListener<Boolean> listener) {
4815 asyncRequest(new IsInheritedFrom(subject, relation), listener);
4819 public void forIsInheritedFrom(Resource subject, Resource relation,
4820 Listener<Boolean> listener) {
4821 asyncRequest(new IsInheritedFrom(subject, relation), listener);
4825 final public void forIsInheritedFrom(final Resource resource,
4826 final Resource type, final AsyncProcedure<Boolean> procedure) {
4828 assert (resource != null);
4829 assert (type != null);
4830 assert (procedure != null);
4832 if (resource.equals(type)) {
4834 procedure.execute(this, true);
4835 } catch (Throwable t) {
4836 Logger.defaultLogError(t);
4841 forSupertypes(resource, new AsyncProcedure<Set<Resource>>() {
4844 public void execute(AsyncReadGraph graph, Set<Resource> result) {
4846 if (result.contains(type))
4847 procedure.execute(graph, true);
4849 procedure.execute(graph, false);
4850 } catch (Throwable t) {
4851 Logger.defaultLogError(t);
4856 public void exception(AsyncReadGraph graph, Throwable t) {
4858 procedure.exception(graph, t);
4859 } catch (Throwable t2) {
4860 Logger.defaultLogError(t2);
4865 public String toString() {
4866 return "forIsInheritedFrom -> " + procedure;
4874 public void forIsInheritedFrom(Resource subject, Resource relation,
4875 SyncProcedure<Boolean> procedure) {
4876 forIsInheritedFrom(subject, relation,
4877 new SyncToAsyncProcedure<Boolean>(procedure));
4881 public void forIsInheritedFrom(Resource subject, Resource relation,
4882 Procedure<Boolean> procedure) {
4883 forIsInheritedFrom(subject, relation,
4884 new NoneToAsyncProcedure<Boolean>(procedure));
4888 public void forIsSubrelationOf(Resource subject, Resource relation,
4889 AsyncListener<Boolean> listener) {
4890 asyncRequest(new IsSubrelationOf(subject, relation), listener);
4894 public void forIsSubrelationOf(Resource subject, Resource relation,
4895 SyncListener<Boolean> listener) {
4896 asyncRequest(new IsSubrelationOf(subject, relation), listener);
4900 public void forIsSubrelationOf(Resource subject, Resource relation,
4901 Listener<Boolean> listener) {
4902 asyncRequest(new IsSubrelationOf(subject, relation), listener);
4906 final public void forIsSubrelationOf(final Resource resource,
4907 final Resource relation, final AsyncProcedure<Boolean> procedure) {
4909 assert (resource != null);
4910 assert (relation != null);
4911 assert (procedure != null);
4913 if (resource.equals(relation)) {
4914 procedure.execute(this, true);
4918 forSuperrelations(resource, new AsyncProcedure<Set<Resource>>() {
4921 public void execute(AsyncReadGraph graph, Set<Resource> result) {
4923 if (result.contains(relation))
4924 procedure.execute(graph, true);
4926 procedure.execute(graph, false);
4927 } catch (Throwable t) {
4928 Logger.defaultLogError(t);
4933 public void exception(AsyncReadGraph graph, Throwable t) {
4935 procedure.exception(graph, t);
4936 } catch (Throwable t2) {
4937 Logger.defaultLogError(t2);
4942 public String toString() {
4943 return "forIsSubrelationOf -> " + procedure;
4951 public void forIsSubrelationOf(Resource subject, Resource relation,
4952 SyncProcedure<Boolean> procedure) {
4953 forIsSubrelationOf(subject, relation,
4954 new SyncToAsyncProcedure<Boolean>(procedure));
4958 public void forIsSubrelationOf(Resource subject, Resource relation,
4959 Procedure<Boolean> procedure) {
4960 forIsSubrelationOf(subject, relation,
4961 new NoneToAsyncProcedure<Boolean>(procedure));
4965 public void forHasStatement(Resource subject,
4966 AsyncListener<Boolean> listener) {
4967 asyncRequest(new HasStatementSubject(subject), listener);
4971 public void forHasStatement(Resource subject, SyncListener<Boolean> listener) {
4972 asyncRequest(new HasStatementSubject(subject), listener);
4976 public void forHasStatement(Resource subject, Listener<Boolean> listener) {
4977 asyncRequest(new HasStatementSubject(subject), listener);
4981 final public void forHasStatement(final Resource subject,
4982 final AsyncProcedure<Boolean> procedure) {
4984 assert (subject != null);
4985 assert (procedure != null);
4987 processor.forHasStatement(this, subject, procedure);
4992 public void forHasStatement(Resource subject,
4993 SyncProcedure<Boolean> procedure) {
4994 forHasStatement(subject, new SyncToAsyncProcedure<Boolean>(procedure));
4998 public void forHasStatement(Resource subject, Procedure<Boolean> procedure) {
4999 forHasStatement(subject, new NoneToAsyncProcedure<Boolean>(procedure));
5003 public void forHasStatement(Resource subject, Resource relation,
5004 AsyncListener<Boolean> listener) {
5005 asyncRequest(new HasStatement(subject, relation), listener);
5009 public void forHasStatement(Resource subject, Resource relation,
5010 SyncListener<Boolean> listener) {
5011 asyncRequest(new HasStatement(subject, relation), listener);
5015 public void forHasStatement(Resource subject, Resource relation,
5016 Listener<Boolean> listener) {
5017 asyncRequest(new HasStatement(subject, relation), listener);
5021 final public void forHasStatement(final Resource subject,
5022 final Resource relation, final AsyncProcedure<Boolean> procedure) {
5024 assert (subject != null);
5025 assert (relation != null);
5026 assert (procedure != null);
5028 processor.forHasStatement(this, subject, relation, procedure);
5033 public void forHasStatement(Resource subject, Resource relation,
5034 SyncProcedure<Boolean> procedure) {
5035 forHasStatement(subject, relation, new SyncToAsyncProcedure<Boolean>(
5040 public void forHasStatement(Resource subject, Resource relation,
5041 Procedure<Boolean> procedure) {
5042 forHasStatement(subject, relation, new NoneToAsyncProcedure<Boolean>(
5047 public void forHasStatement(Resource subject, Resource relation,
5048 Resource object, AsyncListener<Boolean> listener) {
5049 asyncRequest(new HasStatementSubjectObject(subject, relation, object),
5054 public void forHasStatement(Resource subject, Resource relation,
5055 Resource object, SyncListener<Boolean> listener) {
5056 asyncRequest(new HasStatementSubjectObject(subject, relation, object),
5061 public void forHasStatement(Resource subject, Resource relation,
5062 Resource object, Listener<Boolean> listener) {
5063 asyncRequest(new HasStatementSubjectObject(subject, relation, object),
5068 final public void forHasStatement(final Resource subject,
5069 final Resource relation, final Resource object,
5070 final AsyncProcedure<Boolean> procedure) {
5072 assert (subject != null);
5073 assert (relation != null);
5074 assert (object != null);
5075 assert (procedure != null);
5077 processor.forHasStatement(this, subject, relation, object, procedure);
5082 public void forHasStatement(Resource subject, Resource relation,
5083 Resource object, SyncProcedure<Boolean> procedure) {
5084 forHasStatement(subject, relation, object,
5085 new SyncToAsyncProcedure<Boolean>(procedure));
5089 public void forHasStatement(Resource subject, Resource relation,
5090 Resource object, Procedure<Boolean> procedure) {
5091 forHasStatement(subject, relation, object,
5092 new NoneToAsyncProcedure<Boolean>(procedure));
5096 public void forHasValue(Resource subject, AsyncListener<Boolean> listener) {
5097 asyncRequest(new HasValue(subject), listener);
5101 public void forHasValue(Resource subject, SyncListener<Boolean> listener) {
5102 asyncRequest(new HasValue(subject), listener);
5106 public void forHasValue(Resource subject, Listener<Boolean> listener) {
5107 asyncRequest(new HasValue(subject), listener);
5111 final public void forHasValue(final Resource subject,
5112 final AsyncProcedure<Boolean> procedure) {
5114 assert (subject != null);
5115 assert (procedure != null);
5117 processor.forValue(this, subject, new AsyncProcedure<byte[]>() {
5120 public void execute(AsyncReadGraph graph, byte[] result) {
5123 procedure.execute(graph, false);
5125 procedure.execute(graph, true);
5126 } catch (Throwable t) {
5127 Logger.defaultLogError(t);
5132 public void exception(AsyncReadGraph graph, Throwable t) {
5134 procedure.exception(graph, t);
5135 } catch (Throwable t2) {
5136 Logger.defaultLogError(t2);
5141 public String toString() {
5142 return "forHasValue -> " + procedure;
5150 public void forHasValue(Resource subject, SyncProcedure<Boolean> procedure) {
5151 forHasValue(subject, new SyncToAsyncProcedure<Boolean>(procedure));
5155 public void forHasValue(Resource subject, Procedure<Boolean> procedure) {
5156 forHasValue(subject, new NoneToAsyncProcedure<Boolean>(procedure));
5160 public void forOrderedSet(Resource subject,
5161 AsyncMultiListener<Resource> listener) {
5162 asyncRequest(new OrderedSet(subject), listener);
5166 public void forOrderedSet(Resource subject,
5167 SyncMultiListener<Resource> listener) {
5168 asyncRequest(new OrderedSet(subject), listener);
5172 public void forOrderedSet(Resource subject, MultiListener<Resource> listener) {
5173 asyncRequest(new OrderedSet(subject), listener);
5177 final public void forOrderedSet(final Resource subject,
5178 final AsyncMultiProcedure<Resource> procedure) {
5180 assert (subject != null);
5181 assert (procedure != null);
5183 processor.forOrderedSet(this, subject,
5184 new AsyncMultiProcedure<Resource>() {
5187 public void finished(AsyncReadGraph graph) {
5189 procedure.finished(graph);
5190 } catch (Throwable t) {
5191 Logger.defaultLogError(t);
5196 public void execute(AsyncReadGraph graph, Resource result) {
5198 procedure.execute(graph, result);
5199 } catch (Throwable t) {
5200 Logger.defaultLogError(t);
5205 public void exception(AsyncReadGraph graph, Throwable t) {
5207 procedure.exception(graph, t);
5208 } catch (Throwable t2) {
5209 Logger.defaultLogError(t2);
5214 public String toString() {
5215 return "forOrderedSet -> " + procedure;
5223 public void forOrderedSet(Resource subject,
5224 SyncMultiProcedure<Resource> procedure) {
5225 forOrderedSet(subject, new SyncToAsyncMultiProcedure<Resource>(
5230 public void forOrderedSet(Resource subject,
5231 MultiProcedure<Resource> procedure) {
5232 forOrderedSet(subject, new NoneToAsyncMultiProcedure<Resource>(
5237 public <T> void forPossibleAdapted(Resource resource, Class<T> clazz,
5238 AsyncListener<T> listener) {
5239 asyncRequest(new PossibleAdapter<T>(resource, clazz), listener);
5243 public <T> void forPossibleAdapted(Resource resource, Class<T> clazz,
5244 SyncListener<T> listener) {
5245 asyncRequest(new PossibleAdapter<T>(resource, clazz), listener);
5249 public <T> void forPossibleAdapted(Resource resource, Class<T> clazz,
5250 Listener<T> listener) {
5251 asyncRequest(new PossibleAdapter<T>(resource, clazz), listener);
5255 final public <T> void forPossibleAdapted(final Resource resource,
5256 final Class<T> clazz, final AsyncProcedure<T> procedure) {
5258 assert (resource != null);
5259 assert (clazz != null);
5260 assert (procedure != null);
5262 final AdaptionService service = getSession().peekService(AdaptionService.class);
5263 if (service == null)
5264 procedure.exception(this, new ServiceException("No AdaptionService available"));
5266 service.adapt(this, resource, resource, Resource.class, clazz, true, procedure);
5270 public <T> void forPossibleAdapted(Resource resource, Class<T> clazz,
5271 SyncProcedure<T> procedure) {
5272 forPossibleAdapted(resource, clazz, new SyncToAsyncProcedure<T>(
5277 public <T> void forPossibleAdapted(Resource resource, Class<T> clazz,
5278 Procedure<T> procedure) {
5279 forPossibleAdapted(resource, clazz, new NoneToAsyncProcedure<T>(
5284 public <T> void forPossibleUniqueAdapted(Resource resource, Class<T> clazz,
5285 AsyncListener<T> listener) {
5286 asyncRequest(new PossibleUniqueAdapter<T>(resource, clazz), listener);
5290 public <T> void forPossibleUniqueAdapted(Resource resource, Class<T> clazz,
5291 SyncListener<T> listener) {
5292 asyncRequest(new PossibleUniqueAdapter<T>(resource, clazz), listener);
5296 public <T> void forPossibleUniqueAdapted(Resource resource, Class<T> clazz,
5297 Listener<T> listener) {
5298 asyncRequest(new PossibleUniqueAdapter<T>(resource, clazz), listener);
5302 final public <T> void forPossibleUniqueAdapted(final Resource resource,
5303 final Class<T> clazz, final AsyncProcedure<T> procedure) {
5305 assert (resource != null);
5306 assert (clazz != null);
5307 assert (procedure != null);
5309 final AdaptionService service = getSession().peekService(AdaptionService.class);
5310 if (service == null)
5311 procedure.exception(this, new ServiceException("No AdaptionService available"));
5313 service.adaptNew(this, resource, clazz, true, procedure);
5318 public <T> void forPossibleUniqueAdapted(Resource resource, Class<T> clazz,
5319 SyncProcedure<T> procedure) {
5320 forPossibleUniqueAdapted(resource, clazz, new SyncToAsyncProcedure<T>(
5325 public <T> void forPossibleUniqueAdapted(Resource resource, Class<T> clazz,
5326 Procedure<T> procedure) {
5327 forPossibleUniqueAdapted(resource, clazz, new NoneToAsyncProcedure<T>(
5332 * Implementation of the interface AsyncRequestProcessor
5336 final public Session getSession() {
5337 return processor.getSession();
5341 // final public Builtins getBuiltins() {
5342 // return processor.getSession().getBuiltins();
5346 public <T> void asyncRequest(final Read<T> request) {
5348 asyncRequest(request, new AsyncProcedure<T>() {
5351 public void execute(AsyncReadGraph graph, T result) {
5355 public void exception(AsyncReadGraph graph, Throwable t) {
5356 Logger.defaultLogError(t);
5360 public String toString() {
5361 return "asyncRequest(Read) -> " + request;
5369 public <T> void asyncRequest(Read<T> request, AsyncListener<T> procedure) {
5370 asyncRequest(request, (AsyncProcedure<T>) procedure);
5374 public <T> void asyncRequest(Read<T> request,
5375 final SyncListener<T> procedure) {
5376 asyncRequest(request, new SyncToAsyncListener<T>(procedure));
5380 public <T> void asyncRequest(Read<T> request, final Listener<T> procedure) {
5381 asyncRequest(request, new NoneToAsyncListener<T>(procedure));
5385 public <T> void asyncRequest(final Read<T> request, final AsyncProcedure<T> procedure) {
5387 assert (request != null);
5388 assert (procedure != null);
5390 final ListenerBase listener = getListenerBase(procedure);
5392 if (parent != null || listener != null) {
5395 QueryCache.runnerReadEntry(this, request, parent, listener, procedure);
5396 //processor.query(this, request, parent, procedure,listener);
5397 } catch (DatabaseException e) {
5398 Logger.defaultLogError(e);
5399 // This throwable has already been transferred to procedure at this point - do nothing about it
5405 // final ReadGraphImpl newGraph = newSync();
5409 T result = request.perform(this);
5412 procedure.execute(this, result);
5413 } catch (Throwable t) {
5414 Logger.defaultLogError(t);
5417 } catch (Throwable t) {
5420 procedure.exception(this, t);
5421 } catch (Throwable t2) {
5422 Logger.defaultLogError(t2);
5433 public static ReadGraphImpl createAsync(QueryProcessor support) {
5434 return new ReadGraphImpl(null, support);
5437 public static ReadGraphImpl forRecompute(CacheEntry entry, QueryProcessor support) {
5438 return new ReadGraphImpl(entry, support);
5442 public <T> void asyncRequest(Read<T> request, SyncProcedure<T> procedure) {
5443 asyncRequest(request, new SyncToAsyncProcedure<T>(procedure));
5447 public <T> void asyncRequest(Read<T> request, final Procedure<T> procedure) {
5448 asyncRequest(request, new NoneToAsyncProcedure<T>(procedure));
5452 final public <T> void asyncRequest(final AsyncRead<T> request) {
5454 assert (request != null);
5456 asyncRequest(request, new AsyncProcedure<T>() {
5459 public void execute(AsyncReadGraph graph, T result) {
5463 public void exception(AsyncReadGraph graph, Throwable t) {
5464 Logger.defaultLogError(t);
5468 public String toString() {
5469 return "asyncRequest(AsyncRead) -> " + request;
5477 public <T> void asyncRequest(AsyncRead<T> request,
5478 AsyncListener<T> procedure) {
5479 asyncRequest(request, (AsyncProcedure<T>) procedure);
5483 final public <T> void asyncRequest(AsyncRead<T> request,
5484 final SyncListener<T> procedure) {
5485 asyncRequest(request, new SyncToAsyncListener<T>(procedure));
5489 final public <T> void asyncRequest(AsyncRead<T> request,
5490 final Listener<T> procedure) {
5491 asyncRequest(request, new NoneToAsyncListener<T>(procedure));
5495 final public <T> void asyncRequest(final AsyncRead<T> request,
5496 final AsyncProcedure<T> procedure) {
5498 assert (request != null);
5499 assert (procedure != null);
5501 final ListenerBase listener = getListenerBase(procedure);
5503 if (parent != null || listener != null) {
5506 QueryCache.runnerAsyncReadEntry(this, request, parent, listener, procedure);
5507 //processor.query(this, request, parent, procedure, listener);
5508 } catch (DatabaseException e) {
5509 Logger.defaultLogError(e);
5516 request.perform(this, new CallWrappedSingleQueryProcedure4<T>(procedure, request));
5518 } catch (Throwable t) {
5520 if (t instanceof DatabaseException)
5521 procedure.exception(this, t);
5526 new DatabaseException(
5527 "Unexpected exception in ReadGraph.asyncRequest(SingleAsyncRead, SingleProcedure)",
5537 public <T> void asyncRequest(AsyncRead<T> request,
5538 SyncProcedure<T> procedure) {
5539 asyncRequest(request, new SyncToAsyncProcedure<T>(procedure));
5543 final public <T> void asyncRequest(final AsyncRead<T> request,
5544 final Procedure<T> procedure) {
5545 asyncRequest(request, new NoneToAsyncProcedure<T>(procedure));
5549 public <T> void asyncRequest(final MultiRead<T> request) {
5551 assert (request != null);
5553 asyncRequest(request, new AsyncMultiProcedureAdapter<T>() {
5555 public void exception(AsyncReadGraph graph, Throwable t) {
5556 Logger.defaultLogError(t);
5560 public String toString() {
5561 return "asyncRequest(MultiRead) -> " + request;
5568 public <T> void asyncRequest(MultiRead<T> request,
5569 AsyncMultiListener<T> procedure) {
5570 asyncRequest(request, (AsyncMultiProcedure<T>) procedure);
5574 public <T> void asyncRequest(MultiRead<T> request,
5575 SyncMultiListener<T> procedure) {
5576 asyncRequest(request, new SyncToAsyncMultiListener<T>(procedure));
5580 public <T> void asyncRequest(MultiRead<T> request,
5581 MultiListener<T> procedure) {
5582 asyncRequest(request, new NoneToAsyncMultiListener<T>(procedure));
5586 public <T> void asyncRequest(final MultiRead<T> request,
5587 final AsyncMultiProcedure<T> procedure) {
5589 assert (request != null);
5590 assert (procedure != null);
5592 final ListenerBase listener = getListenerBase(procedure);
5594 if (parent != null || listener != null) {
5596 // final ReadGraphImpl newGraph = newSync();
5597 processor.query(this, request, parent, procedure,listener);
5601 // final ReadGraphImpl newGraph = newSync();
5605 request.perform(this, procedure);
5607 } catch (Throwable t) {
5609 procedure.exception(this, t);
5618 public <T> void asyncRequest(MultiRead<T> request,
5619 SyncMultiProcedure<T> procedure) {
5620 asyncRequest(request, new SyncToAsyncMultiProcedure<T>(procedure));
5624 public <T> void asyncRequest(MultiRead<T> request,
5625 MultiProcedure<T> procedure) {
5626 asyncRequest(request, new NoneToAsyncMultiProcedure<T>(procedure));
5630 final public <T> void asyncRequest(final AsyncMultiRead<T> request) {
5632 assert (request != null);
5634 asyncRequest(request, new AsyncMultiProcedureAdapter<T>() {
5636 public void exception(AsyncReadGraph graph, Throwable t) {
5637 Logger.defaultLogError(t);
5641 public String toString() {
5642 return "asyncRequest(AsyncMultiRead) -> " + request;
5649 public <T> void asyncRequest(AsyncMultiRead<T> request,
5650 AsyncMultiListener<T> procedure) {
5651 asyncRequest(request, (AsyncMultiProcedure<T>) procedure);
5655 public <T> void asyncRequest(AsyncMultiRead<T> request,
5656 SyncMultiListener<T> procedure) {
5657 asyncRequest(request, new SyncToAsyncMultiListener<T>(procedure));
5661 public <T> void asyncRequest(AsyncMultiRead<T> request,
5662 MultiListener<T> procedure) {
5663 asyncRequest(request, new NoneToAsyncMultiListener<T>(procedure));
5667 final public <T> void asyncRequest(AsyncMultiRead<T> request,
5668 final AsyncMultiProcedure<T> procedure) {
5670 assert (request != null);
5671 assert (procedure != null);
5673 ListenerBase listener = getListenerBase(procedure);
5675 if (parent != null || listener != null) {
5677 processor.query(this, request, parent, procedure, listener);
5683 request.perform(this, new AsyncMultiProcedure<T>() {
5686 public void execute(AsyncReadGraph graph, T result) {
5687 procedure.execute(graph, result);
5691 public void finished(AsyncReadGraph graph) {
5692 procedure.finished(graph);
5696 public void exception(AsyncReadGraph graph, Throwable t) {
5697 procedure.exception(graph, t);
5701 public String toString() {
5702 return "asyncRequest(AsyncMultiRead) -> " + procedure;
5707 } catch (Throwable t) {
5709 procedure.exception(this, new DatabaseException(t));
5717 public <T> void asyncRequest(AsyncMultiRead<T> request,
5718 SyncMultiProcedure<T> procedure) {
5719 asyncRequest(request, new SyncToAsyncMultiProcedure<T>(procedure));
5723 final public <T> void asyncRequest(AsyncMultiRead<T> request,
5724 final MultiProcedure<T> procedure) {
5725 asyncRequest(request, new NoneToAsyncMultiProcedure<T>(procedure));
5729 final public <T> void asyncRequest(final ExternalRead<T> request) {
5731 assert (request != null);
5733 asyncRequest(request, new Procedure<T>() {
5736 public void execute(T result) {
5740 public void exception(Throwable t) {
5741 Logger.defaultLogError(t);
5745 public String toString() {
5746 return "asyncRequest(PrimitiveRead) -> " + request;
5754 public <T> void asyncRequest(ExternalRead<T> request,
5755 final Listener<T> procedure) {
5756 asyncRequest(request, (Procedure<T>) procedure);
5760 final public <T> void asyncRequest(final ExternalRead<T> request,
5761 final Procedure<T> procedure) {
5763 assert (request != null);
5764 assert (procedure != null);
5766 ListenerBase listener = getListenerBase(procedure);
5768 if (parent != null || listener != null) {
5770 processor.query(this, request, parent, procedure, listener);
5776 request.register(this, new Listener<T>() {
5779 public void execute(T result) {
5780 procedure.execute(result);
5784 public void exception(Throwable t) {
5785 procedure.exception(t);
5789 public String toString() {
5790 return "asyncRequest(PrimitiveRead) -> " + request;
5794 public boolean isDisposed() {
5800 } catch (Throwable t) {
5802 if (t instanceof DatabaseException)
5803 procedure.exception(t);
5806 .exception(new DatabaseException(
5807 "Unexpected exception in ReadGraph.asyncRequest(SingleAsyncRead, SingleProcedure)",
5817 public void asyncRequest(final Write request) {
5819 assert (request != null);
5821 getSession().asyncRequest(request);
5823 // processor.asyncWrite(request);
5828 public <T> void asyncRequest(final WriteResult<T> request, Procedure<T> procedure) {
5829 throw new Error("Not implemented.");
5833 public void asyncRequest(Write request, Consumer<DatabaseException> callback) {
5835 assert (request != null);
5837 getSession().asyncRequest(request, callback);
5842 public void asyncRequest(final DelayedWrite request) {
5844 assert (request != null);
5846 getSession().asyncRequest(request);
5851 public <T> void asyncRequest(final DelayedWriteResult<T> request, Procedure<T> procedure) {
5852 throw new Error("Not implemented.");
5856 public void asyncRequest(DelayedWrite r,
5857 Consumer<DatabaseException> callback) {
5858 throw new Error("Not implemented.");
5862 public void asyncRequest(final WriteOnly request) {
5864 assert (request != null);
5866 getSession().asyncRequest(request);
5871 public <T> void asyncRequest(final WriteOnlyResult<T> request, Procedure<T> procedure) {
5872 throw new Error("Not implemented.");
5876 public void asyncRequest(WriteOnly r, Consumer<DatabaseException> callback) {
5877 throw new Error("Not implemented.");
5881 * Implementation of the interface ServiceLocator
5885 public <T> T getService(Class<T> api) {
5886 if(WriteSupport.class == api) {
5887 if(this instanceof WriteGraphImpl) {
5888 WriteGraphImpl impl = (WriteGraphImpl)this;
5889 return (T)impl.writeSupport;
5892 return getSession().getService(api);
5896 public <T> T peekService(Class<T> api) {
5897 return getSession().peekService(api);
5901 public boolean hasService(Class<?> api) {
5902 return getSession().hasService(api);
5906 public <T> void registerService(Class<T> api, T service) {
5907 getSession().registerService(api, service);
5911 public boolean isImmutable(Resource resource) throws DatabaseException {
5912 ResourceImpl impl = (ResourceImpl)resource;
5913 return processor.isImmutable(impl.id);
5920 protected static String INTERNAL_ERROR_STRING = "Transaction aborted due to internal client error. Contact application support.";
5923 * callerThread is the currently running thread state.syncThread is blocking for
5924 * this execution state.syncParent is the blocking request
5927 final private boolean isExternal(int thread) {
5928 return thread == Integer.MIN_VALUE;
5931 // final private boolean isSync(int thread) {
5932 // return thread < -1 && thread > Integer.MIN_VALUE;
5935 ReadGraphImpl(ReadGraphImpl graph) {
5936 this(graph.parent, graph.processor);
5939 ReadGraphImpl(CacheEntry parent, QueryProcessor support) {
5940 // this.state = new ReadGraphState(barrier, support);
5941 this.parent = parent;
5942 this.processor = support;
5945 ReadGraphImpl(final QueryProcessor support) {
5947 // this.state = state;
5948 this.processor = support;
5953 // public static ReadGraphImpl createSync(int syncThread, Object syncParent,
5954 // ReadGraphSupportImpl support) {
5955 // return new ReadGraphImpl(syncThread, syncThread, syncParent, null,
5956 // support, new AsyncBarrierImpl(null));
5959 public static ReadGraphImpl create(QueryProcessor support) {
5960 return new ReadGraphImpl(support);
5963 // public ReadGraphImpl newAsync() {
5965 //// if(!state.synchronizedExecution) {
5968 //// return new ReadGraphImpl(false, parent, state.support, state.barrier);
5972 // public ReadGraphImpl newSync() {
5973 // return new ReadGraphImpl(parent, processor);
5976 public ReadGraphImpl newSync(CacheEntry parentEntry) {
5977 return new ReadGraphImpl(parentEntry, processor);
5980 public ReadGraphImpl newRestart(ReadGraphImpl impl) {
5982 WriteGraphImpl write = processor.getSession().getService(
5983 WriteGraphImpl.class);
5985 // if (write.callerThread != impl.callerThread)
5986 // return new WriteGraphImpl(impl.callerThread, parent, state.support, write.writeSupport, write.provider, write.state.barrier);
5991 // public ReadGraphImpl newSync(Object parentRequest) {
5992 // return new ReadGraphImpl(callerThread, state.parent, state.support, new AsyncBarrierImpl(state.barrier));
5995 // public ReadGraphImpl newSync(final int callerThread, Object parentRequest) {
5996 // assert (state.syncThread == callerThread || (state.syncThread == Integer.MIN_VALUE && callerThread != Integer.MIN_VALUE));
5997 // return new ReadGraphImpl(callerThread, callerThread, parentRequest,
5998 // state.parent, state.support, new AsyncBarrierImpl(state.barrier));
6001 // public ReadGraphImpl newSyncAsync(Object parentRequest) {
6002 //// assert (callerThread < 0);
6003 // return new ReadGraphImpl(callerThread, state.syncThread, parentRequest,
6004 // state.parent, state.support, new AsyncBarrierImpl(state.barrier));
6007 // public ReadGraphImpl newSyncAsync(final int callerThread,
6008 // Object parentRequest) {
6009 //// assert (callerThread < 0);
6010 // // assert(state.syncThread == callerThread || (state.syncThread == Integer.MIN_VALUE
6011 // // && callerThread != Integer.MIN_VALUE) );
6012 // return new ReadGraphImpl(callerThread, callerThread, parentRequest,
6013 // state.parent, state.support, new AsyncBarrierImpl(state.barrier));
6016 public ReadGraphImpl withAsyncParent(CacheEntry parent) {
6017 return new ReadGraphImpl(parent, processor);
6020 public ReadGraphImpl withParent(CacheEntry parent) {
6021 if(parent == this.parent) return this;
6022 else return new ReadGraphImpl(parent, processor);
6025 final private ListenerBase getListenerBase(final Object procedure) {
6026 if (procedure instanceof ListenerBase)
6027 return (ListenerBase) procedure;
6032 public <T> void waitAsyncProcedure(AsyncMultiReadProcedure<T> procedure) {
6034 assert(procedure.done());
6036 // while (!procedure.done()) {
6038 // boolean executed = processor.resumeTasks(callerThread, null, null);
6042 // // sema.tryAcquire(1, TimeUnit.MILLISECONDS);
6043 // } catch (InterruptedException e) {
6044 // e.printStackTrace();
6052 public <T> void waitAsyncProcedure(AsyncReadProcedure<T> procedure) {
6054 assert(procedure.done());
6056 // while (!procedure.done()) {
6058 // boolean executed = processor.processor.resume(this);
6062 // // sema.tryAcquire(1, TimeUnit.MILLISECONDS);
6063 // } catch (InterruptedException e) {
6064 // e.printStackTrace();
6072 // public void waitAsync(Object request) {
6074 // state.barrier.waitBarrier(request, this);
6075 // } catch (Throwable t) {
6076 // t.printStackTrace();
6077 // processor.scanPending();
6078 // processor.querySupport.checkTasks();
6079 // throw new RuntimeDatabaseException(t);
6083 // public void restart() {
6084 // state.barrier.restart();
6087 public boolean resumeTasks() {
6088 return processor.resumeTasks(this);
6091 Class<?> singleClass(Set<Resource> types) {
6092 Class<?> result = null;
6093 for (Resource type : types) {
6094 Class<?> clazz = processor.getBuiltinValue(type);
6095 if (clazz != null) {
6105 private String debugString(Resource r) {
6108 name = getPossibleRelatedValue(r, processor.getL0(this).HasName);
6109 } catch (ManyObjectsForFunctionalRelationException e) {
6110 Logger.defaultLogError(e);
6111 } catch (ServiceException e) {
6112 Logger.defaultLogError(e);
6114 return "[" + name + " - " + r + "]";
6118 public String toString() {
6119 return "ReadGraphImpl[thread=" + Thread.currentThread() + "]";
6123 final public int thread() {
6127 static class MultiTripleIntProcedure implements TripleIntProcedure {
6129 final private AsyncMultiProcedure<Statement> procedure;
6130 final private ReadGraphImpl impl;
6131 final private QuerySupport support;
6133 public MultiTripleIntProcedure(AsyncMultiProcedure<Statement> procedure, ReadGraphImpl impl, QuerySupport support) {
6134 this.procedure = procedure;
6136 this.support = support;
6140 public void execute(ReadGraphImpl graph, int s, int p, int o) {
6142 procedure.execute(graph, support.getStatement(s, p, o));
6143 } catch (Throwable t2) {
6144 Logger.defaultLogError(t2);
6149 public void finished(ReadGraphImpl graph) {
6151 procedure.finished(graph);
6152 // impl.state.barrier.dec("ReadGraphSupportImpl.516");
6153 } catch (Throwable t2) {
6154 Logger.defaultLogError(t2);
6159 public void exception(ReadGraphImpl graph, Throwable t) {
6161 procedure.exception(graph, t);
6162 } catch (Throwable t2) {
6163 Logger.defaultLogError(t2);
6165 // impl.state.barrier.dec("ReadGraphSupportImpl.516");
6169 public String toString() {
6170 return "forEachObject with " + procedure;
6175 // private AsyncMultiProcedure<Resource> cacheKey = null;
6176 // private MultiIntProcedure cacheResult = null;
6178 // final IntProcedure forMultiProcedure(final AsyncMultiProcedure<Resource> procedure) {
6180 // if(procedure == cacheKey) return cacheResult;
6182 // cacheResult = new MultiIntProcedure(procedure, this, processor.support);
6183 // cacheKey = procedure;
6185 // return cacheResult;
6189 // private AsyncMultiProcedure<Statement> cacheKey2 = null;
6190 // private MultiTripleIntProcedure cacheResult2 = null;
6192 // final synchronized TripleIntProcedure forMultiProcedure(final AsyncMultiProcedure<Statement> procedure) {
6194 // if(procedure == cacheKey2) return cacheResult2;
6196 // cacheResult2 = new MultiTripleIntProcedure(procedure, this, processor.support);
6197 // cacheKey2 = procedure;
6199 // return cacheResult2;
6204 public Datatype getDataType(Resource subject) throws DatabaseException {
6205 for(Resource dataTypeResource : getObjects(subject, processor.getL0(this).HasDataType))
6206 return getValue(dataTypeResource, Bindings.getBindingUnchecked(Datatype.class));
6207 throw new DoesNotContainValueException("The literal has no data type.");
6210 protected <T extends Accessor> T getAccessor4File(Resource subject)
6211 throws DatabaseException {
6214 byte[] bytes = processor.support.getValue(g, subject);
6218 BinaryVariant va = (BinaryVariant) Accessors.getAccessor(bytes, Datatypes.VARIANT);
6219 Accessor ca = va.getContentAccessor();
6221 } catch (AccessorConstructionException e) {
6222 throw new DatabaseException(e);
6228 Binding datatype_binding = Bindings.getBindingUnchecked(DataType.class);
6229 Serializer datatype_serializer = datatype_binding.serializer();
6232 BinaryMemory in = new BinaryMemory(ByteBuffer.wrap(bytes));
6233 datatype = (DataType)datatype_serializer.deserialize(in);
6234 Binding data_binding = Bindings.getBinding(datatype);
6235 Serializer data_serializer = data_binding.serializer(BinarySerializationFormat.INSTANCE);
6236 Object o = data_serializer.deserialize(in);
6238 return (T)Accessors.getAccessor(data_binding, o);
6239 } catch(AccessorConstructionException e) {
6242 } catch (Exception e) {
6243 throw new DatabaseException(e);
6246 @SuppressWarnings("unchecked")
6248 public <T extends Accessor> T getAccessor(Resource subject) throws DatabaseException {
6249 RandomAccessBinary rab = getRandomAccessBinary(subject);
6251 return (T)Accessors.getAccessor(rab, getDataType(subject));
6252 } catch(AccessorConstructionException e) {
6253 throw new DatabaseException(e);
6256 @SuppressWarnings("unchecked")
6257 protected <T extends Accessor> T createAccessor(Resource resource, Datatype datatype, Object intialValue)
6258 throws DatabaseException {
6259 RandomAccessBinary rab = createRandomAccessBinary(resource, datatype, intialValue);
6261 return (T)Accessors.getAccessor(rab, datatype);
6262 } catch(AccessorConstructionException e) {
6263 throw new DatabaseException(e);
6267 public RandomAccessBinary getRandomAccessBinary(Resource subject) throws DatabaseException {
6268 RandomAccessValueSupport ravs = getSession().getService(RandomAccessValueSupport.class);
6269 ResourceData rd = ravs.get(subject);
6273 ExternalValueSupport evs = getService(ExternalValueSupport.class);
6274 long size = evs.getValueSize(this, subject); // Throws DatabaseException if no old external value.
6276 File platform = Platform.getLocation().toFile();
6277 File tempFiles = new File(platform, "tempFiles");
6278 File dbDir = new File(tempFiles, "db");
6280 File file = new File(dbDir, "ResourceFile" + subject.getResourceId());
6281 rd = new ResourceData(new BinaryFile(file), true); // Old external value.
6282 final int N = 1<<20;
6286 int length = N < left ? N : (int)left;
6287 byte[] bytes = evs.readValue(this, subject, offset, length);
6288 offset += bytes.length;
6289 left -= bytes.length;
6290 rd.binaryFile.write(bytes);
6292 ravs.put(subject, rd);
6294 } catch (Exception e) {
6295 throw new DatabaseException("Resource " + subject + " have value but there was problem with accessing value data.", e);
6297 } catch (Exception e) {
6298 if(Development.DEVELOPMENT) {
6299 if(Development.<Boolean>getProperty(DevelopmentKeys.WRITEGRAPH_EXCEPTION_STACKTRACES, Bindings.BOOLEAN)) {
6300 e.printStackTrace();
6304 Datatype datatype = getDataType(subject);
6305 Object value = getPossibleValue(subject, Bindings.getBinding(datatype));
6306 return createRandomAccessBinary(subject, datatype, value);
6308 public RandomAccessBinary createRandomAccessBinary(Resource resource, Datatype datatype, Object initialValue)
6309 throws DatabaseException {
6310 RandomAccessValueSupport ravs = getSession().getService(RandomAccessValueSupport.class);
6312 File platform = Platform.getLocation().toFile();
6313 File tempFiles = new File(platform, "tempFiles");
6314 File dbDir = new File(tempFiles, "db");
6316 File file = new File(dbDir, "ResourceFile" + resource.getResourceId());
6317 ResourceData rd = new ResourceData(new BinaryFile(file), false);
6318 Binding binding = Bindings.getBinding(datatype);
6319 if (null == initialValue) {
6320 initialValue = binding.createDefault();
6322 Serializer serializer = binding.serializer();
6323 byte[] bytes = serializer.serialize(initialValue);
6324 rd.binaryFile.write(bytes);
6325 ravs.put(resource, rd);
6327 } catch (Exception e) {
6328 if (e instanceof DatabaseException)
6329 throw (DatabaseException)e;
6331 throw new DatabaseException(e);
6335 // static class ExternalValueRequest<T> extends ResourceRead<T> {
6337 // public ExternalValueRequest(Resource resource) {
6341 // @SuppressWarnings("unchecked")
6343 // public T perform(ReadGraph graph) throws DatabaseException {
6346 // String uri = graph.getURI(resource);
6347 // if(Layer0.URIs.Functions_functionApplication.equals(uri)) return (T)functionApplication;
6349 // return (T)ReflectionUtils.getValue(uri).getValue();
6351 // } catch(ValueNotFoundException e) {
6352 // throw new DatabaseException("Couldn't convert to external value (r=" + resource + ")", e);
6353 // } catch(ClassCastException e) {
6354 // throw new DatabaseException("Couldn't convert to external value (r=" + resource + ")", e);
6360 @SuppressWarnings("unchecked")
6362 public <T> T getValue2(Resource r, Object context) throws DatabaseException {
6363 Layer0 L0 = processor.getL0(this);
6364 Set<Resource> types = getTypes(r);
6366 if(types.contains(L0.Literal)) {
6367 if(isImmutable(r)) {
6368 return syncRequest(new ValueImplied<T>(r));
6373 else if(types.contains(L0.ExternalValue)) {
6374 return (T)syncRequest(new AdaptValue(r), TransientCacheListener.<Object>instance());
6378 Function3<ReadGraph,Resource,Object,T> function = requestValueFunction(r);
6379 if(function == null) throw new DoesNotContainValueException("Couldn't convert to a value function " + r);
6381 return function.apply(this, r, context);
6382 } catch(RuntimeException e) {
6383 DatabaseException dte = findPossibleRootException(e);
6384 if(dte != null) throw dte;
6385 else throw new DatabaseException(e);
6392 public Variant getVariantValue2(Resource r, Object context) throws DatabaseException {
6393 Layer0 L0 = processor.getL0(this);
6394 Set<Resource> types = getTypes(r);
6396 if(types.contains(L0.Literal)) {
6397 if(isImmutable(r)) {
6398 return syncRequest(new VariantValueImplied(r));
6400 return getVariantValue(r);
6403 else if(types.contains(L0.ExternalValue)) {
6404 Object value = syncRequest(new AdaptValue(r), TransientCacheListener.<Object>instance());
6406 return new Variant(Bindings.OBJECT.getContentBinding(value), value);
6407 } catch ( org.simantics.databoard.binding.error.BindingException e ) {
6408 throw new BindingException( "No binding found for class " + value.getClass().getName(), e );
6413 Function3<ReadGraph,Resource,Object,Object> function = requestValueFunction(r);
6414 if(function == null) throw new DoesNotContainValueException("Couldn't convert to a value function " + r);
6416 Object value = function.apply(this, r, context);
6418 return new Variant(Bindings.OBJECT.getContentBinding(value), value);
6419 } catch ( org.simantics.databoard.binding.error.BindingException e ) {
6420 throw new BindingException( "No binding found for class " + value.getClass().getName(), e );
6422 } catch(RuntimeException e) {
6423 DatabaseException dte = findPossibleRootException(e);
6424 if(dte != null) throw dte;
6425 else throw new DatabaseException(e);
6431 public <T> T getPossibleValue2(Resource subject, Object context) throws DatabaseException {
6433 return getValue2(subject, context);
6434 } catch (DatabaseException e) {
6439 static class PossibleConverterFunction<T> extends ResourceRead<Function3<ReadGraph,Resource,Object,T>> {
6441 public PossibleConverterFunction(Resource resource) {
6446 public Function3<ReadGraph,Resource,Object,T> perform(ReadGraph graph) throws DatabaseException {
6447 return compute(graph, resource);
6450 @SuppressWarnings("unchecked")
6451 public static <T> Function3<ReadGraph,Resource,Object,T> compute(ReadGraph graph, Resource resource) throws DatabaseException {
6452 Layer0 L0 = Layer0.getInstance(graph);
6453 for(Resource converter : graph.getObjects(resource, L0.ConvertsToValueWith)) {
6455 if(L0.Functions_functionApplication.equals(converter)) {
6456 return (Function3<ReadGraph,Resource,Object,T>)graph.syncRequest(new AdaptValue(resource));
6458 return graph.getValue2(converter, resource);
6460 } catch(RuntimeException e) {
6461 DatabaseException dte = findPossibleRootException(e);
6462 if(dte != null) throw dte;
6463 else throw new DatabaseException(e);
6471 <T> Function3<ReadGraph,Resource,Object,T> requestValueFunction(Resource r) throws DatabaseException {
6473 return syncRequest(new PossibleConverterFunction<T>(r), TransientCacheAsyncListener.<Function3<ReadGraph,Resource,Object,T>>instance());
6475 return syncRequest(new PossibleConverterFunction<T>(r));
6479 * Get a value associated with a graph {@link Resource}, using a possible context object and
6480 * a desired value binding. The following methods are tried in order to retreive the value:
6482 * <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>
6483 * <li>If the resource is a {@code L0.ExternalValue}, the value is acquired using
6484 * {@link ReflectionUtils#getValue(String)}.</li>
6485 * <li>If the resource is associated with a suitable value converter with relation {@code L0.ConvertsToValueWith}
6486 * (see {@link #requestValueFunction(Resource)}), the value function is called with the graph, the resource
6487 * and the context object.</li>
6490 * @param r A graph resource with which the value is associated
6491 * @param context A context object that is used for acquiring the value (only applied in case 3)
6492 * @param binding A binding for the value type (only applied in case 1)
6493 * @return The value of the graph node.
6494 * @throws DoesNotContainValueException No value is associated with the graph node.
6495 * @throws DatabaseException Other errors, such as an error in casting the value to the return type or
6496 * a runtime error in the value function.
6498 @SuppressWarnings("unchecked")
6500 public <T> T getValue2(Resource r, Object context, Binding binding) throws DatabaseException {
6501 if (binding instanceof ObjectVariantBinding)
6502 return getValue2(r, context);
6504 Layer0 L0 = processor.getL0(this);
6505 Set<Resource> types = getTypes(r);
6506 if(types.contains(L0.Literal)) {
6507 if(isImmutable(r)) {
6508 return syncRequest(new Value<T>(r, binding));
6510 return getValue(r, binding);
6512 } else if(types.contains(L0.ExternalValue)) {
6514 return (T)ReflectionUtils.getValue(getURI(r)).getValue();
6515 } catch(ValueNotFoundException e) {
6516 throw new DatabaseException(e);
6517 } catch(ClassCastException e) {
6518 throw new DatabaseException(e);
6522 Function3<ReadGraph,Resource,Object,T> function = requestValueFunction(r);
6523 if(function == null) throw new DoesNotContainValueException("Couldn't convert to a value function.");
6525 Object value = function.apply(this, r, context);
6526 if(binding.isInstance(value)) return (T)value;
6527 Binding srcBinding = Bindings.OBJECT.getContentBinding(value);
6528 return (T)Bindings.adapt(value, srcBinding, binding);
6529 } catch(RuntimeException e) {
6530 DatabaseException dte = findPossibleRootException(e);
6531 if(dte != null) throw dte;
6532 else throw new DatabaseException(e);
6533 } catch (AdaptException e) {
6534 throw new DatabaseException(e);
6535 } catch (org.simantics.databoard.binding.error.BindingException e) {
6536 throw new DatabaseException(e);
6542 public <T> T getPossibleValue2(Resource subject, Object context, Binding binding) throws DatabaseException {
6544 return getValue2(subject, context, binding);
6545 } catch (DatabaseException e) {
6550 private static DatabaseException findPossibleRootException(Throwable t) {
6551 if(t == null) return null;
6552 if(t instanceof DatabaseException) return (DatabaseException)t;
6553 if(t instanceof RuntimeException || t instanceof InvocationTargetException) {
6554 return findPossibleRootException(t.getCause());
6560 public <T> T getRelatedValue2(Resource subject, Resource relation) throws DatabaseException {
6561 return getRelatedValue2(subject, relation, subject);
6565 public Variant getRelatedVariantValue2(Resource subject, Resource relation) throws DatabaseException {
6566 return getRelatedVariantValue2(subject, relation, subject);
6570 public <T> T getPossibleRelatedValue2(Resource subject, Resource relation) throws DatabaseException {
6572 Resource object = getPossibleObject(subject, relation);
6573 if(object == null) return null;
6574 else return getValue2(object, subject);
6575 } catch (DatabaseException e) {
6581 public <T> T getRelatedValue2(Resource subject, Resource relation, Object context) throws DatabaseException {
6582 if(Development.DEVELOPMENT) {
6583 String error = L0Validations.checkValueType(this, subject, relation);
6585 Logger.defaultLogError(new ValidationException(error));
6586 //throw new ValidationException(error);
6587 new ValidationException(error).printStackTrace();
6590 return getValue2(getSingleObject(subject, relation), context);
6594 public Variant getRelatedVariantValue2(Resource subject, Resource relation, Object context) throws DatabaseException {
6595 if(Development.DEVELOPMENT) {
6596 String error = L0Validations.checkValueType(this, subject, relation);
6598 Logger.defaultLogError(new ValidationException(error));
6599 //throw new ValidationException(error);
6600 new ValidationException(error).printStackTrace();
6603 return getVariantValue2(getSingleObject(subject, relation), context);
6607 public <T> T getPossibleRelatedValue2(Resource subject, Resource relation, Object context) throws DatabaseException {
6609 Resource object = getPossibleObject(subject, relation);
6610 if(object == null) return null;
6611 else return getValue2(object, context);
6612 } catch (DatabaseException e) {
6618 public <T> T getRelatedValue2(Resource subject, Resource relation, Binding binding) throws DatabaseException {
6619 return getRelatedValue2(subject, relation, subject, binding);
6623 public <T> T getPossibleRelatedValue2(Resource subject, Resource relation, Binding binding) throws DatabaseException {
6625 Resource object = getPossibleObject(subject, relation);
6626 if(object == null) return null;
6627 return getValue2(object, subject, binding);
6628 } catch (DatabaseException e) {
6634 public <T> T getRelatedValue2(Resource subject, Resource relation, Object context, Binding binding) throws DatabaseException {
6635 return getValue2(getSingleObject(subject, relation), context, binding);
6639 public <T> T getPossibleRelatedValue2(Resource subject, Resource relation, Object context, Binding binding) throws DatabaseException {
6641 Resource object = getPossibleObject(subject, relation);
6642 if(object == null) return null;
6643 else return getValue2(object, context, binding);
6644 } catch (DatabaseException e) {
6650 public Type getRelatedValueType(Resource subject, Resource relation) throws DatabaseException {
6651 Layer0 L0 = processor.getL0(this);
6652 Resource property = getSingleObject(subject, relation);
6653 String typeText = (String)getRelatedValue(property, L0.HasValueType, Bindings.STRING);
6655 return org.simantics.scl.compiler.types.Types.parseType(typeText);
6656 } catch (SCLTypeParseException e) {
6657 throw new DatabaseException(e);
6662 public boolean setSynchronous(boolean value) {
6663 boolean old = processor.synch;
6664 processor.synch = value;
6669 public boolean getSynchronous() {
6670 return processor.synch;
6673 public void ensureLoaded(int resource) {
6674 processor.querySupport.ensureLoaded(this, resource);
6677 public void ensureLoaded(int resource, int predicate) {
6678 processor.querySupport.ensureLoaded(this, resource, predicate);
6681 public byte[] getValue(int resource) {
6682 return processor.querySupport.getValue(this, resource);
6685 public int thread(int resource) {
6686 return (resource >>> 16) & processor.THREAD_MASK;
6689 public int thread(Resource resource) {
6690 return (((ResourceImpl)resource).id >>> 16) & processor.THREAD_MASK;
6693 public ResourceSupport getResourceSupport() {
6694 return processor.getResourceSupport();
6698 public Object getModificationCounter() {
6699 return processor.getSession().getModificationCounter();