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;
31 import java.util.function.Consumer;
33 import org.eclipse.core.runtime.Platform;
34 import org.simantics.databoard.Accessors;
35 import org.simantics.databoard.Bindings;
36 import org.simantics.databoard.accessor.Accessor;
37 import org.simantics.databoard.accessor.error.AccessorConstructionException;
38 import org.simantics.databoard.adapter.AdaptException;
39 import org.simantics.databoard.binding.Binding;
40 import org.simantics.databoard.binding.error.RuntimeBindingConstructionException;
41 import org.simantics.databoard.binding.impl.ObjectVariantBinding;
42 import org.simantics.databoard.binding.mutable.Variant;
43 import org.simantics.databoard.serialization.Serializer;
44 import org.simantics.databoard.type.Datatype;
45 import org.simantics.databoard.util.binary.BinaryFile;
46 import org.simantics.databoard.util.binary.RandomAccessBinary;
47 import org.simantics.db.AsyncReadGraph;
48 import org.simantics.db.DevelopmentKeys;
49 import org.simantics.db.ExternalValueSupport;
50 import org.simantics.db.ReadGraph;
51 import org.simantics.db.RelationContext;
52 import org.simantics.db.Resource;
53 import org.simantics.db.Session;
54 import org.simantics.db.Statement;
55 import org.simantics.db.adaption.AdaptionService;
56 import org.simantics.db.common.primitiverequest.Adapter;
57 import org.simantics.db.common.primitiverequest.Builtin;
58 import org.simantics.db.common.primitiverequest.DatatypeBinding;
59 import org.simantics.db.common.primitiverequest.ForEachAssertedObject;
60 import org.simantics.db.common.primitiverequest.ForEachAssertedStatement;
61 import org.simantics.db.common.primitiverequest.HasStatement;
62 import org.simantics.db.common.primitiverequest.HasStatementSubject;
63 import org.simantics.db.common.primitiverequest.HasStatementSubjectObject;
64 import org.simantics.db.common.primitiverequest.HasValue;
65 import org.simantics.db.common.primitiverequest.Inverse;
66 import org.simantics.db.common.primitiverequest.IsInheritedFrom;
67 import org.simantics.db.common.primitiverequest.IsInstanceOf;
68 import org.simantics.db.common.primitiverequest.IsSubrelationOf;
69 import org.simantics.db.common.primitiverequest.OrderedSet;
70 import org.simantics.db.common.primitiverequest.PossibleAdapter;
71 import org.simantics.db.common.primitiverequest.PossibleInverse;
72 import org.simantics.db.common.primitiverequest.PossibleObject;
73 import org.simantics.db.common.primitiverequest.PossibleRelatedValue;
74 import org.simantics.db.common.primitiverequest.PossibleRelatedValueImplied;
75 import org.simantics.db.common.primitiverequest.PossibleStatement;
76 import org.simantics.db.common.primitiverequest.PossibleType;
77 import org.simantics.db.common.primitiverequest.PossibleUniqueAdapter;
78 import org.simantics.db.common.primitiverequest.PossibleValue;
79 import org.simantics.db.common.primitiverequest.PossibleValueImplied;
80 import org.simantics.db.common.primitiverequest.RelatedValue;
81 import org.simantics.db.common.primitiverequest.RelatedValueImplied;
82 import org.simantics.db.common.primitiverequest.SingleObject;
83 import org.simantics.db.common.primitiverequest.SingleStatement;
84 import org.simantics.db.common.primitiverequest.SingleType;
85 import org.simantics.db.common.primitiverequest.SingleTypeAny;
86 import org.simantics.db.common.primitiverequest.Types;
87 import org.simantics.db.common.primitiverequest.UniqueAdapter;
88 import org.simantics.db.common.primitiverequest.Value;
89 import org.simantics.db.common.primitiverequest.ValueImplied;
90 import org.simantics.db.common.primitiverequest.VariantValueImplied;
91 import org.simantics.db.common.procedure.BlockingAsyncProcedure;
92 import org.simantics.db.common.procedure.adapter.AsyncMultiProcedureAdapter;
93 import org.simantics.db.common.procedure.adapter.ProcedureAdapter;
94 import org.simantics.db.common.procedure.adapter.TransientCacheAsyncListener;
95 import org.simantics.db.common.procedure.adapter.TransientCacheListener;
96 import org.simantics.db.common.procedure.single.SyncReadProcedure;
97 import org.simantics.db.common.procedure.single.wrapper.DeepSingleOrErrorProcedure;
98 import org.simantics.db.common.procedure.single.wrapper.DeepSingleOrNullProcedure;
99 import org.simantics.db.common.procedure.single.wrapper.ExceptionToNullProcedure;
100 import org.simantics.db.common.procedure.single.wrapper.NullSingleOrNullProcedure;
101 import org.simantics.db.common.procedure.single.wrapper.SingleFunctionalOrNullProcedure;
102 import org.simantics.db.common.procedure.single.wrapper.SingleOrErrorProcedure;
103 import org.simantics.db.common.procedure.single.wrapper.SingleOrNullProcedure;
104 import org.simantics.db.common.procedure.wrapper.NoneToAsyncListener;
105 import org.simantics.db.common.procedure.wrapper.NoneToAsyncMultiListener;
106 import org.simantics.db.common.procedure.wrapper.NoneToAsyncMultiProcedure;
107 import org.simantics.db.common.procedure.wrapper.NoneToAsyncProcedure;
108 import org.simantics.db.common.procedure.wrapper.NoneToAsyncSetProcedure;
109 import org.simantics.db.common.procedure.wrapper.SyncToAsyncListener;
110 import org.simantics.db.common.procedure.wrapper.SyncToAsyncMultiListener;
111 import org.simantics.db.common.procedure.wrapper.SyncToAsyncMultiProcedure;
112 import org.simantics.db.common.procedure.wrapper.SyncToAsyncProcedure;
113 import org.simantics.db.common.procedure.wrapper.SyncToAsyncSetProcedure;
114 import org.simantics.db.common.request.AdaptValue;
115 import org.simantics.db.common.request.ResourceRead;
116 import org.simantics.db.common.utils.Functions;
117 import org.simantics.db.common.utils.Logger;
118 import org.simantics.db.common.utils.NameUtils;
119 import org.simantics.db.common.validation.L0Validations;
120 import org.simantics.db.exception.AdaptionException;
121 import org.simantics.db.exception.ArgumentException;
122 import org.simantics.db.exception.AssumptionException;
123 import org.simantics.db.exception.BindingException;
124 import org.simantics.db.exception.DatabaseException;
125 import org.simantics.db.exception.DoesNotContainValueException;
126 import org.simantics.db.exception.EmptyResourceException;
127 import org.simantics.db.exception.InternalException;
128 import org.simantics.db.exception.InvalidLiteralException;
129 import org.simantics.db.exception.ManyObjectsForFunctionalRelationException;
130 import org.simantics.db.exception.NoInverseException;
131 import org.simantics.db.exception.NoSingleResultException;
132 import org.simantics.db.exception.ResourceNotFoundException;
133 import org.simantics.db.exception.ServiceException;
134 import org.simantics.db.exception.ValidationException;
135 import org.simantics.db.impl.RelationContextImpl;
136 import org.simantics.db.impl.ResourceImpl;
137 import org.simantics.db.impl.internal.RandomAccessValueSupport;
138 import org.simantics.db.impl.internal.ResourceData;
139 import org.simantics.db.impl.procedure.CallWrappedSingleQueryProcedure4;
140 import org.simantics.db.impl.procedure.InternalProcedure;
141 import org.simantics.db.impl.procedure.ResultCallWrappedQueryProcedure4;
142 import org.simantics.db.impl.procedure.ResultCallWrappedSingleQueryProcedure4;
143 import org.simantics.db.impl.query.CacheEntry;
144 import org.simantics.db.impl.query.QueryCache;
145 import org.simantics.db.impl.query.QueryCacheBase;
146 import org.simantics.db.impl.query.QueryProcessor;
147 import org.simantics.db.impl.query.QuerySupport;
148 import org.simantics.db.impl.query.TripleIntProcedure;
149 import org.simantics.db.impl.query.QueryProcessor.SessionTask;
150 import org.simantics.db.impl.support.ResourceSupport;
151 import org.simantics.db.procedure.AsyncListener;
152 import org.simantics.db.procedure.AsyncMultiListener;
153 import org.simantics.db.procedure.AsyncMultiProcedure;
154 import org.simantics.db.procedure.AsyncProcedure;
155 import org.simantics.db.procedure.AsyncSetListener;
156 import org.simantics.db.procedure.Listener;
157 import org.simantics.db.procedure.ListenerBase;
158 import org.simantics.db.procedure.MultiListener;
159 import org.simantics.db.procedure.MultiProcedure;
160 import org.simantics.db.procedure.Procedure;
161 import org.simantics.db.procedure.SetListener;
162 import org.simantics.db.procedure.StatementProcedure;
163 import org.simantics.db.procedure.SyncListener;
164 import org.simantics.db.procedure.SyncMultiListener;
165 import org.simantics.db.procedure.SyncMultiProcedure;
166 import org.simantics.db.procedure.SyncProcedure;
167 import org.simantics.db.procedure.SyncSetListener;
168 import org.simantics.db.request.AsyncMultiRead;
169 import org.simantics.db.request.AsyncRead;
170 import org.simantics.db.request.DelayedWrite;
171 import org.simantics.db.request.DelayedWriteResult;
172 import org.simantics.db.request.ExternalRead;
173 import org.simantics.db.request.MultiRead;
174 import org.simantics.db.request.Read;
175 import org.simantics.db.request.ReadInterface;
176 import org.simantics.db.request.RequestFlags;
177 import org.simantics.db.request.Write;
178 import org.simantics.db.request.WriteInterface;
179 import org.simantics.db.request.WriteOnly;
180 import org.simantics.db.request.WriteOnlyResult;
181 import org.simantics.db.request.WriteResult;
182 import org.simantics.layer0.Layer0;
183 import org.simantics.scl.compiler.types.Type;
184 import org.simantics.scl.compiler.types.exceptions.SCLTypeParseException;
185 import org.simantics.scl.reflection.ReflectionUtils;
186 import org.simantics.scl.reflection.ValueNotFoundException;
187 import org.simantics.scl.runtime.function.Function1;
188 import org.simantics.scl.runtime.function.Function3;
189 import org.simantics.utils.DataContainer;
190 import org.simantics.utils.Development;
191 import org.simantics.utils.datastructures.Pair;
192 import org.simantics.utils.datastructures.collections.CollectionUtils;
194 import gnu.trove.map.hash.TObjectIntHashMap;
196 public class ReadGraphImpl implements ReadGraph {
198 final static boolean EMPTY_RESOURCE_CHECK = false;
200 final public CacheEntry parent;
201 final public QueryProcessor processor;
203 final static Binding DATA_TYPE_BINDING_INTERNAL = Bindings.getBindingUnchecked(Datatype.class);
204 final static Serializer DATA_TYPE_SERIALIZER = Bindings.getSerializerUnchecked(DATA_TYPE_BINDING_INTERNAL);
206 final public static TObjectIntHashMap<String> counters = new TObjectIntHashMap<String>();
208 public static void resetCounters() {
212 public static String listCounters(File file) throws IOException {
214 PrintStream b = new PrintStream(new BufferedOutputStream(new FileOutputStream(file)));
216 for(Pair<String,Integer> p : CollectionUtils.valueSortedEntries(counters)) {
217 b.print(-p.second + " " + p.first + "\n");
222 return "Dumped " + counters.size() + " queries.";
227 * Implementation of the interface ReadGraph
229 final public String getURI(final Resource resource) throws AssumptionException, ValidationException, ServiceException {
231 assert (resource != null);
235 return syncRequest(new org.simantics.db.common.uri.ResourceToURI(resource));
237 } catch (AssumptionException e) {
239 throw new AssumptionException(e);
241 } catch (ValidationException e) {
243 throw new ValidationException(e);
245 } catch (ServiceException e) {
247 throw new ServiceException(e);
249 } catch (DatabaseException e) {
251 throw new ServiceException(INTERNAL_ERROR_STRING, e);
257 final public String getPossibleURI(final Resource resource) throws ValidationException, ServiceException {
259 assert (resource != null);
263 return syncRequest(new org.simantics.db.common.uri.ResourceToPossibleURI(resource));
265 } catch (ValidationException e) {
267 throw new ValidationException(e);
269 } catch (ServiceException e) {
271 throw new ServiceException(e);
273 } catch (DatabaseException e) {
275 throw new ServiceException(INTERNAL_ERROR_STRING, e);
281 final public Resource getResource(final String id)
282 throws ResourceNotFoundException, ValidationException,
289 // assert (id != null);
290 // assert (procedure != null);
292 // processor.forResource(this, id, procedure);
294 //// return syncRequest(new org.simantics.db.common.primitiverequest.Resource(
297 Integer rid = QueryCache.resultURIToResource(this, id, parent, null);
298 if(rid == 0) throw new ResourceNotFoundException(id);
299 return processor.querySupport.getResource(rid);
301 } catch (ResourceNotFoundException e) {
303 throw new ResourceNotFoundException(id, e);
305 } catch (ValidationException e) {
307 throw new ValidationException(e);
309 } catch (ServiceException e) {
311 throw new ServiceException(e);
313 } catch (DatabaseException e) {
315 throw new ServiceException(INTERNAL_ERROR_STRING, e);
321 final public Resource getPossibleResource(final String id)
322 throws ResourceNotFoundException, ValidationException,
329 return getResource(id);
331 // return syncRequest(new org.simantics.db.common.primitiverequest.Resource(
334 } catch (ResourceNotFoundException e) {
338 } catch (ValidationException e) {
340 throw new ValidationException(e);
342 } catch (ServiceException e) {
344 throw new ServiceException(e);
346 } catch (DatabaseException e) {
348 throw new ServiceException(INTERNAL_ERROR_STRING, e);
355 public Map<String, Resource> getChildren(Resource resource) throws ValidationException, ServiceException {
357 assert (resource != null);
361 int rId = processor.querySupport.getId(resource);
362 return QueryCache.resultChildMap(this, rId, parent, null);
364 } catch (ValidationException e) {
366 throw new ValidationException(e);
368 } catch (ServiceException e) {
370 throw new ServiceException(e);
372 } catch (DatabaseException e) {
374 throw new ServiceException(INTERNAL_ERROR_STRING, e);
380 final public Resource getRootLibrary() {
381 return processor.getRootLibraryResource();
384 final public Resource getBuiltin(final String id)
385 throws ResourceNotFoundException, ServiceException {
391 return syncRequest(new Builtin(id));
393 } catch (ResourceNotFoundException e) {
395 throw new ResourceNotFoundException(id, e);
397 } catch (ServiceException e) {
399 throw new ServiceException(e);
401 } catch (DatabaseException e) {
403 throw new ServiceException(INTERNAL_ERROR_STRING, e);
409 static class StatementReadProcedure extends TIntArrayListInternal implements StatementProcedure {
411 private static Throwable DONE = new Throwable();
413 Throwable exception = null;
415 final ResourceSupport support;
417 public StatementReadProcedure(ResourceSupport support) {
418 this.support = support;
422 public synchronized void execute(AsyncReadGraph graph, int s, int p, int o) {
429 public void finished(AsyncReadGraph graph) {
434 public void exception(AsyncReadGraph graph, Throwable t) {
438 public void checkAndThrow() throws DatabaseException {
439 if(exception != DONE) {
440 if (exception instanceof DatabaseException)
441 throw (DatabaseException) exception;
443 throw new DatabaseException(
444 "Unexpected exception in ReadGraph.syncRequest(AsyncMultiRead)",
449 public boolean done() {
450 return exception != null;
454 public boolean contains(Object obj) {
455 if(!(obj instanceof InternalStatement))
457 InternalStatement statement = (InternalStatement)obj;
461 for(int i=0;i<sizeInternal();i+=3)
462 if(s==getQuick(i) && p==getQuick(i+1) && o==getQuick(i+2))
467 @SuppressWarnings("unchecked")
469 public <T> T[] toArray(T[] a) {
470 int length = sizeInternal() / 3;
471 if(length > a.length) {
472 Class<?> arrayType = a.getClass();
473 a = (arrayType == Object[].class)
474 ? (T[]) new Object[length]
475 : (T[]) Array.newInstance(arrayType.getComponentType(), length);
478 for(int i=length;i<a.length;++i)
481 for(int i=0,j=0;i<sizeInternal();i+=3,++j)
482 a[j] = (T)new InternalStatement(support, getQuick(i), getQuick(i+1), getQuick(i+2));
487 public boolean add(Statement e) {
488 throw new UnsupportedOperationException();
492 public boolean remove(Object o) {
493 throw new UnsupportedOperationException();
497 public boolean addAll(Collection<? extends Statement> c) {
498 throw new UnsupportedOperationException();
501 class IteratorImpl implements ListIterator<Statement> {
505 public IteratorImpl(int index) {
510 public boolean hasNext() {
511 return index < sizeInternal();
515 public Statement next() {
516 Statement result = new InternalStatement(support, getQuick(index), getQuick(index+1), getQuick(index+2));
522 public void remove() {
523 throw new Error("Not supported");
527 public boolean hasPrevious() {
532 public Statement previous() {
534 Statement result = new InternalStatement(support, getQuick(index), getQuick(index+1), getQuick(index+2));
539 public int nextIndex() {
544 public int previousIndex() {
549 public void set(Statement e) {
550 throw new UnsupportedOperationException();
554 public void add(Statement e) {
555 throw new UnsupportedOperationException();
561 public Iterator<Statement> iterator() {
562 return new IteratorImpl(0);
567 return sizeInternal() / 3;
571 public Object[] toArray() {
572 Object[] result = new Object[sizeInternal() / 3];
573 for(int i=0,j=0;j<sizeInternal();i++,j+=3)
574 result[i] = new InternalStatement(support, getQuick(j), getQuick(j+1), getQuick(j+2));
579 public boolean addAll(int index, Collection<? extends Statement> c) {
580 throw new UnsupportedOperationException();
584 public Statement get(int index) {
586 if(index < 0 || index >= sizeInternal())
587 throw new IndexOutOfBoundsException();
588 return new InternalStatement(support, getQuick(index), getQuick(index+1), getQuick(index+2));
592 public Statement set(int index, Statement element) {
593 throw new UnsupportedOperationException();
597 public void add(int index, Statement element) {
598 throw new UnsupportedOperationException();
602 public Statement remove(int index) {
603 throw new UnsupportedOperationException();
607 public int indexOf(Object obj) {
608 if(!(obj instanceof InternalStatement))
610 InternalStatement statement = (InternalStatement)obj;
614 for(int i=0;i<sizeInternal();i+=3)
615 if(s==getQuick(i) && p==getQuick(i+1) && o==getQuick(i+2))
621 public int lastIndexOf(Object obj) {
622 if(!(obj instanceof InternalStatement))
624 InternalStatement statement = (InternalStatement)obj;
628 for(int i=sizeInternal()-3;i>=0;i-=3)
629 if(s==getQuick(i) && p==getQuick(i+1) && o==getQuick(i+2))
635 public ListIterator<Statement> listIterator() {
636 return new IteratorImpl(0);
640 public ListIterator<Statement> listIterator(int index) {
641 return new IteratorImpl(index*3);
645 public List<Statement> subList(int fromIndex, int toIndex) {
646 if(fromIndex < 0 || toIndex*3 >= sizeInternal() || fromIndex > toIndex)
647 throw new IndexOutOfBoundsException();
648 return new RandomAccessSubList<Statement>(this, fromIndex, toIndex-fromIndex);
653 final public Collection<Statement> getStatements(final Resource subject,
654 final Resource relation)
655 throws ManyObjectsForFunctionalRelationException, ServiceException {
657 assert (subject != null);
658 assert (relation != null);
662 StatementReadProcedure procedure = new StatementReadProcedure(getResourceSupport());
663 processor.forEachStatement(this, subject, relation, procedure);
664 procedure.checkAndThrow();
667 } catch (DatabaseException e) {
669 System.err.println(INTERNAL_ERROR_STRING + " getStatements " + subject + " " + relation);
671 StatementReadProcedure procedure = new StatementReadProcedure(getResourceSupport());
672 processor.forEachStatement(this, subject, relation, procedure);
674 return Collections.emptyList();
676 // throw new ServiceException(INTERNAL_ERROR_STRING + " getStatements " + subject + " " + relation, e);
683 final public Collection<Statement> getAssertedStatements(final Resource subject, final Resource relation)
684 throws ManyObjectsForFunctionalRelationException, ServiceException {
686 assert (subject != null);
687 assert (relation != null);
691 return syncRequest(new ForEachAssertedStatement(subject, relation));
693 } catch (ManyObjectsForFunctionalRelationException e) {
695 throw new ManyObjectsForFunctionalRelationException(e);
697 } catch (ServiceException e) {
699 throw new ServiceException(e);
701 } catch (DatabaseException e) {
703 throw new ServiceException(INTERNAL_ERROR_STRING, e);
710 final public Collection<Resource> getPredicates(final Resource subject) throws ServiceException {
712 assert (subject != null);
716 return processor.getPredicates(this, subject);
718 // AsyncMultiReadProcedure<Resource> procedure = new AsyncMultiReadProcedure<Resource>();
719 // processor.forEachPredicate(this, subject, procedure);
720 // procedure.checkAndThrow();
723 } catch (ServiceException e) {
725 throw new ServiceException(e);
727 } catch (DatabaseException e) {
729 throw new ServiceException(INTERNAL_ERROR_STRING, e);
731 } catch (Throwable e) {
733 throw new ServiceException(e);
740 final public Collection<Resource> getPrincipalTypes(final Resource subject)
741 throws ServiceException {
743 assert (subject != null);
747 AsyncMultiReadProcedure<Resource> procedure = new AsyncMultiReadProcedure<Resource>();
748 processor.forEachPrincipalType(this, subject, procedure);
749 procedure.checkAndThrow();
752 } catch (ServiceException e) {
754 throw new ServiceException(e);
756 } catch (DatabaseException e) {
758 throw new ServiceException(INTERNAL_ERROR_STRING, e);
765 final public Set<Resource> getTypes(final Resource subject) throws ServiceException {
767 assert (subject != null);
771 return processor.getTypes(this, subject);
773 } catch (ServiceException e) {
775 throw new ServiceException(e);
777 } catch (DatabaseException e) {
779 throw new ServiceException(INTERNAL_ERROR_STRING, e);
781 } catch (Throwable e) {
783 throw new ServiceException(e);
790 final public Set<Resource> getSupertypes(final Resource subject)
791 throws ServiceException {
793 assert (subject != null);
797 SyncReadProcedure<Set<Resource>> procedure = new SyncReadProcedure<Set<Resource>>();
798 processor.forSupertypes(this, subject, procedure);
799 procedure.checkAndThrow();
800 return procedure.result;
802 } catch (ServiceException e) {
804 throw new ServiceException(e);
806 } catch (DatabaseException e) {
808 throw new ServiceException(INTERNAL_ERROR_STRING, e);
815 final public Set<Resource> getSuperrelations(final Resource subject)
816 throws ServiceException {
818 assert (subject != null);
822 SyncReadProcedure<Set<Resource>> procedure = new SyncReadProcedure<Set<Resource>>();
823 processor.forSuperrelations(this, subject, procedure);
824 procedure.checkAndThrow();
825 return procedure.result;
827 } catch (ServiceException e) {
829 throw new ServiceException(e);
831 } catch (DatabaseException e) {
833 throw new ServiceException(INTERNAL_ERROR_STRING, e);
840 public Resource getPossibleSuperrelation(Resource subject) throws ServiceException {
844 SyncReadProcedure<Resource> procedure = new SyncReadProcedure<Resource>();
845 processor.forPossibleSuperrelation(this, subject, procedure);
846 procedure.checkAndThrow();
847 return procedure.result;
849 } catch (ServiceException e) {
851 throw new ServiceException(e);
853 } catch (DatabaseException e) {
855 throw new ServiceException(INTERNAL_ERROR_STRING, e);
862 final public Collection<Resource> getObjects(final Resource subject, final Resource relation)
863 throws ServiceException {
865 assert (subject != null);
866 assert (relation != null);
868 if(Development.DEVELOPMENT) {
869 if(Development.isTrue(DevelopmentKeys.READGRAPH_COUNT)) {
870 counters.adjustOrPutValue("objects $" + subject.getResourceId() + " $" + relation.getResourceId(), 1, 1);
872 //if(subject.getResourceId()==xx && relation.getResourceId()==xx) new Exception().printStackTrace();
877 AsyncMultiReadProcedure<Resource> procedure = new AsyncMultiReadProcedure<Resource>();
878 processor.forEachObject(this, subject, relation, procedure);
879 procedure.checkAndThrow();
882 } catch (DatabaseException e) {
884 throw new ServiceException(INTERNAL_ERROR_STRING, e);
891 final public Collection<Resource> getAssertedObjects(
892 final Resource subject, final Resource relation)
893 throws ManyObjectsForFunctionalRelationException, ServiceException {
896 throw new ArgumentException("Subject must not be null.");
897 if (relation == null)
898 throw new ArgumentException("Relation must not be null. Subject=" + subject);
902 return syncRequest(new ForEachAssertedObject(subject, relation));
904 } catch (ManyObjectsForFunctionalRelationException e) {
906 throw new ManyObjectsForFunctionalRelationException(e);
908 } catch (ServiceException e) {
910 throw new ServiceException(e);
912 } catch (DatabaseException e) {
914 throw new ServiceException(INTERNAL_ERROR_STRING, e);
921 final public Resource getInverse(final Resource relation) throws NoInverseException, ServiceException {
923 assert (relation != null);
927 return getSingleObject(relation, processor.querySupport.getResource(processor.getInverseOf()));
929 } catch (NoSingleResultException e) {
931 throw new NoInverseException(e);
933 } catch (ServiceException e) {
935 throw new ServiceException(e);
942 final public Resource getSingleObject(final Resource subject, final Resource relation) throws NoSingleResultException, ServiceException {
944 if( subject == null) throw new IllegalArgumentException("subject can not be null");
945 if( relation == null) throw new IllegalArgumentException("relation can not be null");
948 int single = processor.getSingleObject(this, subject, relation);
950 if (EMPTY_RESOURCE_CHECK) {
951 if (!hasStatement(subject)) {
952 throw new EmptyResourceException("Resource " + debugString(subject));
955 throw new NoSingleResultException("No single object for subject " + debugString(subject)
956 + " and relation " + debugString(relation), single);
958 return processor.querySupport.getResource(single);
959 } catch (NoSingleResultException e) {
961 } catch (DatabaseException e) {
962 throw new ServiceException(e);
967 final public Statement getSingleStatement(final Resource subject, final Resource relation) throws NoSingleResultException, ManyObjectsForFunctionalRelationException, ServiceException {
968 assert (subject != null);
969 assert (relation != null);
971 Collection<Statement> statements = getStatements(subject, relation);
972 if (statements.size() == 1) {
973 return statements.iterator().next();
975 if (EMPTY_RESOURCE_CHECK)
976 if (!hasStatement(subject))
977 throw new EmptyResourceException("Resource " + debugString(subject));
978 throw new NoSingleResultException("No single statement for subject " + debugString(subject)
979 + " and relation " + debugString(relation), statements.size());
981 } catch (ServiceException e) {
982 throw new ServiceException(e);
987 final public Resource getSingleType(final Resource subject) throws NoSingleResultException, ServiceException {
988 assert (subject != null);
990 ArrayList<Resource> principalTypes = (ArrayList<Resource>)getPrincipalTypes(subject);
991 if (principalTypes.size() == 1) {
992 return principalTypes.get(0);
994 throw new NoSingleResultException("No single type for subject " + debugString(subject), principalTypes.size());
996 } catch (ServiceException e) {
997 throw new ServiceException(e);
1002 final public Resource getSingleType(final Resource subject,
1003 final Resource baseType) throws NoSingleResultException,
1006 assert (subject != null);
1007 assert (baseType != null);
1010 return syncRequest(new SingleType(subject, baseType));
1011 } catch (DatabaseException e) {
1012 throw new NoSingleResultException("subject=" + subject + ", baseType=" + baseType, 0, e);
1017 final public <T> T getValue(final Resource subject) throws DoesNotContainValueException, ServiceException {
1019 assert (subject != null);
1023 Layer0 L0 = processor.getL0(this);
1024 int object = processor.getSingleObject(this, subject, L0.HasDataType);
1025 if(object == 0) throw new DoesNotContainValueException("No data type for " + subject);
1027 if(processor.isImmutable(object)) {
1028 Binding binding = syncRequest(new DatatypeBinding(processor.querySupport.getResource(object)), TransientCacheListener.<Binding>instance());
1029 return getValue(subject, binding);
1031 byte[] dt = processor.getValue(this, object);
1032 if(dt == null) throw new ServiceException("No data type for " + subject);
1033 Datatype datatype = (Datatype)DATA_TYPE_SERIALIZER.deserialize(dt);
1034 Binding binding = Bindings.getBinding(datatype);
1035 return getValue(subject, binding);
1038 } catch (IOException e) {
1040 throw new ServiceException(e);
1042 } catch (DoesNotContainValueException e) {
1044 throw new DoesNotContainValueException(e, subject);
1046 } catch (ServiceException e) {
1048 throw new ServiceException(e);
1050 } catch (DatabaseException e) {
1052 throw new ServiceException(INTERNAL_ERROR_STRING, e);
1059 final public Variant getVariantValue(final Resource subject) throws DoesNotContainValueException, ServiceException {
1061 assert (subject != null);
1065 Layer0 L0 = processor.getL0(this);
1066 int object = processor.getSingleObject(this, subject, L0.HasDataType);
1067 if(object == 0) throw new DoesNotContainValueException("No data type for " + subject);
1069 if(processor.isImmutable(object)) {
1070 Binding binding = syncRequest(new DatatypeBinding(processor.querySupport.getResource(object)), TransientCacheListener.<Binding>instance());
1071 return new Variant(binding, getValue(subject, binding));
1073 byte[] dt = processor.getValue(this, object);
1074 if(dt == null) throw new ServiceException("No data type for " + subject);
1075 Datatype datatype = (Datatype)DATA_TYPE_SERIALIZER.deserialize(dt);
1076 Binding binding = Bindings.getBinding(datatype);
1077 return new Variant(binding, getValue(subject, binding));
1080 } catch (IOException e) {
1082 throw new ServiceException(e);
1084 } catch (DoesNotContainValueException e) {
1086 throw new DoesNotContainValueException(e, subject);
1088 } catch (ServiceException e) {
1090 throw new ServiceException(e);
1092 } catch (DatabaseException e) {
1094 throw new ServiceException(INTERNAL_ERROR_STRING, e);
1099 static final IdentityHashMap<Binding,Serializer> serializers = new IdentityHashMap<Binding,Serializer>();
1102 serializers.put(Bindings.STRING, Bindings.STRING.serializer());
1105 final protected Serializer getSerializer(Binding binding) {
1106 return binding.serializer();
1110 final public <T> T getValue(final Resource subject, final Binding binding) throws DoesNotContainValueException, BindingException,
1113 assert (subject != null);
1117 byte[] bytes = processor.getValue(this, subject);
1118 if (bytes == null) throw new DoesNotContainValueException("No value for resource " + subject);
1120 Serializer serializer = getSerializer(binding);
1121 return (T)serializer.deserialize(bytes);
1123 } catch (DoesNotContainValueException e) {
1125 throw new DoesNotContainValueException(e);
1127 } catch (IOException e) {
1129 throw new ServiceException(e);
1131 } catch (DatabaseException e) {
1133 throw new ServiceException(e);
1135 } catch (BufferUnderflowException e) {
1136 // This is sometimes thrown when deserialize fails because wrong format.
1137 // For callers of this method this is just an service exception.
1138 throw new ServiceException(e);
1144 final public <T> T getRelatedValue(final Resource subject, final Resource relation) throws NoSingleResultException,
1145 DoesNotContainValueException, ServiceException {
1147 assert (subject != null);
1148 assert (relation != null);
1151 Resource object = getSingleObject(subject, relation);
1152 return getValue(object);
1153 } catch (NoSingleResultException e) {
1154 throw new NoSingleResultException("No single value found for subject " + debugString(subject) + " and relation " + debugString(relation), e.getResultCount(), e);
1155 } catch (DoesNotContainValueException e) {
1157 Layer0 L0 = processor.getL0(this);
1158 Resource object = getPossibleObject(subject, relation);
1159 if(isInstanceOf(object, L0.Value)) {
1160 if(isInstanceOf(object, L0.Literal)) {
1161 throw new DoesNotContainValueException(e);
1163 throw new InvalidLiteralException("The object " + object + " is not an instance of L0.Literal (use getRelatedValue2 instead)", e);
1166 throw new DoesNotContainValueException("The object " + object + " is not an instance of L0.Value", e);
1168 } catch (DoesNotContainValueException e2) {
1170 } catch (DatabaseException e2) {
1171 throw new InternalException("The client failed to analyse the cause of the following exception", e);
1173 } catch (ServiceException e) {
1174 throw new ServiceException(e);
1179 final public Variant getRelatedVariantValue(final Resource subject, final Resource relation) throws NoSingleResultException,
1180 DoesNotContainValueException, ServiceException {
1182 assert (subject != null);
1183 assert (relation != null);
1186 Resource object = getSingleObject(subject, relation);
1187 return getVariantValue(object);
1188 } catch (NoSingleResultException e) {
1189 throw new NoSingleResultException("No single object for subject " + debugString(subject) + " and relation " + debugString(relation), e.getResultCount(), e);
1190 } catch (DoesNotContainValueException e) {
1192 Layer0 L0 = processor.getL0(this);
1193 Resource object = getPossibleObject(subject, relation);
1194 if(isInstanceOf(object, L0.Value)) {
1195 if(isInstanceOf(object, L0.Literal)) {
1196 throw new DoesNotContainValueException(e);
1198 throw new InvalidLiteralException("The object " + object + " is not an instance of L0.Literal (use getRelatedValue2 instead)", e);
1201 throw new DoesNotContainValueException("The object " + object + " is not an instance of L0.Value", e);
1203 } catch (DoesNotContainValueException e2) {
1205 } catch (DatabaseException e2) {
1206 throw new InternalException("The client failed to analyse the cause of the following exception", e);
1208 } catch (ServiceException e) {
1209 throw new ServiceException(e);
1214 final public <T> T getRelatedValue(final Resource subject, final Resource relation, final Binding binding)
1215 throws NoSingleResultException, DoesNotContainValueException, BindingException, ServiceException {
1217 assert (subject != null);
1218 assert (relation != null);
1221 Resource object = getSingleObject(subject, relation);
1222 return getValue(object, binding);
1223 } catch (NoSingleResultException e) {
1224 String message = "";
1226 String subjectName = NameUtils.getSafeName(this, subject, true);
1227 String relationName = NameUtils.getSafeName(this, relation, true);
1228 message = "Subject: " + subjectName + ", Relation: " + relationName;
1229 } catch (DatabaseException e2) {
1232 throw new NoSingleResultException(message, e.getResultCount(), e);
1233 } catch (DoesNotContainValueException e) {
1234 throw new DoesNotContainValueException(e);
1235 } catch (ServiceException e) {
1236 throw new ServiceException(e);
1241 final public <T> T adapt(final Resource resource, final Class<T> clazz)
1242 throws AdaptionException, ValidationException, ServiceException {
1244 assert (resource != null);
1245 assert (clazz != null);
1249 return syncRequest(new Adapter<T>(resource, clazz));
1251 } catch (AdaptionException e) {
1253 throw new AdaptionException(e);
1255 } catch (ValidationException e) {
1257 throw new ValidationException(e);
1259 } catch (ServiceException e) {
1261 throw new ServiceException(e);
1263 } catch (DatabaseException e) {
1265 throw new ServiceException(INTERNAL_ERROR_STRING, e);
1272 final public <T,C> T adaptContextual(final Resource resource, final C context, final Class<C> contextClass, final Class<T> clazz)
1273 throws AdaptionException, ValidationException, ServiceException {
1275 assert (resource != null);
1276 assert (context != null);
1278 class ContextualAdapter implements AsyncRead<T> {
1280 final private Resource resource;
1281 final private C context;
1282 final private Class<T> clazz;
1285 public int hashCode() {
1286 return resource.hashCode() + 31 * (clazz.hashCode() + 41 * context.hashCode());
1290 final public int threadHash() {
1291 return resource.getThreadHash();
1295 public boolean equals(Object object) {
1298 else if (object == null)
1300 else if (getClass() != object.getClass())
1302 ContextualAdapter r = (ContextualAdapter)object;
1303 return resource.equals(r.resource) && context.equals(r.context) && clazz.equals(r.clazz);
1307 public int getFlags() {
1311 public ContextualAdapter(Resource resource, C context, Class<T> clazz) {
1312 this.resource = resource;
1313 this.context = context;
1318 public void perform(AsyncReadGraph graph, AsyncProcedure<T> procedure) {
1320 final AdaptionService service = getSession().peekService(AdaptionService.class);
1321 if (service == null)
1322 procedure.exception(graph, new ServiceException("No AdaptionService available"));
1324 service.adapt(graph, resource, context, contextClass, clazz, false, procedure);
1329 public String toString() {
1330 return "Adapter for (" + resource + "," + context + ") as " + clazz.getName();
1337 return syncRequest(new ContextualAdapter(resource, context, clazz));
1339 } catch (AdaptionException e) {
1341 throw new AdaptionException(e);
1343 } catch (ValidationException e) {
1345 throw new ValidationException(e);
1347 } catch (ServiceException e) {
1349 throw new ServiceException(e);
1351 } catch (DatabaseException e) {
1353 throw new ServiceException(INTERNAL_ERROR_STRING, e);
1360 final public <T> T adaptRelated(final Resource resource, final Resource relation, final Class<T> clazz)
1361 throws AdaptionException, NoSingleResultException, ValidationException, ServiceException {
1363 assert (resource != null);
1364 assert (clazz != null);
1366 Statement stm = getSingleStatement(resource, relation);
1368 return adaptContextual(stm.getObject(), new RelationContextImpl(resource, stm), RelationContext.class, clazz);
1373 final public <T> T getPossibleRelatedAdapter(final Resource resource, final Resource relation, final Class<T> clazz)
1374 throws ValidationException, ServiceException {
1377 return adaptRelated(resource, relation, clazz);
1378 } catch (DatabaseException e) {
1385 final public <T,C> T getPossibleContextualAdapter(final Resource resource, final C context, final Class<C> contextClass, final Class<T> clazz)
1386 throws ValidationException, ServiceException {
1388 assert (resource != null);
1389 assert (context != null);
1391 class PossibleContextualAdapter implements AsyncRead<T> {
1393 final private Resource resource;
1394 final private C context;
1395 final private Class<T> clazz;
1398 public int hashCode() {
1399 return resource.hashCode() + 31 * (clazz.hashCode() + 41 * context.hashCode());
1403 final public int threadHash() {
1404 return resource.getThreadHash();
1408 public boolean equals(Object object) {
1411 else if (object == null)
1413 else if (getClass() != object.getClass())
1415 PossibleContextualAdapter r = (PossibleContextualAdapter)object;
1416 return resource.equals(r.resource) && context.equals(r.context) && clazz.equals(r.clazz);
1420 public int getFlags() {
1424 public PossibleContextualAdapter(Resource resource, C context, Class<T> clazz) {
1425 this.resource = resource;
1426 this.context = context;
1431 public void perform(AsyncReadGraph graph, AsyncProcedure<T> procedure) {
1433 final AdaptionService service = getSession().peekService(AdaptionService.class);
1434 if (service == null)
1435 procedure.exception(graph, new ServiceException("No AdaptionService available"));
1437 service.adapt(graph, resource, context, contextClass, clazz, true, procedure);
1442 public String toString() {
1443 return "Possible adapter for (" + resource + "," + context + ") as " + clazz.getName();
1450 return syncRequest(new PossibleContextualAdapter(resource, context, clazz));
1452 } catch (ValidationException e) {
1454 throw new ValidationException(e);
1456 } catch (ServiceException e) {
1458 throw new ServiceException(e);
1460 } catch (DatabaseException e) {
1462 throw new ServiceException(INTERNAL_ERROR_STRING, e);
1469 final public <T> T adaptUnique(final Resource resource, final Class<T> clazz)
1470 throws AdaptionException, ValidationException, ServiceException {
1472 assert (resource != null);
1473 assert (clazz != null);
1477 return syncRequest(new UniqueAdapter<T>(resource, clazz));
1479 } catch (AdaptionException e) {
1481 throw new AdaptionException(e);
1483 } catch (ValidationException e) {
1485 throw new ValidationException(e);
1487 } catch (ServiceException e) {
1489 throw new ServiceException(e);
1491 } catch (DatabaseException e) {
1493 throw new ServiceException(INTERNAL_ERROR_STRING, e);
1500 final public Resource getPossibleInverse(final Resource relation)
1501 throws ServiceException {
1503 assert (relation != null);
1507 return getPossibleObject(relation, processor.querySupport.getResource(processor.getInverseOf()));
1509 } catch (ServiceException e) {
1511 throw new ServiceException(e);
1513 } catch (DatabaseException e) {
1515 throw new ServiceException(INTERNAL_ERROR_STRING, e);
1522 public Resource getPossibleObject(final Resource subject, final Resource relation)
1523 throws ManyObjectsForFunctionalRelationException, ServiceException {
1525 assert (subject != null);
1526 assert (relation != null);
1530 int result = processor.getSingleObject(this, subject, relation);
1531 if(result == 0) return null;
1533 return processor.querySupport.getResource(result);
1535 } catch (ManyObjectsForFunctionalRelationException e) {
1537 throw new ManyObjectsForFunctionalRelationException("subject=" + subject + ", relation=" + relation, e);
1539 } catch (DatabaseException e) {
1541 throw new ServiceException(e);
1548 final public Statement getPossibleStatement(final Resource subject, final Resource relation)
1549 throws ManyObjectsForFunctionalRelationException, ServiceException {
1551 assert (subject != null);
1552 assert (relation != null);
1556 Collection<Statement> statements = getStatements(subject, relation);
1557 if(statements.size() == 1) return statements.iterator().next();
1560 } catch (ManyObjectsForFunctionalRelationException e) {
1562 throw new ManyObjectsForFunctionalRelationException("Many objects in " + subject + " for functional relation " + relation);
1564 } catch (ServiceException e) {
1566 throw new ServiceException(e);
1573 final public Resource getPossibleType(final Resource subject, final Resource baseType) throws ServiceException {
1575 assert (subject != null);
1576 assert (baseType != null);
1580 AsyncReadProcedure<Resource> procedure = new AsyncReadProcedure<Resource>();
1581 forPossibleType(subject, baseType, procedure);
1582 procedure.checkAndThrow();
1583 return procedure.result;
1585 } catch (ServiceException e) {
1587 throw new ServiceException(e);
1589 } catch (DatabaseException e) {
1591 throw new ServiceException(INTERNAL_ERROR_STRING, e);
1598 final public <T> T getPossibleValue(final Resource subject) throws ServiceException {
1600 assert (subject != null);
1604 int object = processor.getSingleObject(this, subject, processor.getL0(this).HasDataType);
1605 if(object == 0) return null;
1607 if(processor.isImmutable(object)) {
1608 Binding binding = syncRequest(new DatatypeBinding(processor.querySupport.getResource(object)), TransientCacheListener.<Binding>instance());
1609 return getPossibleValue(subject, binding);
1611 byte[] dt = processor.getValue(this, object);
1612 if(dt == null) return null;
1613 Datatype datatype = (Datatype)DATA_TYPE_SERIALIZER.deserialize(dt);
1614 Binding binding = Bindings.getBinding(datatype);
1615 return getPossibleValue(subject, binding);
1618 } catch (IOException e) {
1620 throw new ServiceException(e);
1622 } catch (ServiceException e) {
1624 throw new ServiceException(e);
1626 } catch (DatabaseException e) {
1628 throw new ServiceException(INTERNAL_ERROR_STRING, e);
1635 final public <T> T getPossibleValue(final Resource subject, final Binding binding) throws BindingException, ServiceException {
1637 assert (subject != null);
1638 assert (binding != null);
1642 byte[] dt = processor.getValue(this, subject);
1643 if(dt == null) return null;
1644 Serializer serializer = getSerializer(binding);
1645 return (T)serializer.deserialize(dt);
1647 } catch (IOException e) {
1649 throw new ServiceException(e);
1651 } catch (BindingException e) {
1653 throw new BindingException(e);
1655 } catch (ServiceException e) {
1657 throw new ServiceException(e);
1659 } catch (DatabaseException e) {
1660 e.printStackTrace();
1661 throw new ServiceException(INTERNAL_ERROR_STRING, e);
1667 public <T> T getPossibleRelatedValue(final Resource subject, final Resource relation)
1668 throws ManyObjectsForFunctionalRelationException, ServiceException {
1670 assert (subject != null);
1671 assert (relation != null);
1675 Resource object = getPossibleObject(subject, relation);
1676 if(object == null) return null;
1677 else return getPossibleValue(object);
1679 } catch (ManyObjectsForFunctionalRelationException e) {
1681 throw new ManyObjectsForFunctionalRelationException(e);
1683 } catch (ServiceException e) {
1685 throw new ServiceException(e);
1692 public <T> T getPossibleRelatedValue(final Resource subject, final Resource relation, final Binding binding)
1693 throws ManyObjectsForFunctionalRelationException, BindingException, ServiceException {
1695 assert (subject != null);
1696 assert (relation != null);
1697 assert (binding != null);
1701 Resource object = getPossibleObject(subject, relation);
1702 if(object == null) return null;
1703 else return getPossibleValue(object, binding);
1705 } catch (ManyObjectsForFunctionalRelationException e) {
1707 throw new ManyObjectsForFunctionalRelationException(e);
1709 } catch (BindingException e) {
1711 throw new BindingException(e);
1713 } catch (ServiceException e) {
1715 throw new ServiceException(e);
1722 public <T> T getPossibleAdapter(Resource resource, Class<T> clazz) throws ValidationException, ServiceException {
1724 assert (resource != null);
1725 assert (clazz != null);
1729 return syncRequest(new PossibleAdapter<T>(resource, clazz));
1731 } catch (ValidationException e) {
1733 throw new ValidationException(e);
1735 } catch (AdaptionException e) {
1739 } catch (DatabaseException e) {
1741 throw new ServiceException(INTERNAL_ERROR_STRING, e);
1747 public <T> T getPossibleUniqueAdapter(Resource resource, Class<T> clazz) throws ValidationException, ServiceException {
1749 assert (resource != null);
1750 assert (clazz != null);
1754 return syncRequest(new PossibleUniqueAdapter<T>(resource, clazz));
1756 } catch (AdaptionException e) {
1760 } catch (ValidationException e) {
1762 throw new ValidationException(e);
1764 } catch (DatabaseException e) {
1766 throw new ServiceException(INTERNAL_ERROR_STRING, e);
1773 final public boolean isInstanceOf(final Resource resource, final Resource type) throws ServiceException {
1775 assert (resource != null);
1776 assert (type != null);
1778 Set<Resource> resources = getTypes(resource);
1779 // This check was necessary because some of the callers of this method got stuck when the NPE was thrown from here.
1780 if (null == resources)
1783 if(EMPTY_RESOURCE_CHECK) {
1784 if (resources.isEmpty()) {
1785 if(!hasStatement(resource)) throw new EmptyResourceException("Resource " + debugString(resource));
1789 return resources.contains(type);
1794 final public boolean isInheritedFrom(final Resource resource, final Resource type) throws ServiceException {
1796 assert (resource != null);
1797 assert (type != null);
1801 if(resource.equals(type)) return true;
1803 return getSupertypes(resource).contains(type);
1805 } catch (ServiceException e) {
1807 throw new ServiceException(e);
1814 final public boolean isSubrelationOf(final Resource resource, final Resource type) throws ServiceException {
1816 assert (resource != null);
1817 assert (type != null);
1821 if(resource.equals(type)) return true;
1823 return getSuperrelations(resource).contains(type);
1825 } catch (ServiceException e) {
1827 throw new ServiceException(e);
1834 final public boolean hasStatement(final Resource subject) throws ServiceException {
1836 assert (subject != null);
1840 SyncReadProcedure<Boolean> procedure = new SyncReadProcedure<Boolean>();
1841 processor.forHasStatement(this, subject, procedure);
1842 procedure.checkAndThrow();
1843 return procedure.result;
1845 } catch (ServiceException e) {
1847 throw new ServiceException(e);
1849 } catch (DatabaseException e) {
1851 throw new ServiceException(INTERNAL_ERROR_STRING, e);
1858 final public boolean hasStatement(final Resource subject, final Resource relation) throws ServiceException {
1860 assert (subject != null);
1861 assert (relation != null);
1865 Collection<Resource> objects = getObjects(subject, relation);
1866 return !objects.isEmpty();
1868 } catch (ServiceException e) {
1870 throw new ServiceException(e);
1877 final public boolean hasStatement(final Resource subject, final Resource relation, final Resource object) throws ServiceException {
1879 assert (subject != null);
1880 assert (relation != null);
1881 assert (object != null);
1885 for(Resource o : getObjects(subject, relation)) {
1886 if(object.equals(o)) return true;
1891 } catch (ServiceException e) {
1893 throw new ServiceException(e);
1900 final public boolean hasValue(final Resource subject) throws ServiceException {
1902 assert (subject != null);
1906 SyncReadProcedure<Boolean> procedure = new SyncReadProcedure<Boolean>();
1907 processor.forHasValue(this, subject, procedure);
1908 procedure.checkAndThrow();
1909 return procedure.result;
1911 } catch (ServiceException e) {
1913 throw new ServiceException(e);
1915 } catch (DatabaseException e) {
1917 throw new ServiceException(INTERNAL_ERROR_STRING, e);
1923 final AsyncProcedure<?> NONE = new AsyncProcedure<Object>() {
1926 public void execute(AsyncReadGraph graph, Object result) {
1930 public void exception(AsyncReadGraph graph, Throwable throwable) {
1936 * Implementation of the interface RequestProcessor
1940 public <T> T syncRequest(final Read<T> request) throws DatabaseException {
1942 assert (request != null);
1944 return QueryCache.resultReadEntry(this, request, parent, null, null);
1946 //return processor.query(this, request, parent, null, null);
1948 // if (parent != null) {
1951 // } catch (Throwable e) {
1952 // if(e instanceof DatabaseException) throw (DatabaseException)e;
1953 // else throw new DatabaseException(e);
1960 // return processor.tryQuery(this, request);
1962 // } catch (Throwable throwable) {
1964 // //Logger.defaultLogError("Internal read request failure", throwable);
1966 // if (throwable instanceof DatabaseException)
1967 // throw (DatabaseException) throwable;
1969 // throw new DatabaseException(
1970 // "Unexpected exception in ReadGraph.syncRequest(Read,Procedure)",
1980 public <T> T syncRequest(Read<T> request, SyncListener<T> procedure)
1981 throws DatabaseException {
1982 return syncRequest(request, new SyncToAsyncListener<T>(procedure));
1986 public <T> T syncRequest(Read<T> request, final Listener<T> procedure)
1987 throws DatabaseException {
1988 return syncRequest(request, new NoneToAsyncListener<T>(procedure));
1992 public <T> T syncRequest(final Read<T> request, final AsyncProcedure<T> procedure) throws DatabaseException {
1994 assert (request != null);
1996 ListenerBase listener = procedure != null ? getListenerBase(procedure) : null;
1998 return QueryCache.resultReadEntry(this, request, parent, listener, procedure);
2000 // return processor.query(this, request, parent, procedure, listener);
2003 // if (parent != null || listener != null) {
2006 // } catch (Throwable e) {
2007 // if(e instanceof DatabaseException) throw (DatabaseException)e;
2008 // else throw new DatabaseException(e);
2015 // T t = processor.tryQuery(this, request);
2016 // if(procedure != null)
2017 // procedure.execute(this, t);
2021 // } catch (Throwable throwable) {
2023 // Logger.defaultLogError("Internal read request failure", throwable);
2025 // if(procedure != null)
2026 // procedure.exception(this, throwable);
2028 // if (throwable instanceof DatabaseException)
2029 // throw (DatabaseException) throwable;
2031 // throw new DatabaseException(
2032 // "Unexpected exception in ReadGraph.syncRequest(Read,Procedure)",
2042 public <T> T syncRequest(final Read<T> request,
2043 final SyncProcedure<T> procedure) throws DatabaseException {
2044 return syncRequest(request, new SyncToAsyncProcedure<T>(procedure));
2048 public <T> T syncRequest(Read<T> request, Procedure<T> procedure)
2049 throws DatabaseException {
2050 return syncRequest(request, new NoneToAsyncProcedure<T>(procedure));
2053 static class AsyncReadProcedure<T> implements AsyncProcedure<T> {
2055 private static Throwable DONE = new Throwable();
2058 Throwable exception = null;
2061 public void execute(AsyncReadGraph graph, T t) {
2067 public void exception(AsyncReadGraph graph, Throwable t) {
2071 public void checkAndThrow() throws DatabaseException {
2072 if(exception != DONE) {
2073 if (exception instanceof DatabaseException)
2074 throw (DatabaseException) exception;
2076 throw new DatabaseException(
2077 "Unexpected exception in ReadGraph.syncRequest(AsyncRead)",
2082 public boolean done() {
2083 return exception != null;
2089 public <T> T syncRequest(final AsyncRead<T> request)
2090 throws DatabaseException {
2092 assert (request != null);
2093 // AsyncReadProcedure<T> procedure = new AsyncReadProcedure<T>();
2094 BlockingAsyncProcedure<T> ap = new BlockingAsyncProcedure<>(this, null, request);
2095 syncRequest(request, ap);
2097 // procedure.checkAndThrow();
2098 // return procedure.result;
2100 // return syncRequest(request, new AsyncProcedureAdapter<T>());
2105 public <T> T syncRequest(AsyncRead<T> request, AsyncListener<T> procedure)
2106 throws DatabaseException {
2107 return syncRequest(request, (AsyncProcedure<T>) procedure);
2111 public <T> T syncRequest(AsyncRead<T> request, SyncListener<T> procedure)
2112 throws DatabaseException {
2113 return syncRequest(request, new SyncToAsyncListener<T>(procedure));
2117 public <T> T syncRequest(AsyncRead<T> request, Listener<T> procedure)
2118 throws DatabaseException {
2119 return syncRequest(request, new NoneToAsyncListener<T>(procedure));
2123 final public <T> T syncRequest(final AsyncRead<T> request,
2124 final AsyncProcedure<T> procedure) throws DatabaseException {
2126 assert (request != null);
2128 ListenerBase listener = getListenerBase(procedure);
2130 BlockingAsyncProcedure<T> ap = new BlockingAsyncProcedure<>(this, procedure, request);
2132 // final ResultCallWrappedSingleQueryProcedure4<T> wrapper = new ResultCallWrappedSingleQueryProcedure4<T>(
2133 // procedure, request);
2135 QueryCache.runnerAsyncReadEntry(this, request, parent, listener, ap, true);
2137 //processor.query(this, request, parent, wrapper, listener);
2141 // return wrapper.getResult();
2143 // if (parent != null || listener != null || ((request.getFlags() & RequestFlags.SCHEDULE) > 0)) {
2145 //// Object syncParent = request;
2147 //// final ReadGraphImpl newGraph = newSync();
2150 //// newGraph.waitAsync(syncParent);
2152 // Throwable e = wrapper.getException();
2154 // // The request was async - produce meaningful stack trace by
2156 // if (e instanceof DatabaseException)
2157 // throw (DatabaseException) e;
2159 // throw new DatabaseException(e);
2162 // return wrapper.getResult();
2166 // // System.out.println("direct call " + request );
2168 // // Do not set the sync state.parent for external threads
2169 //// Object syncParent = request;
2171 //// final ReadGraphImpl newGraph = newSync();
2173 // final ResultCallWrappedSingleQueryProcedure4<T> wrapper = new ResultCallWrappedSingleQueryProcedure4<T>(
2174 // procedure, request);
2178 // processor.tryQuery(this, request, wrapper);
2180 // } catch (Throwable t) {
2182 // wrapper.exception(this, t);
2186 // Throwable e = wrapper.getException();
2188 // // The request was async - produce meaningful stack trace by
2190 // if (e instanceof DatabaseException)
2191 // throw (DatabaseException) e;
2193 // throw new DatabaseException(e);
2196 // return wrapper.getResult();
2202 final private <T> void syncRequest(final AsyncRead<T> request, final AsyncReadProcedure<T> procedure) throws DatabaseException {
2204 assert (request != null);
2206 ListenerBase listener = getListenerBase(procedure);
2207 assert(listener == null);
2209 BlockingAsyncProcedure<T> ap = new BlockingAsyncProcedure<>(this, procedure, request);
2211 // final ResultCallWrappedSingleQueryProcedure4<T> wrapper = new ResultCallWrappedSingleQueryProcedure4<T>(
2212 // procedure, request);
2214 QueryCache.runnerAsyncReadEntry(this, request, parent, listener, ap, true);
2221 public <T> T syncRequest(AsyncRead<T> request,
2222 final SyncProcedure<T> procedure) throws DatabaseException {
2223 return syncRequest(request, new SyncToAsyncProcedure<T>(procedure));
2227 final public <T> T syncRequest(final AsyncRead<T> request,
2228 final Procedure<T> procedure) throws DatabaseException {
2229 return syncRequest(request, new NoneToAsyncProcedure<T>(procedure));
2233 public <T> Collection<T> syncRequest(final MultiRead<T> request)
2234 throws DatabaseException {
2236 assert (request != null);
2238 final ArrayList<T> result = new ArrayList<T>();
2239 final DataContainer<Throwable> exception = new DataContainer<Throwable>();
2241 syncRequest(request, new AsyncMultiProcedure<T>() {
2244 public void execute(AsyncReadGraph graph, T t) {
2245 synchronized (result) {
2251 public void finished(AsyncReadGraph graph) {
2255 public void exception(AsyncReadGraph graph, Throwable t) {
2260 public String toString() {
2261 return "syncRequest(MultiRead) -> " + request;
2266 Throwable t = exception.get();
2268 if (t instanceof DatabaseException)
2269 throw (DatabaseException) t;
2271 throw new DatabaseException(
2272 "Unexpected exception in ReadGraph.syncRequest(Read)",
2281 public <T> Collection<T> syncRequest(MultiRead<T> request,
2282 AsyncMultiListener<T> procedure) {
2283 return syncRequest(request, (AsyncMultiProcedure<T>) procedure);
2287 public <T> Collection<T> syncRequest(MultiRead<T> request,
2288 SyncMultiListener<T> procedure) {
2289 return syncRequest(request, new SyncToAsyncMultiListener<T>(procedure));
2293 public <T> Collection<T> syncRequest(MultiRead<T> request,
2294 MultiListener<T> procedure) {
2295 return syncRequest(request, new NoneToAsyncMultiListener<T>(procedure));
2299 public <T> Collection<T> syncRequest(MultiRead<T> request,
2300 AsyncMultiProcedure<T> procedure) {
2302 assert (request != null);
2304 ListenerBase listener = getListenerBase(procedure);
2306 if (parent != null || listener != null) {
2308 // Object syncParent = request;
2310 // final ReadGraphImpl newGraph = newSync();
2312 processor.query(this, request, parent, procedure, listener);
2314 // newGraph.waitAsync(syncParent);
2318 // Object syncParent = request;
2320 // final ReadGraphImpl newGraph = newSync();
2322 final ResultCallWrappedQueryProcedure4<T> wrapper = new ResultCallWrappedQueryProcedure4<T>(procedure);
2326 request.perform(this, wrapper);
2328 } catch (Throwable t) {
2330 wrapper.exception(this, t);
2331 // newGraph.waitAsync(syncParent);
2343 public <T> Collection<T> syncRequest(MultiRead<T> request,
2344 SyncMultiProcedure<T> procedure) {
2345 return syncRequest(request, new SyncToAsyncMultiProcedure<T>(procedure));
2349 public <T> Collection<T> syncRequest(MultiRead<T> request,
2350 MultiProcedure<T> procedure) {
2351 return syncRequest(request, new NoneToAsyncMultiProcedure<T>(procedure));
2354 static class AsyncMultiReadProcedure<T> extends ArrayList<T> implements AsyncMultiProcedure<T> {
2356 private static Throwable DONE = new Throwable();
2358 private static final long serialVersionUID = -6494230465108115812L;
2360 Throwable exception = null;
2363 public synchronized void execute(AsyncReadGraph graph, T t) {
2368 public void finished(AsyncReadGraph graph) {
2373 public void exception(AsyncReadGraph graph, Throwable t) {
2377 public void checkAndThrow() throws DatabaseException {
2378 if(exception != DONE) {
2379 if (exception instanceof DatabaseException)
2380 throw (DatabaseException) exception;
2382 throw new DatabaseException(
2383 "Unexpected exception in ReadGraph.syncRequest(AsyncMultiRead)",
2388 public boolean done() {
2389 return exception != null;
2395 final public <T> Collection<T> syncRequest(AsyncMultiRead<T> request)
2396 throws DatabaseException {
2398 assert (request != null);
2400 final AsyncMultiReadProcedure<T> procedure = new AsyncMultiReadProcedure<T>();
2402 syncRequest(request, procedure);
2404 procedure.checkAndThrow();
2410 public <T> Collection<T> syncRequest(AsyncMultiRead<T> request,
2411 AsyncMultiListener<T> procedure) {
2412 return syncRequest(request, (AsyncMultiProcedure<T>) procedure);
2416 public <T> Collection<T> syncRequest(AsyncMultiRead<T> request,
2417 SyncMultiListener<T> procedure) {
2418 return syncRequest(request, new SyncToAsyncMultiListener<T>(procedure));
2422 public <T> Collection<T> syncRequest(AsyncMultiRead<T> request,
2423 MultiListener<T> procedure) {
2424 return syncRequest(request, new NoneToAsyncMultiListener<T>(procedure));
2427 final private <T> void syncRequest(final AsyncMultiRead<T> request,
2428 final AsyncMultiReadProcedure<T> procedure) {
2430 assert (request != null);
2431 assert (procedure != null);
2433 ListenerBase listener = getListenerBase(procedure);
2435 if (parent != null || listener != null) {
2437 // Object syncParent = request;
2439 // final ReadGraphImpl newGraph = newSync();
2441 processor.query(this, request, parent, procedure, listener);
2443 // newGraph.waitAsync(syncParent);
2444 waitAsyncProcedure(procedure);
2448 // Object syncParent = callerThread == Integer.MIN_VALUE ? null
2451 // final ReadGraphImpl newGraph = newSyncAsync(syncParent);
2456 // ReadGraphImpl sync = newSync();
2457 request.perform(this, procedure);
2458 // sync.waitAsync(null);
2459 waitAsyncProcedure(procedure);
2462 } catch (Throwable t) {
2464 waitAsyncProcedure(procedure);
2475 final public <T> Collection<T> syncRequest(final AsyncMultiRead<T> request,
2476 final AsyncMultiProcedure<T> procedure) {
2478 assert (request != null);
2479 assert (procedure != null);
2481 ListenerBase listener = getListenerBase(procedure);
2483 if (parent != null || listener != null) {
2485 // Object syncParent = request;
2487 // final ReadGraphImpl newGraph = newSync();
2489 processor.query(this, request, parent, procedure, listener);
2491 // newGraph.waitAsync(syncParent);
2495 // Object syncParent = request;
2497 // final ReadGraphImpl newGraph = newSync();
2501 request.perform(this, new AsyncMultiProcedure<T>() {
2504 public void execute(AsyncReadGraph graph, T result) {
2505 procedure.execute(graph, result);
2509 public void finished(AsyncReadGraph graph) {
2510 procedure.finished(graph);
2514 public void exception(AsyncReadGraph graph, Throwable t) {
2515 procedure.exception(graph, t);
2519 public String toString() {
2520 return "syncRequest(AsyncMultiRead) -> " + procedure;
2525 } catch (Throwable t) {
2537 public <T> Collection<T> syncRequest(AsyncMultiRead<T> request,
2538 final SyncMultiProcedure<T> procedure) {
2539 return syncRequest(request, new SyncToAsyncMultiProcedure<T>(procedure));
2543 final public <T> Collection<T> syncRequest(final AsyncMultiRead<T> request,
2544 final MultiProcedure<T> procedure) {
2545 return syncRequest(request, new NoneToAsyncMultiProcedure<T>(procedure));
2549 public <T> T syncRequest(final ExternalRead<T> request)
2550 throws DatabaseException {
2552 assert (request != null);
2554 return syncRequest(request, new Procedure<T>() {
2557 public void execute(T t) {
2561 public void exception(Throwable t) {
2565 public String toString() {
2566 return "syncRequest(AsyncRead) -> " + request;
2574 public <T> T syncRequest(ExternalRead<T> request, Listener<T> procedure) throws DatabaseException {
2575 return syncRequest(request, (Procedure<T>) procedure);
2579 final public <T> T syncRequest(final ExternalRead<T> request,
2580 final Procedure<T> procedure) throws DatabaseException {
2582 assert (request != null);
2584 ListenerBase listener = procedure != null ? getListenerBase(procedure) : null;
2585 return QueryCache.resultExternalReadEntry(this, request, parent, listener, procedure);
2588 // ListenerBase listener = getListenerBase(procedure);
2590 // return QueryCache.resultExternalReadEntry(this, request, parent, listener, procedure);
2592 // assert (request != null);
2594 // ListenerBase listener = getListenerBase(procedure);
2596 // final DataContainer<Throwable> exception = new DataContainer<Throwable>();
2597 // final DataContainer<T> result = new DataContainer<T>();
2599 // processor.query(this, request, parent, new Procedure<T>() {
2602 // public void exception(Throwable throwable) {
2603 // exception.set(throwable);
2604 // procedure.exception(throwable);
2608 // public void execute(T t) {
2610 // procedure.execute(t);
2617 // if (parent != null || listener != null) {
2619 //// final ReadGraphImpl newGraph = newSync();
2622 //// newGraph.waitAsync(request);
2628 // T t = processor.tryQuery(this, request);
2630 // procedure.execute(t);
2632 // } catch (Throwable t) {
2634 // if (t instanceof DatabaseException) {
2635 // exception.set((DatabaseException)t);
2636 // procedure.exception(exception.get());
2638 // exception.set(new DatabaseException(
2639 // "Unexpected exception in ReadGraph.syncRequest(Read)",
2641 // procedure.exception(exception.get());
2648 // Throwable t = exception.get();
2650 // if (t instanceof DatabaseException)
2651 // throw (DatabaseException) t;
2653 // throw new DatabaseException(
2654 // "Unexpected exception in ReadGraph.syncRequest(Read)",
2658 // return result.get();
2663 public void syncRequest(final Write request) throws DatabaseException {
2665 assert (request != null);
2667 throw new DatabaseException(
2668 "Write operations are not supported during read transactions!");
2673 public <T> T syncRequest(final WriteResult<T> request) throws DatabaseException {
2675 assert (request != null);
2677 throw new DatabaseException(
2678 "Write operations are not supported during read transactions!");
2683 public void syncRequest(final DelayedWrite request)
2684 throws DatabaseException {
2686 assert (request != null);
2688 throw new DatabaseException(
2689 "Write operations are not supported during read transactions!");
2694 public <T> T syncRequest(final DelayedWriteResult<T> request) throws DatabaseException {
2696 assert (request != null);
2698 throw new DatabaseException(
2699 "Write operations are not supported during read transactions!");
2704 public void syncRequest(final WriteOnly request) throws DatabaseException {
2706 assert (request != null);
2708 throw new DatabaseException(
2709 "Write operations are not supported during read transactions!");
2714 public <T> T syncRequest(final WriteOnlyResult<T> request) throws DatabaseException {
2716 assert (request != null);
2718 throw new DatabaseException(
2719 "Write operations are not supported during read transactions!");
2724 public <T> void async(ReadInterface<T> r, AsyncProcedure<T> procedure) {
2725 r.request(this, procedure);
2729 public <T> void async(ReadInterface<T> r, Procedure<T> procedure) {
2730 r.request(this, procedure);
2734 public <T> void async(ReadInterface<T> r, SyncProcedure<T> procedure) {
2735 r.request(this, procedure);
2739 public <T> void async(ReadInterface<T> r, AsyncListener<T> procedure) {
2740 r.request(this, procedure);
2744 public <T> void async(ReadInterface<T> r, Listener<T> procedure) {
2745 r.request(this, procedure);
2749 public <T> void async(ReadInterface<T> r, SyncListener<T> procedure) {
2750 r.request(this, procedure);
2754 public <T> T sync(ReadInterface<T> r) throws DatabaseException {
2755 return r.request(this);
2759 public <T> T sync(WriteInterface<T> r) throws DatabaseException {
2760 return r.request(this);
2764 public <T> void async(WriteInterface<T> r, Procedure<T> procedure) {
2765 r.request(this, procedure);
2769 public <T> void async(WriteInterface<T> r) {
2770 r.request(this, new ProcedureAdapter<T>());
2774 * Implementation of the interface AsyncReadGraph
2778 public void forURI(Resource resource, AsyncListener<String> listener) {
2779 asyncRequest(new org.simantics.db.common.uri.ResourceToURI(resource),
2784 public void forURI(Resource resource, SyncListener<String> listener) {
2785 asyncRequest(new org.simantics.db.common.uri.ResourceToURI(resource),
2790 public void forURI(Resource resource, Listener<String> listener) {
2791 asyncRequest(new org.simantics.db.common.uri.ResourceToURI(resource),
2796 final public void forURI(final Resource resource,
2797 final AsyncProcedure<String> procedure) {
2799 assert (resource != null);
2800 assert (procedure != null);
2802 asyncRequest(new org.simantics.db.common.uri.ResourceToURI(resource),
2808 public void forURI(Resource resource, SyncProcedure<String> procedure) {
2809 forURI(resource, new SyncToAsyncProcedure<String>(procedure));
2813 public void forURI(Resource resource, Procedure<String> procedure) {
2814 forURI(resource, new NoneToAsyncProcedure<String>(procedure));
2818 public void forResource(String id, AsyncListener<Resource> listener) {
2819 asyncRequest(new org.simantics.db.common.primitiverequest.Resource(id),
2824 public void forResource(String id, SyncListener<Resource> listener) {
2825 asyncRequest(new org.simantics.db.common.primitiverequest.Resource(id),
2830 public void forResource(String id, Listener<Resource> listener) {
2831 asyncRequest(new org.simantics.db.common.primitiverequest.Resource(id),
2836 final public void forResource(final String id,
2837 final AsyncProcedure<Resource> procedure) {
2839 assert (id != null);
2840 assert (procedure != null);
2842 processor.forResource(this, id, procedure);
2847 public void forResource(String id, SyncProcedure<Resource> procedure) {
2848 forResource(id, new SyncToAsyncProcedure<Resource>(procedure));
2852 public void forResource(String id, Procedure<Resource> procedure) {
2853 forResource(id, new NoneToAsyncProcedure<Resource>(procedure));
2857 public void forBuiltin(String id, AsyncListener<Resource> listener) {
2858 asyncRequest(new Builtin(id), listener);
2862 public void forBuiltin(String id, SyncListener<Resource> listener) {
2863 asyncRequest(new Builtin(id), listener);
2867 public void forBuiltin(String id, Listener<Resource> listener) {
2868 asyncRequest(new Builtin(id), listener);
2872 final public void forBuiltin(final String id,
2873 final AsyncProcedure<Resource> procedure) {
2875 assert (id != null);
2876 assert (procedure != null);
2878 processor.forBuiltin(this, id, procedure);
2883 public void forBuiltin(String id, SyncProcedure<Resource> procedure) {
2884 forBuiltin(id, new SyncToAsyncProcedure<Resource>(procedure));
2888 public void forBuiltin(String id, Procedure<Resource> procedure) {
2889 forBuiltin(id, new NoneToAsyncProcedure<Resource>(procedure));
2893 final public void forEachStatement(Resource subject, Resource relation,
2894 AsyncMultiProcedure<Statement> procedure) {
2896 assert (subject != null);
2897 assert (relation != null);
2898 assert (procedure != null);
2900 processor.forEachStatement(this, subject, relation, procedure);
2905 public void forEachStatement(Resource subject, Resource relation,
2906 SyncMultiProcedure<Statement> procedure) {
2907 forEachStatement(subject, relation,
2908 new SyncToAsyncMultiProcedure<Statement>(procedure));
2912 final public void forEachStatement(Resource subject, Resource relation,
2913 MultiProcedure<Statement> procedure) {
2915 assert (subject != null);
2916 assert (relation != null);
2917 assert (procedure != null);
2919 processor.forEachStatement(this, subject, relation, procedure);
2924 final public void forStatementSet(Resource subject, Resource relation,
2925 AsyncSetListener<Statement> procedure) {
2927 assert (subject != null);
2928 assert (relation != null);
2929 assert (procedure != null);
2931 processor.forStatementSet(this, subject, relation, procedure);
2936 final public void forStatementSet(Resource subject, Resource relation,
2937 SyncSetListener<Statement> procedure) {
2938 forStatementSet(subject, relation,
2939 new SyncToAsyncSetProcedure<Statement>(procedure));
2943 public void forStatementSet(Resource subject, Resource relation,
2944 SetListener<Statement> listener) {
2945 forStatementSet(subject, relation,
2946 new NoneToAsyncSetProcedure<Statement>(listener));
2950 final public void forEachAssertedStatement(final Resource subject,
2951 final Resource relation,
2952 final AsyncMultiProcedure<Statement> procedure) {
2954 assert (subject != null);
2955 assert (relation != null);
2956 assert (procedure != null);
2958 processor.forEachAssertedStatement(this, subject, relation, procedure);
2963 public void forEachAssertedStatement(Resource subject, Resource relation,
2964 SyncMultiProcedure<Statement> procedure) {
2965 forEachAssertedStatement(subject, relation,
2966 new SyncToAsyncMultiProcedure<Statement>(procedure));
2970 public void forEachAssertedStatement(Resource subject, Resource relation,
2971 MultiProcedure<Statement> procedure) {
2972 forEachAssertedStatement(subject, relation,
2973 new NoneToAsyncMultiProcedure<Statement>(procedure));
2977 public void forAssertedStatementSet(Resource subject, Resource relation,
2978 AsyncSetListener<Statement> procedure) {
2980 assert (subject != null);
2981 assert (relation != null);
2982 assert (procedure != null);
2984 processor.forAssertedStatementSet(this, subject, relation, procedure);
2989 public void forAssertedStatementSet(Resource subject, Resource relation,
2990 SyncSetListener<Statement> procedure) {
2992 assert (subject != null);
2993 assert (relation != null);
2994 assert (procedure != null);
2996 forAssertedStatementSet(subject, relation,
2997 new SyncToAsyncSetProcedure<Statement>(procedure));
3002 public void forAssertedStatementSet(Resource subject, Resource relation,
3003 SetListener<Statement> procedure) {
3005 assert (subject != null);
3006 assert (relation != null);
3007 assert (procedure != null);
3009 forAssertedStatementSet(subject, relation,
3010 new NoneToAsyncSetProcedure<Statement>(procedure));
3015 final public void forEachPredicate(final Resource subject,
3016 final AsyncMultiProcedure<Resource> procedure) {
3018 assert (subject != null);
3019 assert (procedure != null);
3021 processor.forEachPredicate(this, subject, procedure);
3026 public void forEachPredicate(Resource subject,
3027 SyncMultiProcedure<Resource> procedure) {
3028 forEachPredicate(subject, new SyncToAsyncMultiProcedure<Resource>(
3033 final public void forEachPredicate(final Resource subject,
3034 final MultiProcedure<Resource> procedure) {
3036 assert (subject != null);
3037 assert (procedure != null);
3039 processor.forEachPredicate(this, subject, procedure);
3044 final public void forPredicateSet(final Resource subject,
3045 final AsyncSetListener<Resource> procedure) {
3047 assert (subject != null);
3048 assert (procedure != null);
3050 processor.forPredicateSet(this, subject, procedure);
3055 final public void forPredicateSet(final Resource subject,
3056 final SyncSetListener<Resource> procedure) {
3058 assert (subject != null);
3059 assert (procedure != null);
3061 forPredicateSet(subject, new SyncToAsyncSetProcedure<Resource>(
3067 final public void forPredicateSet(final Resource subject,
3068 final SetListener<Resource> procedure) {
3070 assert (subject != null);
3071 assert (procedure != null);
3073 forPredicateSet(subject, new NoneToAsyncSetProcedure<Resource>(
3079 final public void forEachPrincipalType(final Resource subject,
3080 final AsyncMultiProcedure<Resource> procedure) {
3082 assert (subject != null);
3083 assert (procedure != null);
3085 processor.forEachPrincipalType(this, subject, procedure);
3090 public void forEachPrincipalType(Resource subject,
3091 SyncMultiProcedure<Resource> procedure) {
3092 forEachPrincipalType(subject, new SyncToAsyncMultiProcedure<Resource>(
3097 final public void forEachPrincipalType(final Resource subject,
3098 final MultiProcedure<Resource> procedure) {
3100 assert (subject != null);
3101 assert (procedure != null);
3103 processor.forEachPrincipalType(this, subject, procedure);
3108 final public void forPrincipalTypeSet(final Resource subject,
3109 final AsyncSetListener<Resource> procedure) {
3111 assert (subject != null);
3112 assert (procedure != null);
3114 processor.forPrincipalTypeSet(this, subject, procedure);
3119 final public void forPrincipalTypeSet(final Resource subject,
3120 final SyncSetListener<Resource> procedure) {
3122 assert (subject != null);
3123 assert (procedure != null);
3125 forPrincipalTypeSet(subject, new SyncToAsyncSetProcedure<Resource>(
3131 final public void forPrincipalTypeSet(final Resource subject,
3132 final SetListener<Resource> procedure) {
3134 assert (subject != null);
3135 assert (procedure != null);
3137 forPrincipalTypeSet(subject, new NoneToAsyncSetProcedure<Resource>(
3143 public void forTypes(Resource subject, AsyncListener<Set<Resource>> listener) {
3144 asyncRequest(new Types(subject), listener);
3148 public void forTypes(Resource subject, SyncListener<Set<Resource>> listener) {
3149 asyncRequest(new Types(subject), listener);
3153 public void forTypes(Resource subject, Listener<Set<Resource>> listener) {
3154 asyncRequest(new Types(subject), listener);
3158 final public void forTypes(final Resource subject,
3159 final AsyncProcedure<Set<Resource>> procedure) {
3161 assert (subject != null);
3162 assert (procedure != null);
3164 processor.forTypes(this, subject, procedure);
3169 public void forTypes(Resource subject,
3170 SyncProcedure<Set<Resource>> procedure) {
3171 forTypes(subject, new SyncToAsyncProcedure<Set<Resource>>(procedure));
3175 public void forTypes(Resource subject, Procedure<Set<Resource>> procedure) {
3176 forTypes(subject, new NoneToAsyncProcedure<Set<Resource>>(procedure));
3180 public void forSupertypes(Resource subject,
3181 AsyncListener<Set<Resource>> listener) {
3182 asyncRequest(new Types(subject), listener);
3186 public void forSupertypes(Resource subject,
3187 SyncListener<Set<Resource>> listener) {
3188 asyncRequest(new Types(subject), listener);
3192 public void forSupertypes(Resource subject, Listener<Set<Resource>> listener) {
3193 asyncRequest(new Types(subject), listener);
3197 final public void forSupertypes(final Resource subject,
3198 final AsyncProcedure<Set<Resource>> procedure) {
3200 assert (subject != null);
3201 assert (procedure != null);
3203 processor.forSupertypes(this, subject, procedure);
3208 public void forSupertypes(Resource subject,
3209 SyncProcedure<Set<Resource>> procedure) {
3210 forSupertypes(subject, new SyncToAsyncProcedure<Set<Resource>>(
3215 public void forSupertypes(Resource subject,
3216 Procedure<Set<Resource>> procedure) {
3217 forSupertypes(subject, new NoneToAsyncProcedure<Set<Resource>>(
3222 public void forDirectSuperrelations(Resource subject,
3223 AsyncMultiProcedure<Resource> procedure) {
3225 assert (subject != null);
3226 assert (procedure != null);
3228 processor.forDirectSuperrelations(this, subject, procedure);
3233 public void forPossibleSuperrelation(Resource subject, AsyncProcedure<Resource> procedure) {
3235 assert (subject != null);
3236 assert (procedure != null);
3238 processor.forPossibleSuperrelation(this, subject, procedure);
3243 public void forSuperrelations(Resource subject,
3244 AsyncListener<Set<Resource>> listener) {
3245 asyncRequest(new Types(subject), listener);
3249 public void forSuperrelations(Resource subject,
3250 SyncListener<Set<Resource>> listener) {
3251 asyncRequest(new Types(subject), listener);
3255 public void forSuperrelations(Resource subject,
3256 Listener<Set<Resource>> listener) {
3257 asyncRequest(new Types(subject), listener);
3261 final public void forSuperrelations(final Resource subject,
3262 final AsyncProcedure<Set<Resource>> procedure) {
3264 assert (subject != null);
3265 assert (procedure != null);
3267 processor.forSuperrelations(this, subject, procedure);
3272 public void forSuperrelations(Resource subject,
3273 SyncProcedure<Set<Resource>> procedure) {
3274 forSuperrelations(subject, new SyncToAsyncProcedure<Set<Resource>>(
3279 public void forSuperrelations(Resource subject,
3280 Procedure<Set<Resource>> procedure) {
3281 forSuperrelations(subject, new NoneToAsyncProcedure<Set<Resource>>(
3286 final public void forEachObject(final Resource subject, final Resource relation, final AsyncMultiProcedure<Resource> procedure) {
3287 processor.forEachObject(this, subject, relation, procedure);
3291 public void forEachObject(Resource subject, Resource relation,
3292 SyncMultiProcedure<Resource> procedure) {
3293 forEachObject(subject, relation,
3294 new SyncToAsyncMultiProcedure<Resource>(procedure));
3298 public void forEachObject(Resource subject, Resource relation,
3299 MultiProcedure<Resource> procedure) {
3301 processor.forEachObject(this, subject, relation, procedure);
3306 // final public void forEachDirectObject(final Resource subject,
3307 // final Resource relation,
3308 // final AsyncMultiProcedure<Resource> procedure) {
3310 // processor.forEachDirectObject(this, subject, relation, procedure);
3315 // public void forEachDirectObject(Resource subject, Resource relation,
3316 // SyncMultiProcedure<Resource> procedure) {
3317 // forEachDirectObject(subject, relation,
3318 // new SyncToAsyncMultiProcedure<Resource>(procedure));
3322 // public void forEachDirectObject(Resource subject, Resource relation,
3323 // MultiProcedure<Resource> procedure) {
3324 // forEachDirectObject(subject, relation,
3325 // new NoneToAsyncMultiProcedure<Resource>(procedure));
3329 final public void forEachDirectPredicate(final Resource subject, final AsyncMultiProcedure<Resource> procedure) {
3330 processor.forEachDirectPredicate(this, subject, procedure);
3334 public void forEachDirectPredicate(Resource subject, SyncMultiProcedure<Resource> procedure) {
3335 forEachDirectPredicate(subject, new SyncToAsyncMultiProcedure<Resource>(procedure));
3339 public void forEachDirectPredicate(Resource subject, MultiProcedure<Resource> procedure) {
3340 forEachDirectPredicate(subject, new NoneToAsyncMultiProcedure<Resource>(procedure));
3344 final public void forObjectSet(final Resource subject,
3345 final Resource relation, final AsyncSetListener<Resource> procedure) {
3347 assert (subject != null);
3348 assert (relation != null);
3349 assert (procedure != null);
3351 processor.forObjectSet(this, subject, relation, procedure);
3356 final public void forObjectSet(final Resource subject,
3357 final Resource relation, final SyncSetListener<Resource> procedure) {
3359 assert (subject != null);
3360 assert (relation != null);
3361 assert (procedure != null);
3363 forObjectSet(subject, relation, new SyncToAsyncSetProcedure<Resource>(
3369 final public void forObjectSet(final Resource subject,
3370 final Resource relation, final SetListener<Resource> procedure) {
3372 assert (subject != null);
3373 assert (relation != null);
3374 assert (procedure != null);
3376 forObjectSet(subject, relation, new NoneToAsyncSetProcedure<Resource>(
3382 final public void forEachAssertedObject(final Resource subject,
3383 final Resource relation,
3384 final AsyncMultiProcedure<Resource> procedure) {
3386 assert (subject != null);
3387 assert (relation != null);
3388 assert (procedure != null);
3390 processor.forEachAssertedObject(this, subject, relation, procedure);
3395 public void forEachAssertedObject(Resource subject, Resource relation,
3396 SyncMultiProcedure<Resource> procedure) {
3398 assert (subject != null);
3399 assert (relation != null);
3400 assert (procedure != null);
3402 forEachAssertedObject(subject, relation,
3403 new SyncToAsyncMultiProcedure<Resource>(procedure));
3408 public void forEachAssertedObject(Resource subject, Resource relation,
3409 MultiProcedure<Resource> procedure) {
3411 assert (subject != null);
3412 assert (relation != null);
3413 assert (procedure != null);
3415 forEachAssertedObject(subject, relation,
3416 new NoneToAsyncMultiProcedure<Resource>(procedure));
3421 public void forAssertedObjectSet(Resource subject, Resource relation,
3422 AsyncSetListener<Resource> procedure) {
3424 assert (subject != null);
3425 assert (relation != null);
3426 assert (procedure != null);
3428 processor.forAssertedObjectSet(this, subject, relation, procedure);
3433 public void forAssertedObjectSet(Resource subject, Resource relation,
3434 SyncSetListener<Resource> procedure) {
3436 assert (subject != null);
3437 assert (relation != null);
3438 assert (procedure != null);
3440 forAssertedObjectSet(subject, relation,
3441 new SyncToAsyncSetProcedure<Resource>(procedure));
3446 public void forAssertedObjectSet(Resource subject, Resource relation,
3447 SetListener<Resource> procedure) {
3449 assert (subject != null);
3450 assert (relation != null);
3451 assert (procedure != null);
3453 forAssertedObjectSet(subject, relation,
3454 new NoneToAsyncSetProcedure<Resource>(procedure));
3459 public void forInverse(Resource relation, AsyncListener<Resource> listener) {
3460 asyncRequest(new Inverse(relation), listener);
3464 public void forInverse(Resource relation, SyncListener<Resource> listener) {
3465 asyncRequest(new Inverse(relation), listener);
3469 public void forInverse(Resource relation, Listener<Resource> listener) {
3470 asyncRequest(new Inverse(relation), listener);
3474 final public void forInverse(final Resource relation,
3475 final AsyncProcedure<Resource> procedure) {
3477 assert (relation != null);
3478 assert (procedure != null);
3480 processor.forInverse(this, relation, new AsyncProcedure<Resource>() {
3483 public void execute(AsyncReadGraph graph, Resource result) {
3485 procedure.execute(graph, result);
3487 procedure.exception(graph, new NoInverseException(relation
3493 public void exception(AsyncReadGraph graph, Throwable throwable) {
3494 procedure.exception(graph, throwable);
3498 public String toString() {
3499 return "forInverse -> " + procedure;
3507 public void forInverse(Resource relation, SyncProcedure<Resource> procedure) {
3508 forInverse(relation, new SyncToAsyncProcedure<Resource>(procedure));
3512 public void forInverse(Resource relation, Procedure<Resource> procedure) {
3513 forInverse(relation, new NoneToAsyncProcedure<Resource>(procedure));
3517 public void forSingleObject(Resource subject, Resource relation,
3518 AsyncListener<Resource> listener) {
3519 asyncRequest(new SingleObject(subject, relation), listener);
3523 public void forSingleObject(Resource subject, Resource relation,
3524 SyncListener<Resource> listener) {
3525 asyncRequest(new SingleObject(subject, relation), listener);
3529 public void forSingleObject(Resource subject, Resource relation,
3530 Listener<Resource> listener) {
3531 asyncRequest(new SingleObject(subject, relation), listener);
3535 final public void forSingleObject(final Resource subject,
3536 final Resource relation, final AsyncProcedure<Resource> procedure) {
3538 assert (subject != null);
3539 assert (relation != null);
3540 assert (procedure != null);
3542 processor.forEachObject(this, subject, relation,
3543 new SingleOrErrorProcedure<Resource>(procedure));
3548 public void forSingleObject(Resource subject, Resource relation,
3549 SyncProcedure<Resource> procedure) {
3550 forSingleObject(subject, relation, new SyncToAsyncProcedure<Resource>(
3555 public void forSingleObject(Resource subject, Resource relation,
3556 Procedure<Resource> procedure) {
3557 forSingleObject(subject, relation, new NoneToAsyncProcedure<Resource>(
3562 public void forSingleStatement(Resource subject, Resource relation,
3563 AsyncListener<Statement> listener) {
3564 asyncRequest(new SingleStatement(subject, relation), listener);
3568 public void forSingleStatement(Resource subject, Resource relation,
3569 SyncListener<Statement> listener) {
3570 asyncRequest(new SingleStatement(subject, relation), listener);
3574 public void forSingleStatement(Resource subject, Resource relation,
3575 Listener<Statement> listener) {
3576 asyncRequest(new SingleStatement(subject, relation), listener);
3580 final public void forSingleStatement(final Resource subject,
3581 final Resource relation, final AsyncProcedure<Statement> procedure) {
3583 assert (subject != null);
3584 assert (relation != null);
3585 assert (procedure != null);
3587 processor.forEachStatement(this, subject, relation,
3588 new SingleOrErrorProcedure<Statement>(procedure));
3593 public void forSingleStatement(Resource subject, Resource relation,
3594 SyncProcedure<Statement> procedure) {
3595 forSingleStatement(subject, relation,
3596 new SyncToAsyncProcedure<Statement>(procedure));
3600 public void forSingleStatement(Resource subject, Resource relation,
3601 Procedure<Statement> procedure) {
3602 forSingleStatement(subject, relation,
3603 new NoneToAsyncProcedure<Statement>(procedure));
3607 public void forSingleType(Resource subject,
3608 AsyncListener<Resource> listener) {
3609 asyncRequest(new SingleTypeAny(subject), listener);
3613 public void forSingleType(Resource subject,
3614 SyncListener<Resource> listener) {
3615 asyncRequest(new SingleTypeAny(subject), listener);
3619 public void forSingleType(Resource subject,
3620 Listener<Resource> listener) {
3621 asyncRequest(new SingleTypeAny(subject), listener);
3625 final public void forSingleType(final Resource subject, final AsyncProcedure<Resource> procedure) {
3627 assert (subject != null);
3628 assert (procedure != null);
3630 final DeepSingleOrErrorProcedure<Resource> checkedProcedure = new DeepSingleOrErrorProcedure<Resource>(procedure);
3632 processor.forEachPrincipalType(this, subject, new AsyncMultiProcedureAdapter<Resource>() {
3635 public void execute(AsyncReadGraph graph, final Resource principalType) {
3636 checkedProcedure.offer(graph, principalType);
3640 public void finished(AsyncReadGraph graph) {
3641 checkedProcedure.dec(graph);
3645 public void exception(AsyncReadGraph graph, Throwable t) {
3646 checkedProcedure.exception(graph, t);
3650 public String toString() {
3651 return "forSingleType -> " + procedure;
3659 public void forSingleType(Resource subject, SyncProcedure<Resource> procedure) {
3660 forSingleType(subject, new SyncToAsyncProcedure<Resource>(
3665 public void forSingleType(Resource subject, Procedure<Resource> procedure) {
3666 forSingleType(subject, new NoneToAsyncProcedure<Resource>(
3671 public void forSingleType(Resource subject, Resource relation,
3672 AsyncListener<Resource> listener) {
3673 asyncRequest(new SingleType(subject, relation), listener);
3677 public void forSingleType(Resource subject, Resource relation,
3678 SyncListener<Resource> listener) {
3679 asyncRequest(new SingleType(subject, relation), listener);
3683 public void forSingleType(Resource subject, Resource relation,
3684 Listener<Resource> listener) {
3685 asyncRequest(new SingleType(subject, relation), listener);
3689 final public void forSingleType(final Resource subject,
3690 final Resource baseType, final AsyncProcedure<Resource> procedure) {
3692 assert (subject != null);
3693 assert (procedure != null);
3695 final DeepSingleOrErrorProcedure<Resource> checkedProcedure = new DeepSingleOrErrorProcedure<Resource>(procedure);
3697 processor.forEachPrincipalType(this, subject,
3698 new AsyncMultiProcedureAdapter<Resource>() {
3701 public void execute(AsyncReadGraph graph,
3702 final Resource principalType) {
3704 checkedProcedure.inc();
3706 if(baseType == null) {
3708 checkedProcedure.offer(graph, principalType);
3709 checkedProcedure.dec(graph);
3711 } else if(principalType.equals(baseType)) {
3713 checkedProcedure.offer(graph, principalType);
3714 checkedProcedure.dec(graph);
3718 processor.forSupertypes((ReadGraphImpl)graph, principalType,
3719 new AsyncProcedure<Set<Resource>>() {
3722 public void execute(
3723 AsyncReadGraph graph,
3724 Set<Resource> result) {
3726 if (result.contains(baseType))
3727 checkedProcedure.offer(graph,
3729 checkedProcedure.dec(graph);
3734 public void exception(
3735 AsyncReadGraph graph,
3738 .exception(graph, t);
3748 public void finished(AsyncReadGraph graph) {
3749 checkedProcedure.dec(graph);
3753 public void exception(AsyncReadGraph graph, Throwable t) {
3754 checkedProcedure.exception(graph, t);
3758 public String toString() {
3759 return "forSingleType -> " + procedure;
3767 public void forSingleType(Resource subject, Resource relation,
3768 SyncProcedure<Resource> procedure) {
3769 forSingleType(subject, relation, new SyncToAsyncProcedure<Resource>(
3774 public void forSingleType(Resource subject, Resource relation,
3775 Procedure<Resource> procedure) {
3776 forSingleType(subject, relation, new NoneToAsyncProcedure<Resource>(
3781 public <T> void forValue(Resource subject, Binding binding,
3782 AsyncListener<T> listener) {
3783 asyncRequest(new Value<T>(subject, binding), listener);
3787 public <T> void forValue(Resource subject, Binding binding,
3788 SyncListener<T> listener) {
3789 asyncRequest(new Value<T>(subject, binding), listener);
3793 public <T> void forValue(Resource subject, Binding binding,
3794 Listener<T> listener) {
3795 asyncRequest(new Value<T>(subject, binding), listener);
3799 public <T> void forValue(final Resource resource, final Binding binding,
3800 final AsyncProcedure<T> procedure) {
3802 assert (resource != null);
3803 assert (binding != null);
3804 assert (procedure != null);
3806 processor.forValue(this, resource, new AsyncProcedure<byte[]>() {
3809 public void execute(AsyncReadGraph graph, byte[] result) {
3813 if (result == null) {
3814 procedure.exception(graph,
3815 new DoesNotContainValueException(
3816 "No value for resource " + resource));
3820 Serializer serializer = binding.serializer();
3821 // Serializer serializer = Bindings.getSerializer( binding );
3822 Object obj = serializer.deserialize(result);
3823 // if (!binding.isInstance(obj))
3824 // procedure.exception(graph, new ClassCastException(
3825 // "Cannot get value " + obj + " with binding "
3828 procedure.execute(graph, (T) obj);
3830 } catch (IOException e) {
3831 procedure.exception(graph, e);
3832 } catch (BufferUnderflowException e) {
3833 procedure.exception(graph, e);
3834 } catch (Throwable t) {
3835 procedure.exception(graph, t);
3841 public void exception(AsyncReadGraph graph, Throwable t) {
3843 procedure.exception(graph, t);
3844 } catch (Throwable t2) {
3845 Logger.defaultLogError(t2);
3850 public String toString() {
3851 return "forValue -> " + procedure;
3859 public <T> void forValue(Resource subject, Binding binding,
3860 SyncProcedure<T> procedure) {
3861 forValue(subject, binding, new SyncToAsyncProcedure<T>(procedure));
3865 public <T> void forValue(Resource subject, Binding binding,
3866 Procedure<T> procedure) {
3867 forValue(subject, binding, new NoneToAsyncProcedure<T>(procedure));
3871 public <T> void forValue(Resource subject, AsyncListener<T> listener) {
3872 asyncRequest(new ValueImplied<T>(subject), listener);
3876 public <T> void forValue(Resource subject, SyncListener<T> listener) {
3877 asyncRequest(new ValueImplied<T>(subject), listener);
3881 public <T> void forValue(Resource subject, Listener<T> listener) {
3882 asyncRequest(new ValueImplied<T>(subject), listener);
3886 final public <T> void forValue(final Resource subject, final AsyncProcedure<T> procedure) {
3888 assert (subject != null);
3889 assert (procedure != null);
3891 forRelatedValue(subject, processor.getL0(this).HasDataType, DATA_TYPE_BINDING_INTERNAL, new AsyncProcedure<Datatype>() {
3894 public void execute(AsyncReadGraph graph, Datatype type) {
3895 // TODO: consider trying Bindings.getBeanBinding(type);
3896 Binding binding = Bindings.getBinding(type);
3897 graph.forValue(subject, binding, procedure);
3901 public void exception(AsyncReadGraph graph, Throwable throwable) {
3902 procedure.exception(graph, new DoesNotContainValueException("Invalid data type", throwable));
3910 public <T> void forValue(Resource subject, SyncProcedure<T> procedure) {
3911 forValue(subject, new SyncToAsyncProcedure<T>(procedure));
3915 public <T> void forValue(Resource subject, Procedure<T> procedure) {
3916 forValue(subject, new NoneToAsyncProcedure<T>(procedure));
3920 public <T> void forRelatedValue(Resource subject, Resource relation,
3921 AsyncListener<T> listener) {
3922 asyncRequest(new RelatedValueImplied<T>(subject, relation), listener);
3926 public <T> void forRelatedValue(Resource subject, Resource relation,
3927 SyncListener<T> listener) {
3928 asyncRequest(new RelatedValueImplied<T>(subject, relation), listener);
3932 public <T> void forRelatedValue(Resource subject, Resource relation,
3933 Listener<T> listener) {
3934 asyncRequest(new RelatedValueImplied<T>(subject, relation), listener);
3938 final public <T> void forRelatedValue(final Resource subject,
3939 final Resource relation, final AsyncProcedure<T> procedure) {
3941 assert (subject != null);
3942 assert (relation != null);
3943 assert (procedure != null);
3945 final DeepSingleOrErrorProcedure<T> checkedProcedure = new DeepSingleOrErrorProcedure<T>(procedure);
3947 processor.forEachObject(this, subject, relation,
3948 new AsyncMultiProcedureAdapter<Resource>() {
3951 public void execute(AsyncReadGraph graph,
3952 final Resource object) {
3954 checkedProcedure.inc();
3956 graph.forValue(object, new AsyncProcedure<Object>() {
3959 public void execute(AsyncReadGraph graph,
3961 checkedProcedure.offer(graph, (T) result);
3962 checkedProcedure.dec(graph);
3966 public void exception(AsyncReadGraph graph,
3968 checkedProcedure.exception(graph, t);
3972 public String toString() {
3973 return "forRelatedValue -> " + procedure;
3981 public void finished(AsyncReadGraph graph) {
3982 checkedProcedure.dec(graph);
3986 public void exception(AsyncReadGraph graph, Throwable t) {
3987 checkedProcedure.exception(graph, t);
3995 public <T> void forRelatedValue(Resource subject, Resource relation,
3996 SyncProcedure<T> procedure) {
3997 forRelatedValue(subject, relation, new SyncToAsyncProcedure<T>(
4002 public <T> void forRelatedValue(Resource subject, Resource relation,
4003 Procedure<T> procedure) {
4004 forRelatedValue(subject, relation, new NoneToAsyncProcedure<T>(
4009 public <T> void forRelatedValue(Resource subject, Resource relation,
4010 Binding binding, AsyncListener<T> listener) {
4011 asyncRequest(new RelatedValue<T>(subject, relation, binding), listener);
4015 public <T> void forRelatedValue(Resource subject, Resource relation,
4016 Binding binding, SyncListener<T> listener) {
4017 asyncRequest(new RelatedValue<T>(subject, relation, binding), listener);
4021 public <T> void forRelatedValue(Resource subject, Resource relation,
4022 Binding binding, Listener<T> listener) {
4023 asyncRequest(new RelatedValue<T>(subject, relation, binding), listener);
4027 final public <T> void forRelatedValue(final Resource subject,
4028 final Resource relation, final Binding binding,
4029 final AsyncProcedure<T> procedure) {
4031 assert (subject != null);
4032 assert (relation != null);
4033 assert (binding != null);
4034 assert (procedure != null);
4036 final DeepSingleOrErrorProcedure<T> checkedProcedure = new DeepSingleOrErrorProcedure<T>(procedure);
4038 processor.forEachObject(this, subject, relation,
4039 new AsyncMultiProcedureAdapter<Resource>() {
4042 public void execute(AsyncReadGraph graph,
4043 final Resource object) {
4045 checkedProcedure.inc();
4047 graph.forValue(object, binding, new AsyncProcedure<Object>() {
4050 public void execute(AsyncReadGraph graph,
4053 checkedProcedure.offer(graph,
4055 checkedProcedure.dec(graph);
4059 public void exception(AsyncReadGraph graph,
4061 checkedProcedure.exception(graph, t);
4065 public String toString() {
4066 return "forRelatedValue -> "
4075 public void finished(AsyncReadGraph graph) {
4076 checkedProcedure.dec(graph);
4080 public void exception(AsyncReadGraph graph, Throwable t) {
4081 checkedProcedure.exception(graph, t);
4089 public <T> void forRelatedValue(Resource subject, Resource relation,
4090 Binding binding, SyncProcedure<T> procedure) {
4091 forRelatedValue(subject, relation, binding,
4092 new SyncToAsyncProcedure<T>(procedure));
4096 public <T> void forRelatedValue(Resource subject, Resource relation,
4097 Binding binding, Procedure<T> procedure) {
4098 forRelatedValue(subject, relation, binding,
4099 new NoneToAsyncProcedure<T>(procedure));
4103 public <T> void forAdapted(Resource resource, Class<T> clazz,
4104 AsyncListener<T> listener) {
4105 asyncRequest(new Adapter<T>(resource, clazz), listener);
4109 public <T> void forAdapted(Resource resource, Class<T> clazz,
4110 SyncListener<T> listener) {
4111 asyncRequest(new Adapter<T>(resource, clazz), listener);
4115 public <T> void forAdapted(Resource resource, Class<T> clazz,
4116 Listener<T> listener) {
4117 asyncRequest(new Adapter<T>(resource, clazz), listener);
4121 final public <T> void forAdapted(final Resource resource,
4122 final Class<T> clazz, final AsyncProcedure<T> procedure) {
4124 assert (resource != null);
4125 assert (clazz != null);
4126 assert (procedure != null);
4128 final AdaptionService service = getSession().peekService(AdaptionService.class);
4129 if (service == null)
4130 procedure.exception(this, new ServiceException("No AdaptionService available"));
4132 service.adapt(this, resource, resource, Resource.class, clazz, false, procedure);
4137 public <T> void forAdapted(Resource resource, Class<T> clazz,
4138 SyncProcedure<T> procedure) {
4139 forAdapted(resource, clazz, new SyncToAsyncProcedure<T>(procedure));
4143 public <T> void forAdapted(Resource resource, Class<T> clazz,
4144 Procedure<T> procedure) {
4145 forAdapted(resource, clazz, new NoneToAsyncProcedure<T>(procedure));
4149 public <T> void forUniqueAdapted(Resource resource, Class<T> clazz,
4150 AsyncListener<T> listener) {
4151 asyncRequest(new UniqueAdapter<T>(resource, clazz), listener);
4155 public <T> void forUniqueAdapted(Resource resource, Class<T> clazz,
4156 SyncListener<T> listener) {
4157 asyncRequest(new UniqueAdapter<T>(resource, clazz), listener);
4161 public <T> void forUniqueAdapted(Resource resource, Class<T> clazz,
4162 Listener<T> listener) {
4163 asyncRequest(new UniqueAdapter<T>(resource, clazz), listener);
4167 final public <T> void forUniqueAdapted(final Resource resource,
4168 final Class<T> clazz, final AsyncProcedure<T> procedure) {
4170 assert (resource != null);
4171 assert (clazz != null);
4172 assert (procedure != null);
4174 final AdaptionService service = getSession().peekService(AdaptionService.class);
4175 if (service == null)
4176 procedure.exception(this, new ServiceException("No AdaptionService available"));
4178 service.adaptNew(this, resource, clazz, false, procedure);
4183 public <T> void forUniqueAdapted(Resource resource, Class<T> clazz,
4184 SyncProcedure<T> procedure) {
4185 forUniqueAdapted(resource, clazz,
4186 new SyncToAsyncProcedure<T>(procedure));
4190 public <T> void forUniqueAdapted(Resource resource, Class<T> clazz,
4191 Procedure<T> procedure) {
4192 forUniqueAdapted(resource, clazz,
4193 new NoneToAsyncProcedure<T>(procedure));
4197 public void forPossibleInverse(Resource subject,
4198 AsyncListener<Resource> listener) {
4199 asyncRequest(new PossibleInverse(subject), listener);
4203 public void forPossibleInverse(Resource subject,
4204 SyncListener<Resource> listener) {
4205 asyncRequest(new PossibleInverse(subject), listener);
4209 public void forPossibleInverse(Resource subject, Listener<Resource> listener) {
4210 asyncRequest(new PossibleInverse(subject), listener);
4214 final public void forPossibleInverse(final Resource relation,
4215 final AsyncProcedure<Resource> procedure) {
4217 assert (relation != null);
4218 assert (procedure != null);
4220 processor.forInverse(this, relation, new ExceptionToNullProcedure<Resource>(procedure));
4225 public void forPossibleInverse(Resource subject,
4226 SyncProcedure<Resource> procedure) {
4227 forPossibleInverse(subject, new SyncToAsyncProcedure<Resource>(
4232 public void forPossibleInverse(Resource subject,
4233 Procedure<Resource> procedure) {
4234 forPossibleInverse(subject, new NoneToAsyncProcedure<Resource>(
4239 public void forPossibleObject(Resource subject, Resource relation,
4240 AsyncListener<Resource> listener) {
4241 asyncRequest(new PossibleObject(subject, relation), listener);
4245 public void forPossibleObject(Resource subject, Resource relation,
4246 SyncListener<Resource> listener) {
4247 asyncRequest(new PossibleObject(subject, relation), listener);
4251 public void forPossibleObject(Resource subject, Resource relation,
4252 Listener<Resource> listener) {
4253 asyncRequest(new PossibleObject(subject, relation), listener);
4257 final public void forPossibleObject(final Resource subject,
4258 final Resource relation, final AsyncProcedure<Resource> procedure) {
4260 assert (subject != null);
4261 assert (relation != null);
4262 assert (procedure != null);
4264 processor.forEachObject(this, subject, relation,
4265 new SingleOrNullProcedure<Resource>(procedure));
4270 public void forPossibleObject(Resource subject, Resource relation,
4271 SyncProcedure<Resource> procedure) {
4272 forPossibleObject(subject, relation,
4273 new SyncToAsyncProcedure<Resource>(procedure));
4277 public void forPossibleObject(Resource subject, Resource relation,
4278 Procedure<Resource> procedure) {
4279 forPossibleObject(subject, relation,
4280 new NoneToAsyncProcedure<Resource>(procedure));
4284 public void forPossibleStatement(Resource subject, Resource relation,
4285 AsyncListener<Statement> listener) {
4286 asyncRequest(new PossibleStatement(subject, relation), listener);
4290 public void forPossibleStatement(Resource subject, Resource relation,
4291 SyncListener<Statement> listener) {
4292 asyncRequest(new PossibleStatement(subject, relation), listener);
4296 public void forPossibleStatement(Resource subject, Resource relation,
4297 Listener<Statement> listener) {
4298 asyncRequest(new PossibleStatement(subject, relation), listener);
4302 final public void forPossibleStatement(final Resource subject,
4303 final Resource relation, final AsyncProcedure<Statement> procedure) {
4305 assert (subject != null);
4306 assert (relation != null);
4307 assert (procedure != null);
4309 processor.forEachStatement(this, subject, relation,
4310 new SingleFunctionalOrNullProcedure<Statement>(
4311 "forPossibleStatement", procedure));
4316 public void forPossibleStatement(Resource subject, Resource relation,
4317 SyncProcedure<Statement> procedure) {
4318 forPossibleStatement(subject, relation,
4319 new SyncToAsyncProcedure<Statement>(procedure));
4323 public void forPossibleStatement(Resource subject, Resource relation,
4324 Procedure<Statement> procedure) {
4325 forPossibleStatement(subject, relation,
4326 new NoneToAsyncProcedure<Statement>(procedure));
4330 public void forPossibleType(Resource subject, Resource relation,
4331 AsyncListener<Resource> listener) {
4332 asyncRequest(new PossibleType(subject, relation), listener);
4336 public void forPossibleType(Resource subject, Resource relation,
4337 SyncListener<Resource> listener) {
4338 asyncRequest(new PossibleType(subject, relation), listener);
4342 public void forPossibleType(Resource subject, Resource relation,
4343 Listener<Resource> listener) {
4344 asyncRequest(new PossibleType(subject, relation), listener);
4348 final public void forPossibleType(final Resource subject,
4349 final Resource baseType, final AsyncProcedure<Resource> procedure) {
4351 assert (subject != null);
4352 assert (procedure != null);
4354 final NullSingleOrNullProcedure<Resource> checkedProcedure = new NullSingleOrNullProcedure<Resource>(procedure);
4356 processor.forEachPrincipalType(this, subject, new AsyncMultiProcedureAdapter<Resource>() {
4359 public void execute(AsyncReadGraph graph,
4360 final Resource principalType) {
4362 if (baseType == null) {
4364 checkedProcedure.offer(graph, principalType);
4366 } else if (principalType.equals(baseType)) {
4368 checkedProcedure.offer(graph, principalType);
4372 checkedProcedure.inc();
4374 processor.forSupertypes((ReadGraphImpl)graph, principalType,
4375 new AsyncProcedure<Set<Resource>>() {
4378 public void execute(
4379 AsyncReadGraph graph,
4380 Set<Resource> result) {
4382 if (result.contains(baseType)) {
4383 checkedProcedure.offer(graph,
4387 checkedProcedure.dec(graph);
4392 public void exception(
4393 AsyncReadGraph graph,
4395 checkedProcedure.exception(graph, t);
4396 checkedProcedure.dec(graph);
4400 public String toString() {
4401 return "forPossibleType -> "
4412 public void finished(AsyncReadGraph graph) {
4413 checkedProcedure.dec(graph);
4417 public void exception(AsyncReadGraph graph, Throwable t) {
4418 checkedProcedure.exception(graph, t);
4419 checkedProcedure.dec(graph);
4427 public void forPossibleType(Resource subject, Resource relation,
4428 SyncProcedure<Resource> procedure) {
4429 forPossibleType(subject, relation, new SyncToAsyncProcedure<Resource>(
4434 public void forPossibleType(Resource subject, Resource relation,
4435 Procedure<Resource> procedure) {
4436 forPossibleType(subject, relation, new NoneToAsyncProcedure<Resource>(
4441 public <T> void forPossibleValue(Resource subject, AsyncListener<T> listener) {
4442 asyncRequest(new PossibleValueImplied<T>(subject), listener);
4446 public <T> void forPossibleValue(Resource subject, SyncListener<T> listener) {
4447 asyncRequest(new PossibleValueImplied<T>(subject), listener);
4451 public <T> void forPossibleValue(Resource subject, Listener<T> listener) {
4452 asyncRequest(new PossibleValueImplied<T>(subject), listener);
4456 final public <T> void forPossibleValue(final Resource subject,
4457 final AsyncProcedure<T> procedure) {
4459 assert (subject != null);
4460 assert (procedure != null);
4462 forPossibleRelatedValue(subject, processor.getL0(this).HasDataType, DATA_TYPE_BINDING_INTERNAL, new AsyncProcedure<Datatype>() {
4465 public void execute(AsyncReadGraph graph, final Datatype type) {
4467 procedure.execute(graph, null);
4470 // TODO: consider trying Bindings.getBeanBinding(type);
4471 Binding binding = Bindings.getBinding(type);
4472 graph.forPossibleValue(subject, binding, procedure);
4473 } catch (RuntimeBindingConstructionException e) {
4474 procedure.exception(graph, e);
4480 public void exception(AsyncReadGraph graph, Throwable t) {
4481 procedure.exception(graph, t);
4485 public String toString() {
4486 return "forPossibleValue -> " + procedure;
4494 public <T> void forPossibleValue(Resource subject,
4495 SyncProcedure<T> procedure) {
4496 forPossibleValue(subject, new SyncToAsyncProcedure<T>(procedure));
4500 public <T> void forPossibleValue(Resource subject, Procedure<T> procedure) {
4501 forPossibleValue(subject, new NoneToAsyncProcedure<T>(procedure));
4505 public <T> void forPossibleValue(Resource subject, Binding binding,
4506 AsyncListener<T> listener) {
4507 asyncRequest(new PossibleValue<T>(subject, binding), listener);
4511 public <T> void forPossibleValue(Resource subject, Binding binding,
4512 SyncListener<T> listener) {
4513 asyncRequest(new PossibleValue<T>(subject, binding), listener);
4517 public <T> void forPossibleValue(Resource subject, Binding binding,
4518 Listener<T> listener) {
4519 asyncRequest(new PossibleValue<T>(subject, binding), listener);
4523 final public <T> void forPossibleValue(final Resource resource,
4524 final Binding binding, final AsyncProcedure<T> procedure) {
4526 assert (resource != null);
4527 assert (binding != null);
4528 assert (procedure != null);
4530 processor.forValue(this, resource, new AsyncProcedure<byte[]>() {
4533 public void execute(AsyncReadGraph graph, byte[] result) {
4537 if (result == null) {
4538 procedure.execute(graph, null);
4542 Serializer serializer = Bindings.getSerializer( binding );
4543 Object obj = serializer.deserialize(result);
4544 if (!binding.isInstance(obj))
4545 procedure.exception(graph, new ClassCastException(
4546 "Cannot get value " + obj + " with binding "
4549 procedure.execute(graph, (T) obj);
4551 } catch (IOException e) {
4552 procedure.exception(graph, e);
4553 } catch (BufferUnderflowException e) {
4554 procedure.exception(graph, e);
4555 } catch (Throwable t) {
4556 procedure.exception(graph, t);
4562 public void exception(AsyncReadGraph graph, Throwable t) {
4564 procedure.exception(graph, t);
4565 } catch (Throwable t2) {
4566 Logger.defaultLogError(t2);
4571 public String toString() {
4572 return "forPossibleValue -> " + procedure;
4580 public <T> void forPossibleValue(Resource subject, Binding binding,
4581 SyncProcedure<T> procedure) {
4582 forPossibleValue(subject, binding, new SyncToAsyncProcedure<T>(
4587 public <T> void forPossibleValue(Resource subject, Binding binding,
4588 Procedure<T> procedure) {
4589 forPossibleValue(subject, binding, new NoneToAsyncProcedure<T>(
4594 public <T> void forPossibleRelatedValue(Resource subject,
4595 Resource relation, AsyncListener<T> listener) {
4596 asyncRequest(new PossibleRelatedValueImplied<T>(subject, relation),
4601 public <T> void forPossibleRelatedValue(Resource subject,
4602 Resource relation, SyncListener<T> listener) {
4603 asyncRequest(new PossibleRelatedValueImplied<T>(subject, relation),
4608 public <T> void forPossibleRelatedValue(Resource subject,
4609 Resource relation, Listener<T> listener) {
4610 asyncRequest(new PossibleRelatedValueImplied<T>(subject, relation),
4615 final public <T> void forPossibleRelatedValue(final Resource subject,
4616 final Resource relation, final AsyncProcedure<T> procedure) {
4618 assert (subject != null);
4619 assert (relation != null);
4620 assert (procedure != null);
4622 final DeepSingleOrNullProcedure<T> checkedProcedure = new DeepSingleOrNullProcedure<T>(procedure);
4624 processor.forEachObject(this, subject, relation,
4625 new AsyncMultiProcedureAdapter<Resource>() {
4628 public void execute(AsyncReadGraph graph,
4629 final Resource object) {
4631 checkedProcedure.inc();
4633 graph.forValue(object, new AsyncProcedure<Object>() {
4636 public void execute(AsyncReadGraph graph,
4638 checkedProcedure.offer(graph, (T) result);
4639 checkedProcedure.dec(graph);
4643 public void exception(AsyncReadGraph graph,
4645 checkedProcedure.exception(graph, t);
4646 checkedProcedure.dec(graph);
4654 public void finished(AsyncReadGraph graph) {
4656 checkedProcedure.dec(graph);
4660 public void exception(AsyncReadGraph graph, Throwable t) {
4661 checkedProcedure.exception(graph, t);
4662 checkedProcedure.dec(graph);
4666 public String toString() {
4667 return "forPossibleRelatedValue -> " + procedure;
4674 public <T> void forPossibleRelatedValue(Resource subject,
4675 Resource relation, SyncProcedure<T> procedure) {
4676 forPossibleRelatedValue(subject, relation, new SyncToAsyncProcedure<T>(
4681 public <T> void forPossibleRelatedValue(Resource subject,
4682 Resource relation, Procedure<T> procedure) {
4683 forPossibleRelatedValue(subject, relation, new NoneToAsyncProcedure<T>(
4688 public <T> void forPossibleRelatedValue(Resource subject,
4689 Resource relation, Binding binding, AsyncListener<T> listener) {
4690 asyncRequest(new PossibleRelatedValue<T>(subject, relation, binding),
4695 public <T> void forPossibleRelatedValue(Resource subject,
4696 Resource relation, Binding binding, SyncListener<T> listener) {
4697 asyncRequest(new PossibleRelatedValue<T>(subject, relation, binding),
4702 public <T> void forPossibleRelatedValue(Resource subject,
4703 Resource relation, Binding binding, Listener<T> listener) {
4704 asyncRequest(new PossibleRelatedValue<T>(subject, relation, binding),
4709 // final public <T> void forPossibleRelatedValue(final Resource subject, final Resource relation, final Binding binding,
4710 // final AsyncProcedure<T> procedure) {
4712 // forPossibleRelatedValue(subject, relation, binding, procedure, false);
4716 final public <T> void forPossibleRelatedValue(final Resource subject, final Resource relation, final Binding binding,
4717 final AsyncProcedure<T> procedure) {
4719 assert (subject != null);
4720 assert (relation != null);
4721 assert (procedure != null);
4723 processor.forPossibleObject(this, subject, relation, new AsyncProcedure<Resource>() {
4726 public void execute(AsyncReadGraph graph, Resource object) {
4728 if(object == null) {
4729 procedure.execute(graph, null);
4733 processor.forPossibleValue((ReadGraphImpl)graph, object, new AsyncProcedure<byte[]>() {
4736 public void execute(AsyncReadGraph graph, byte[] bytes) {
4742 Serializer serializer = binding.serializer();
4743 Object obj = serializer.deserialize(bytes);
4744 if (!binding.isInstance(obj)) {
4745 procedure.exception(graph, new ClassCastException("Cannot get value " + obj + " with binding " + binding));
4747 procedure.execute(graph, (T) obj);
4750 } catch (Throwable t) {
4752 procedure.exception(graph, t);
4758 procedure.execute(graph, null);
4765 public void exception(AsyncReadGraph graph, Throwable t) {
4766 procedure.exception(graph, t);
4774 public void exception(AsyncReadGraph graph, Throwable throwable) {
4775 throwable.printStackTrace();
4776 procedure.exception(graph, throwable);
4784 public <T> void forPossibleRelatedValue(Resource subject,
4785 Resource relation, Binding binding, SyncProcedure<T> procedure) {
4786 forPossibleRelatedValue(subject, relation, binding,
4787 new SyncToAsyncProcedure<T>(procedure));
4791 public <T> void forPossibleRelatedValue(Resource subject,
4792 Resource relation, Binding binding, Procedure<T> procedure) {
4793 forPossibleRelatedValue(subject, relation, binding,
4794 new NoneToAsyncProcedure<T>(procedure));
4798 public void forIsInstanceOf(Resource subject, Resource relation,
4799 AsyncListener<Boolean> listener) {
4800 asyncRequest(new IsInstanceOf(subject, relation), listener);
4804 public void forIsInstanceOf(Resource subject, Resource relation,
4805 SyncListener<Boolean> listener) {
4806 asyncRequest(new IsInstanceOf(subject, relation), listener);
4810 public void forIsInstanceOf(Resource subject, Resource relation,
4811 Listener<Boolean> listener) {
4812 asyncRequest(new IsInstanceOf(subject, relation), listener);
4816 final public void forIsInstanceOf(final Resource resource,
4817 final Resource type, final AsyncProcedure<Boolean> procedure) {
4819 assert (resource != null);
4820 assert (type != null);
4821 assert (procedure != null);
4823 forTypes(resource, new AsyncProcedure<Set<Resource>>() {
4826 public void execute(AsyncReadGraph graph, Set<Resource> result) {
4829 if (result.contains(type))
4830 procedure.execute(graph, true);
4832 procedure.execute(graph, false);
4833 } catch (Throwable t) {
4834 Logger.defaultLogError(t);
4839 public void exception(AsyncReadGraph graph, Throwable t) {
4841 procedure.exception(graph, t);
4842 } catch (Throwable t2) {
4843 Logger.defaultLogError(t2);
4848 public String toString() {
4849 return "forIsInstanceOf -> " + procedure;
4857 public void forIsInstanceOf(Resource subject, Resource relation,
4858 SyncProcedure<Boolean> procedure) {
4859 forIsInstanceOf(subject, relation, new SyncToAsyncProcedure<Boolean>(
4864 public void forIsInstanceOf(Resource subject, Resource relation,
4865 Procedure<Boolean> procedure) {
4866 forIsInstanceOf(subject, relation, new NoneToAsyncProcedure<Boolean>(
4871 public void forIsInheritedFrom(Resource subject, Resource relation,
4872 AsyncListener<Boolean> listener) {
4873 asyncRequest(new IsInheritedFrom(subject, relation), listener);
4877 public void forIsInheritedFrom(Resource subject, Resource relation,
4878 SyncListener<Boolean> listener) {
4879 asyncRequest(new IsInheritedFrom(subject, relation), listener);
4883 public void forIsInheritedFrom(Resource subject, Resource relation,
4884 Listener<Boolean> listener) {
4885 asyncRequest(new IsInheritedFrom(subject, relation), listener);
4889 final public void forIsInheritedFrom(final Resource resource,
4890 final Resource type, final AsyncProcedure<Boolean> procedure) {
4892 assert (resource != null);
4893 assert (type != null);
4894 assert (procedure != null);
4896 if (resource.equals(type)) {
4898 procedure.execute(this, true);
4899 } catch (Throwable t) {
4900 Logger.defaultLogError(t);
4905 forSupertypes(resource, new AsyncProcedure<Set<Resource>>() {
4908 public void execute(AsyncReadGraph graph, Set<Resource> result) {
4910 if (result.contains(type))
4911 procedure.execute(graph, true);
4913 procedure.execute(graph, false);
4914 } catch (Throwable t) {
4915 Logger.defaultLogError(t);
4920 public void exception(AsyncReadGraph graph, Throwable t) {
4922 procedure.exception(graph, t);
4923 } catch (Throwable t2) {
4924 Logger.defaultLogError(t2);
4929 public String toString() {
4930 return "forIsInheritedFrom -> " + procedure;
4938 public void forIsInheritedFrom(Resource subject, Resource relation,
4939 SyncProcedure<Boolean> procedure) {
4940 forIsInheritedFrom(subject, relation,
4941 new SyncToAsyncProcedure<Boolean>(procedure));
4945 public void forIsInheritedFrom(Resource subject, Resource relation,
4946 Procedure<Boolean> procedure) {
4947 forIsInheritedFrom(subject, relation,
4948 new NoneToAsyncProcedure<Boolean>(procedure));
4952 public void forIsSubrelationOf(Resource subject, Resource relation,
4953 AsyncListener<Boolean> listener) {
4954 asyncRequest(new IsSubrelationOf(subject, relation), listener);
4958 public void forIsSubrelationOf(Resource subject, Resource relation,
4959 SyncListener<Boolean> listener) {
4960 asyncRequest(new IsSubrelationOf(subject, relation), listener);
4964 public void forIsSubrelationOf(Resource subject, Resource relation,
4965 Listener<Boolean> listener) {
4966 asyncRequest(new IsSubrelationOf(subject, relation), listener);
4970 final public void forIsSubrelationOf(final Resource resource,
4971 final Resource relation, final AsyncProcedure<Boolean> procedure) {
4973 assert (resource != null);
4974 assert (relation != null);
4975 assert (procedure != null);
4977 if (resource.equals(relation)) {
4978 procedure.execute(this, true);
4982 forSuperrelations(resource, new AsyncProcedure<Set<Resource>>() {
4985 public void execute(AsyncReadGraph graph, Set<Resource> result) {
4987 if (result.contains(relation))
4988 procedure.execute(graph, true);
4990 procedure.execute(graph, false);
4991 } catch (Throwable t) {
4992 Logger.defaultLogError(t);
4997 public void exception(AsyncReadGraph graph, Throwable t) {
4999 procedure.exception(graph, t);
5000 } catch (Throwable t2) {
5001 Logger.defaultLogError(t2);
5006 public String toString() {
5007 return "forIsSubrelationOf -> " + procedure;
5015 public void forIsSubrelationOf(Resource subject, Resource relation,
5016 SyncProcedure<Boolean> procedure) {
5017 forIsSubrelationOf(subject, relation,
5018 new SyncToAsyncProcedure<Boolean>(procedure));
5022 public void forIsSubrelationOf(Resource subject, Resource relation,
5023 Procedure<Boolean> procedure) {
5024 forIsSubrelationOf(subject, relation,
5025 new NoneToAsyncProcedure<Boolean>(procedure));
5029 public void forHasStatement(Resource subject,
5030 AsyncListener<Boolean> listener) {
5031 asyncRequest(new HasStatementSubject(subject), listener);
5035 public void forHasStatement(Resource subject, SyncListener<Boolean> listener) {
5036 asyncRequest(new HasStatementSubject(subject), listener);
5040 public void forHasStatement(Resource subject, Listener<Boolean> listener) {
5041 asyncRequest(new HasStatementSubject(subject), listener);
5045 final public void forHasStatement(final Resource subject,
5046 final AsyncProcedure<Boolean> procedure) {
5048 assert (subject != null);
5049 assert (procedure != null);
5051 processor.forHasStatement(this, subject, procedure);
5056 public void forHasStatement(Resource subject,
5057 SyncProcedure<Boolean> procedure) {
5058 forHasStatement(subject, new SyncToAsyncProcedure<Boolean>(procedure));
5062 public void forHasStatement(Resource subject, Procedure<Boolean> procedure) {
5063 forHasStatement(subject, new NoneToAsyncProcedure<Boolean>(procedure));
5067 public void forHasStatement(Resource subject, Resource relation,
5068 AsyncListener<Boolean> listener) {
5069 asyncRequest(new HasStatement(subject, relation), listener);
5073 public void forHasStatement(Resource subject, Resource relation,
5074 SyncListener<Boolean> listener) {
5075 asyncRequest(new HasStatement(subject, relation), listener);
5079 public void forHasStatement(Resource subject, Resource relation,
5080 Listener<Boolean> listener) {
5081 asyncRequest(new HasStatement(subject, relation), listener);
5085 final public void forHasStatement(final Resource subject,
5086 final Resource relation, final AsyncProcedure<Boolean> procedure) {
5088 assert (subject != null);
5089 assert (relation != null);
5090 assert (procedure != null);
5092 processor.forHasStatement(this, subject, relation, procedure);
5097 public void forHasStatement(Resource subject, Resource relation,
5098 SyncProcedure<Boolean> procedure) {
5099 forHasStatement(subject, relation, new SyncToAsyncProcedure<Boolean>(
5104 public void forHasStatement(Resource subject, Resource relation,
5105 Procedure<Boolean> procedure) {
5106 forHasStatement(subject, relation, new NoneToAsyncProcedure<Boolean>(
5111 public void forHasStatement(Resource subject, Resource relation,
5112 Resource object, AsyncListener<Boolean> listener) {
5113 asyncRequest(new HasStatementSubjectObject(subject, relation, object),
5118 public void forHasStatement(Resource subject, Resource relation,
5119 Resource object, SyncListener<Boolean> listener) {
5120 asyncRequest(new HasStatementSubjectObject(subject, relation, object),
5125 public void forHasStatement(Resource subject, Resource relation,
5126 Resource object, Listener<Boolean> listener) {
5127 asyncRequest(new HasStatementSubjectObject(subject, relation, object),
5132 final public void forHasStatement(final Resource subject,
5133 final Resource relation, final Resource object,
5134 final AsyncProcedure<Boolean> procedure) {
5136 assert (subject != null);
5137 assert (relation != null);
5138 assert (object != null);
5139 assert (procedure != null);
5141 processor.forHasStatement(this, subject, relation, object, procedure);
5146 public void forHasStatement(Resource subject, Resource relation,
5147 Resource object, SyncProcedure<Boolean> procedure) {
5148 forHasStatement(subject, relation, object,
5149 new SyncToAsyncProcedure<Boolean>(procedure));
5153 public void forHasStatement(Resource subject, Resource relation,
5154 Resource object, Procedure<Boolean> procedure) {
5155 forHasStatement(subject, relation, object,
5156 new NoneToAsyncProcedure<Boolean>(procedure));
5160 public void forHasValue(Resource subject, AsyncListener<Boolean> listener) {
5161 asyncRequest(new HasValue(subject), listener);
5165 public void forHasValue(Resource subject, SyncListener<Boolean> listener) {
5166 asyncRequest(new HasValue(subject), listener);
5170 public void forHasValue(Resource subject, Listener<Boolean> listener) {
5171 asyncRequest(new HasValue(subject), listener);
5175 final public void forHasValue(final Resource subject,
5176 final AsyncProcedure<Boolean> procedure) {
5178 assert (subject != null);
5179 assert (procedure != null);
5181 processor.forValue(this, subject, new AsyncProcedure<byte[]>() {
5184 public void execute(AsyncReadGraph graph, byte[] result) {
5187 procedure.execute(graph, false);
5189 procedure.execute(graph, true);
5190 } catch (Throwable t) {
5191 Logger.defaultLogError(t);
5196 public void exception(AsyncReadGraph graph, Throwable t) {
5198 procedure.exception(graph, t);
5199 } catch (Throwable t2) {
5200 Logger.defaultLogError(t2);
5205 public String toString() {
5206 return "forHasValue -> " + procedure;
5214 public void forHasValue(Resource subject, SyncProcedure<Boolean> procedure) {
5215 forHasValue(subject, new SyncToAsyncProcedure<Boolean>(procedure));
5219 public void forHasValue(Resource subject, Procedure<Boolean> procedure) {
5220 forHasValue(subject, new NoneToAsyncProcedure<Boolean>(procedure));
5224 public void forOrderedSet(Resource subject,
5225 AsyncMultiListener<Resource> listener) {
5226 asyncRequest(new OrderedSet(subject), listener);
5230 public void forOrderedSet(Resource subject,
5231 SyncMultiListener<Resource> listener) {
5232 asyncRequest(new OrderedSet(subject), listener);
5236 public void forOrderedSet(Resource subject, MultiListener<Resource> listener) {
5237 asyncRequest(new OrderedSet(subject), listener);
5241 final public void forOrderedSet(final Resource subject,
5242 final AsyncMultiProcedure<Resource> procedure) {
5244 assert (subject != null);
5245 assert (procedure != null);
5247 processor.forOrderedSet(this, subject,
5248 new AsyncMultiProcedure<Resource>() {
5251 public void finished(AsyncReadGraph graph) {
5253 procedure.finished(graph);
5254 } catch (Throwable t) {
5255 Logger.defaultLogError(t);
5260 public void execute(AsyncReadGraph graph, Resource result) {
5262 procedure.execute(graph, result);
5263 } catch (Throwable t) {
5264 Logger.defaultLogError(t);
5269 public void exception(AsyncReadGraph graph, Throwable t) {
5271 procedure.exception(graph, t);
5272 } catch (Throwable t2) {
5273 Logger.defaultLogError(t2);
5278 public String toString() {
5279 return "forOrderedSet -> " + procedure;
5287 public void forOrderedSet(Resource subject,
5288 SyncMultiProcedure<Resource> procedure) {
5289 forOrderedSet(subject, new SyncToAsyncMultiProcedure<Resource>(
5294 public void forOrderedSet(Resource subject,
5295 MultiProcedure<Resource> procedure) {
5296 forOrderedSet(subject, new NoneToAsyncMultiProcedure<Resource>(
5301 public <T> void forPossibleAdapted(Resource resource, Class<T> clazz,
5302 AsyncListener<T> listener) {
5303 asyncRequest(new PossibleAdapter<T>(resource, clazz), listener);
5307 public <T> void forPossibleAdapted(Resource resource, Class<T> clazz,
5308 SyncListener<T> listener) {
5309 asyncRequest(new PossibleAdapter<T>(resource, clazz), listener);
5313 public <T> void forPossibleAdapted(Resource resource, Class<T> clazz,
5314 Listener<T> listener) {
5315 asyncRequest(new PossibleAdapter<T>(resource, clazz), listener);
5319 final public <T> void forPossibleAdapted(final Resource resource,
5320 final Class<T> clazz, final AsyncProcedure<T> procedure) {
5322 assert (resource != null);
5323 assert (clazz != null);
5324 assert (procedure != null);
5326 final AdaptionService service = getSession().peekService(AdaptionService.class);
5327 if (service == null)
5328 procedure.exception(this, new ServiceException("No AdaptionService available"));
5330 service.adapt(this, resource, resource, Resource.class, clazz, true, procedure);
5334 public <T> void forPossibleAdapted(Resource resource, Class<T> clazz,
5335 SyncProcedure<T> procedure) {
5336 forPossibleAdapted(resource, clazz, new SyncToAsyncProcedure<T>(
5341 public <T> void forPossibleAdapted(Resource resource, Class<T> clazz,
5342 Procedure<T> procedure) {
5343 forPossibleAdapted(resource, clazz, new NoneToAsyncProcedure<T>(
5348 public <T> void forPossibleUniqueAdapted(Resource resource, Class<T> clazz,
5349 AsyncListener<T> listener) {
5350 asyncRequest(new PossibleUniqueAdapter<T>(resource, clazz), listener);
5354 public <T> void forPossibleUniqueAdapted(Resource resource, Class<T> clazz,
5355 SyncListener<T> listener) {
5356 asyncRequest(new PossibleUniqueAdapter<T>(resource, clazz), listener);
5360 public <T> void forPossibleUniqueAdapted(Resource resource, Class<T> clazz,
5361 Listener<T> listener) {
5362 asyncRequest(new PossibleUniqueAdapter<T>(resource, clazz), listener);
5366 final public <T> void forPossibleUniqueAdapted(final Resource resource,
5367 final Class<T> clazz, final AsyncProcedure<T> procedure) {
5369 assert (resource != null);
5370 assert (clazz != null);
5371 assert (procedure != null);
5373 final AdaptionService service = getSession().peekService(AdaptionService.class);
5374 if (service == null)
5375 procedure.exception(this, new ServiceException("No AdaptionService available"));
5377 service.adaptNew(this, resource, clazz, true, procedure);
5382 public <T> void forPossibleUniqueAdapted(Resource resource, Class<T> clazz,
5383 SyncProcedure<T> procedure) {
5384 forPossibleUniqueAdapted(resource, clazz, new SyncToAsyncProcedure<T>(
5389 public <T> void forPossibleUniqueAdapted(Resource resource, Class<T> clazz,
5390 Procedure<T> procedure) {
5391 forPossibleUniqueAdapted(resource, clazz, new NoneToAsyncProcedure<T>(
5396 * Implementation of the interface AsyncRequestProcessor
5400 final public Session getSession() {
5401 return processor.getSession();
5405 public <T> void asyncRequest(final Read<T> request) {
5407 asyncRequest(request, new AsyncProcedure<T>() {
5410 public void execute(AsyncReadGraph graph, T result) {
5414 public void exception(AsyncReadGraph graph, Throwable t) {
5415 Logger.defaultLogError(t);
5419 public String toString() {
5420 return "asyncRequest(Read) -> " + request;
5428 public <T> void asyncRequest(Read<T> request, AsyncListener<T> procedure) {
5429 asyncRequest(request, (AsyncProcedure<T>) procedure);
5433 public <T> void asyncRequest(Read<T> request,
5434 final SyncListener<T> procedure) {
5435 asyncRequest(request, new SyncToAsyncListener<T>(procedure));
5439 public <T> void asyncRequest(Read<T> request, final Listener<T> procedure) {
5440 asyncRequest(request, new NoneToAsyncListener<T>(procedure));
5444 public <T> void asyncRequest(final Read<T> request, final AsyncProcedure<T> procedure) {
5446 assert (request != null);
5447 assert (procedure != null);
5449 processor.schedule(new SessionTask(false) {
5452 public void run(int thread) {
5454 final ListenerBase listener = getListenerBase(procedure);
5455 QueryCache.runnerReadEntry(ReadGraphImpl.this, request, parent, listener, procedure, false);
5456 } catch (DatabaseException e) {
5457 Logger.defaultLogError(e);
5465 public static ReadGraphImpl createAsync(QueryProcessor support) {
5466 return new ReadGraphImpl(null, support);
5470 public <T> void asyncRequest(Read<T> request, SyncProcedure<T> procedure) {
5471 asyncRequest(request, new SyncToAsyncProcedure<T>(procedure));
5475 public <T> void asyncRequest(Read<T> request, final Procedure<T> procedure) {
5476 asyncRequest(request, new NoneToAsyncProcedure<T>(procedure));
5480 final public <T> void asyncRequest(final AsyncRead<T> request) {
5482 assert (request != null);
5484 asyncRequest(request, new AsyncProcedure<T>() {
5487 public void execute(AsyncReadGraph graph, T result) {
5491 public void exception(AsyncReadGraph graph, Throwable t) {
5492 Logger.defaultLogError(t);
5496 public String toString() {
5497 return "asyncRequest(AsyncRead) -> " + request;
5505 public <T> void asyncRequest(AsyncRead<T> request,
5506 AsyncListener<T> procedure) {
5507 asyncRequest(request, (AsyncProcedure<T>) procedure);
5511 final public <T> void asyncRequest(AsyncRead<T> request,
5512 final SyncListener<T> procedure) {
5513 asyncRequest(request, new SyncToAsyncListener<T>(procedure));
5517 final public <T> void asyncRequest(AsyncRead<T> request,
5518 final Listener<T> procedure) {
5519 asyncRequest(request, new NoneToAsyncListener<T>(procedure));
5523 final public <T> void asyncRequest(final AsyncRead<T> request,
5524 final AsyncProcedure<T> procedure) {
5526 assert (request != null);
5527 assert (procedure != null);
5529 processor.schedule(new SessionTask(false) {
5532 public void run(int thread) {
5534 final ListenerBase listener = getListenerBase(procedure);
5535 QueryCache.runnerAsyncReadEntry(ReadGraphImpl.this, request, parent, listener, procedure, false);
5536 } catch (DatabaseException e) {
5537 Logger.defaultLogError(e);
5546 public <T> void asyncRequest(AsyncRead<T> request,
5547 SyncProcedure<T> procedure) {
5548 asyncRequest(request, new SyncToAsyncProcedure<T>(procedure));
5552 final public <T> void asyncRequest(final AsyncRead<T> request,
5553 final Procedure<T> procedure) {
5554 asyncRequest(request, new NoneToAsyncProcedure<T>(procedure));
5558 public <T> void asyncRequest(final MultiRead<T> request) {
5560 assert (request != null);
5562 asyncRequest(request, new AsyncMultiProcedureAdapter<T>() {
5564 public void exception(AsyncReadGraph graph, Throwable t) {
5565 Logger.defaultLogError(t);
5569 public String toString() {
5570 return "asyncRequest(MultiRead) -> " + request;
5577 public <T> void asyncRequest(MultiRead<T> request,
5578 AsyncMultiListener<T> procedure) {
5579 asyncRequest(request, (AsyncMultiProcedure<T>) procedure);
5583 public <T> void asyncRequest(MultiRead<T> request,
5584 SyncMultiListener<T> procedure) {
5585 asyncRequest(request, new SyncToAsyncMultiListener<T>(procedure));
5589 public <T> void asyncRequest(MultiRead<T> request,
5590 MultiListener<T> procedure) {
5591 asyncRequest(request, new NoneToAsyncMultiListener<T>(procedure));
5595 public <T> void asyncRequest(final MultiRead<T> request,
5596 final AsyncMultiProcedure<T> procedure) {
5598 assert (request != null);
5599 assert (procedure != null);
5601 final ListenerBase listener = getListenerBase(procedure);
5603 if (parent != null || listener != null) {
5605 // final ReadGraphImpl newGraph = newSync();
5606 processor.query(this, request, parent, procedure,listener);
5610 // final ReadGraphImpl newGraph = newSync();
5614 request.perform(this, procedure);
5616 } catch (Throwable t) {
5618 procedure.exception(this, t);
5627 public <T> void asyncRequest(MultiRead<T> request,
5628 SyncMultiProcedure<T> procedure) {
5629 asyncRequest(request, new SyncToAsyncMultiProcedure<T>(procedure));
5633 public <T> void asyncRequest(MultiRead<T> request,
5634 MultiProcedure<T> procedure) {
5635 asyncRequest(request, new NoneToAsyncMultiProcedure<T>(procedure));
5639 final public <T> void asyncRequest(final AsyncMultiRead<T> request) {
5641 assert (request != null);
5643 asyncRequest(request, new AsyncMultiProcedureAdapter<T>() {
5645 public void exception(AsyncReadGraph graph, Throwable t) {
5646 Logger.defaultLogError(t);
5650 public String toString() {
5651 return "asyncRequest(AsyncMultiRead) -> " + request;
5658 public <T> void asyncRequest(AsyncMultiRead<T> request,
5659 AsyncMultiListener<T> procedure) {
5660 asyncRequest(request, (AsyncMultiProcedure<T>) procedure);
5664 public <T> void asyncRequest(AsyncMultiRead<T> request,
5665 SyncMultiListener<T> procedure) {
5666 asyncRequest(request, new SyncToAsyncMultiListener<T>(procedure));
5670 public <T> void asyncRequest(AsyncMultiRead<T> request,
5671 MultiListener<T> procedure) {
5672 asyncRequest(request, new NoneToAsyncMultiListener<T>(procedure));
5676 final public <T> void asyncRequest(AsyncMultiRead<T> request,
5677 final AsyncMultiProcedure<T> procedure) {
5679 assert (request != null);
5680 assert (procedure != null);
5682 ListenerBase listener = getListenerBase(procedure);
5684 if (parent != null || listener != null) {
5686 processor.query(this, request, parent, procedure, listener);
5692 request.perform(this, new AsyncMultiProcedure<T>() {
5695 public void execute(AsyncReadGraph graph, T result) {
5696 procedure.execute(graph, result);
5700 public void finished(AsyncReadGraph graph) {
5701 procedure.finished(graph);
5705 public void exception(AsyncReadGraph graph, Throwable t) {
5706 procedure.exception(graph, t);
5710 public String toString() {
5711 return "asyncRequest(AsyncMultiRead) -> " + procedure;
5716 } catch (Throwable t) {
5718 procedure.exception(this, new DatabaseException(t));
5726 public <T> void asyncRequest(AsyncMultiRead<T> request,
5727 SyncMultiProcedure<T> procedure) {
5728 asyncRequest(request, new SyncToAsyncMultiProcedure<T>(procedure));
5732 final public <T> void asyncRequest(AsyncMultiRead<T> request,
5733 final MultiProcedure<T> procedure) {
5734 asyncRequest(request, new NoneToAsyncMultiProcedure<T>(procedure));
5738 final public <T> void asyncRequest(final ExternalRead<T> request) {
5740 assert (request != null);
5742 asyncRequest(request, new Procedure<T>() {
5745 public void execute(T result) {
5749 public void exception(Throwable t) {
5750 Logger.defaultLogError(t);
5754 public String toString() {
5755 return "asyncRequest(PrimitiveRead) -> " + request;
5763 public <T> void asyncRequest(ExternalRead<T> request,
5764 final Listener<T> procedure) {
5765 asyncRequest(request, (Procedure<T>) procedure);
5769 final public <T> void asyncRequest(final ExternalRead<T> request,
5770 final Procedure<T> procedure) {
5773 assert (request != null);
5774 assert (procedure != null);
5776 final ListenerBase listener = getListenerBase(procedure);
5778 if (parent != null || listener != null) {
5781 QueryCacheBase.resultExternalReadEntry(this, request, parent, listener, procedure);
5782 //processor.query(this, request, parent, procedure,listener);
5783 } catch (DatabaseException e) {
5784 Logger.defaultLogError(e);
5785 // This throwable has already been transferred to procedure at this point - do nothing about it
5791 request.register(this, new Listener<T>() {
5794 public void execute(T result) {
5795 procedure.execute(result);
5799 public void exception(Throwable t) {
5800 procedure.exception(t);
5804 public String toString() {
5805 return "asyncRequest(PrimitiveRead) -> " + request;
5809 public boolean isDisposed() {
5815 // final ReadGraphImpl newGraph = newSync();
5819 // T result = request.perform(this);
5822 // procedure.execute(this, result);
5823 // } catch (Throwable t) {
5824 // Logger.defaultLogError(t);
5827 // } catch (Throwable t) {
5830 // procedure.exception(this, t);
5831 // } catch (Throwable t2) {
5832 // Logger.defaultLogError(t2);
5841 // assert (request != null);
5842 // assert (procedure != null);
5844 // ListenerBase listener = getListenerBase(procedure);
5846 // if (parent != null || listener != null) {
5848 // processor.query(this, request, parent, procedure, listener);
5854 // request.register(this, new Listener<T>() {
5857 // public void execute(T result) {
5858 // procedure.execute(result);
5862 // public void exception(Throwable t) {
5863 // procedure.exception(t);
5867 // public String toString() {
5868 // return "asyncRequest(PrimitiveRead) -> " + request;
5872 // public boolean isDisposed() {
5878 // } catch (Throwable t) {
5880 // if (t instanceof DatabaseException)
5881 // procedure.exception(t);
5884 // .exception(new DatabaseException(
5885 // "Unexpected exception in ReadGraph.asyncRequest(SingleAsyncRead, SingleProcedure)",
5895 public void asyncRequest(final Write request) {
5897 assert (request != null);
5899 getSession().asyncRequest(request);
5901 // processor.asyncWrite(request);
5906 public <T> void asyncRequest(final WriteResult<T> request, Procedure<T> procedure) {
5907 throw new Error("Not implemented.");
5911 public void asyncRequest(Write request, Consumer<DatabaseException> callback) {
5913 assert (request != null);
5915 getSession().asyncRequest(request, callback);
5920 public void asyncRequest(final DelayedWrite request) {
5922 assert (request != null);
5924 getSession().asyncRequest(request);
5929 public <T> void asyncRequest(final DelayedWriteResult<T> request, Procedure<T> procedure) {
5930 throw new Error("Not implemented.");
5934 public void asyncRequest(DelayedWrite r,
5935 Consumer<DatabaseException> callback) {
5936 throw new Error("Not implemented.");
5940 public void asyncRequest(final WriteOnly request) {
5942 assert (request != null);
5944 getSession().asyncRequest(request);
5949 public <T> void asyncRequest(final WriteOnlyResult<T> request, Procedure<T> procedure) {
5950 throw new Error("Not implemented.");
5954 public void asyncRequest(WriteOnly r, Consumer<DatabaseException> callback) {
5955 throw new Error("Not implemented.");
5959 * Implementation of the interface ServiceLocator
5963 public <T> T getService(Class<T> api) {
5964 if(WriteSupport.class == api) {
5965 if(this instanceof WriteGraphImpl) {
5966 WriteGraphImpl impl = (WriteGraphImpl)this;
5967 return (T)impl.writeSupport;
5970 return getSession().getService(api);
5974 public <T> T peekService(Class<T> api) {
5975 return getSession().peekService(api);
5979 public boolean hasService(Class<?> api) {
5980 return getSession().hasService(api);
5984 public <T> void registerService(Class<T> api, T service) {
5985 getSession().registerService(api, service);
5989 public boolean isImmutable(Resource resource) throws DatabaseException {
5990 ResourceImpl impl = (ResourceImpl)resource;
5991 return processor.isImmutable(impl.id);
5998 protected static String INTERNAL_ERROR_STRING = "Transaction aborted due to internal client error. Contact application support.";
6001 * callerThread is the currently running thread state.syncThread is blocking for
6002 * this execution state.syncParent is the blocking request
6005 final private boolean isExternal(int thread) {
6006 return thread == Integer.MIN_VALUE;
6009 ReadGraphImpl(ReadGraphImpl graph) {
6010 this(graph.parent, graph.processor);
6013 ReadGraphImpl(CacheEntry parent, QueryProcessor support) {
6014 this.parent = parent;
6015 this.processor = support;
6018 public static ReadGraphImpl create(QueryProcessor support) {
6019 return new ReadGraphImpl(null, support);
6022 public ReadGraphImpl newRestart(ReadGraphImpl impl) {
6024 WriteGraphImpl write = processor.getSession().getService(
6025 WriteGraphImpl.class);
6031 public ReadGraphImpl withParent(CacheEntry parent) {
6032 if(parent == this.parent) return this;
6033 else return new ReadGraphImpl(parent, processor);
6036 final private ListenerBase getListenerBase(final Object procedure) {
6037 if (procedure instanceof ListenerBase)
6038 return (ListenerBase) procedure;
6043 public <T> void waitAsyncProcedure(AsyncMultiReadProcedure<T> procedure) {
6045 assert(procedure.done());
6049 public <T> void waitAsyncProcedure(AsyncReadProcedure<T> procedure) {
6051 assert(procedure.done());
6055 public boolean resumeTasks() {
6056 return processor.resumeTasks(this);
6059 Class<?> singleClass(Set<Resource> types) {
6060 Class<?> result = null;
6061 for (Resource type : types) {
6062 Class<?> clazz = processor.getBuiltinValue(type);
6063 if (clazz != null) {
6073 private String debugString(Resource r) {
6076 name = getPossibleRelatedValue(r, processor.getL0(this).HasName);
6077 } catch (ManyObjectsForFunctionalRelationException e) {
6078 Logger.defaultLogError(e);
6079 } catch (ServiceException e) {
6080 Logger.defaultLogError(e);
6082 return "[" + name + " - " + r + "]";
6086 public String toString() {
6087 return "ReadGraphImpl[thread=" + Thread.currentThread() + "]";
6091 final public int thread() {
6095 static class MultiTripleIntProcedure implements TripleIntProcedure {
6097 final private AsyncMultiProcedure<Statement> procedure;
6098 final private ReadGraphImpl impl;
6099 final private QuerySupport support;
6101 public MultiTripleIntProcedure(AsyncMultiProcedure<Statement> procedure, ReadGraphImpl impl, QuerySupport support) {
6102 this.procedure = procedure;
6104 this.support = support;
6108 public void execute(ReadGraphImpl graph, int s, int p, int o) {
6110 procedure.execute(graph, support.getStatement(s, p, o));
6111 } catch (Throwable t2) {
6112 Logger.defaultLogError(t2);
6117 public void finished(ReadGraphImpl graph) {
6119 procedure.finished(graph);
6120 // impl.state.barrier.dec("ReadGraphSupportImpl.516");
6121 } catch (Throwable t2) {
6122 Logger.defaultLogError(t2);
6127 public void exception(ReadGraphImpl graph, Throwable t) {
6129 procedure.exception(graph, t);
6130 } catch (Throwable t2) {
6131 Logger.defaultLogError(t2);
6133 // impl.state.barrier.dec("ReadGraphSupportImpl.516");
6137 public String toString() {
6138 return "forEachObject with " + procedure;
6143 // private AsyncMultiProcedure<Resource> cacheKey = null;
6144 // private MultiIntProcedure cacheResult = null;
6146 // final IntProcedure forMultiProcedure(final AsyncMultiProcedure<Resource> procedure) {
6148 // if(procedure == cacheKey) return cacheResult;
6150 // cacheResult = new MultiIntProcedure(procedure, this, processor.support);
6151 // cacheKey = procedure;
6153 // return cacheResult;
6157 // private AsyncMultiProcedure<Statement> cacheKey2 = null;
6158 // private MultiTripleIntProcedure cacheResult2 = null;
6160 // final synchronized TripleIntProcedure forMultiProcedure(final AsyncMultiProcedure<Statement> procedure) {
6162 // if(procedure == cacheKey2) return cacheResult2;
6164 // cacheResult2 = new MultiTripleIntProcedure(procedure, this, processor.support);
6165 // cacheKey2 = procedure;
6167 // return cacheResult2;
6172 public Datatype getDataType(Resource subject) throws DatabaseException {
6173 for(Resource dataTypeResource : getObjects(subject, processor.getL0(this).HasDataType))
6174 return getValue(dataTypeResource, Bindings.getBindingUnchecked(Datatype.class));
6175 throw new DoesNotContainValueException("The literal has no data type.");
6178 protected <T extends Accessor> T getAccessor4File(Resource subject)
6179 throws DatabaseException {
6182 byte[] bytes = processor.support.getValue(g, subject);
6186 BinaryVariant va = (BinaryVariant) Accessors.getAccessor(bytes, Datatypes.VARIANT);
6187 Accessor ca = va.getContentAccessor();
6189 } catch (AccessorConstructionException e) {
6190 throw new DatabaseException(e);
6196 Binding datatype_binding = Bindings.getBindingUnchecked(DataType.class);
6197 Serializer datatype_serializer = datatype_binding.serializer();
6200 BinaryMemory in = new BinaryMemory(ByteBuffer.wrap(bytes));
6201 datatype = (DataType)datatype_serializer.deserialize(in);
6202 Binding data_binding = Bindings.getBinding(datatype);
6203 Serializer data_serializer = data_binding.serializer(BinarySerializationFormat.INSTANCE);
6204 Object o = data_serializer.deserialize(in);
6206 return (T)Accessors.getAccessor(data_binding, o);
6207 } catch(AccessorConstructionException e) {
6210 } catch (Exception e) {
6211 throw new DatabaseException(e);
6214 @SuppressWarnings("unchecked")
6216 public <T extends Accessor> T getAccessor(Resource subject) throws DatabaseException {
6217 RandomAccessBinary rab = getRandomAccessBinary(subject);
6219 return (T)Accessors.getAccessor(rab, getDataType(subject));
6220 } catch(AccessorConstructionException e) {
6221 throw new DatabaseException(e);
6224 @SuppressWarnings("unchecked")
6225 protected <T extends Accessor> T createAccessor(Resource resource, Datatype datatype, Object intialValue)
6226 throws DatabaseException {
6227 RandomAccessBinary rab = createRandomAccessBinary(resource, datatype, intialValue);
6229 return (T)Accessors.getAccessor(rab, datatype);
6230 } catch(AccessorConstructionException e) {
6231 throw new DatabaseException(e);
6235 public RandomAccessBinary getRandomAccessBinary(Resource subject) throws DatabaseException {
6236 RandomAccessValueSupport ravs = getSession().getService(RandomAccessValueSupport.class);
6237 ResourceData rd = ravs.get(subject);
6241 ExternalValueSupport evs = getService(ExternalValueSupport.class);
6242 long size = evs.getValueSize(this, subject); // Throws DatabaseException if no old external value.
6244 File platform = Platform.getLocation().toFile();
6245 File tempFiles = new File(platform, "tempFiles");
6246 File dbDir = new File(tempFiles, "db");
6248 File file = new File(dbDir, "ResourceFile" + subject.getResourceId());
6249 rd = new ResourceData(new BinaryFile(file), true); // Old external value.
6250 final int N = 1<<20;
6254 int length = N < left ? N : (int)left;
6255 byte[] bytes = evs.readValue(this, subject, offset, length);
6256 offset += bytes.length;
6257 left -= bytes.length;
6258 rd.binaryFile.write(bytes);
6260 ravs.put(subject, rd);
6262 } catch (Exception e) {
6263 throw new DatabaseException("Resource " + subject + " have value but there was problem with accessing value data.", e);
6265 } catch (Exception e) {
6266 if(Development.DEVELOPMENT) {
6267 if(Development.<Boolean>getProperty(DevelopmentKeys.WRITEGRAPH_EXCEPTION_STACKTRACES, Bindings.BOOLEAN)) {
6268 e.printStackTrace();
6272 Datatype datatype = getDataType(subject);
6273 Object value = getPossibleValue(subject, Bindings.getBinding(datatype));
6274 return createRandomAccessBinary(subject, datatype, value);
6276 public RandomAccessBinary createRandomAccessBinary(Resource resource, Datatype datatype, Object initialValue)
6277 throws DatabaseException {
6278 RandomAccessValueSupport ravs = getSession().getService(RandomAccessValueSupport.class);
6280 File platform = Platform.getLocation().toFile();
6281 File tempFiles = new File(platform, "tempFiles");
6282 File dbDir = new File(tempFiles, "db");
6284 File file = new File(dbDir, "ResourceFile" + resource.getResourceId());
6285 ResourceData rd = new ResourceData(new BinaryFile(file), false);
6286 Binding binding = Bindings.getBinding(datatype);
6287 if (null == initialValue) {
6288 initialValue = binding.createDefault();
6290 Serializer serializer = binding.serializer();
6291 byte[] bytes = serializer.serialize(initialValue);
6292 rd.binaryFile.write(bytes);
6293 ravs.put(resource, rd);
6295 } catch (Exception e) {
6296 if (e instanceof DatabaseException)
6297 throw (DatabaseException)e;
6299 throw new DatabaseException(e);
6303 // static class ExternalValueRequest<T> extends ResourceRead<T> {
6305 // public ExternalValueRequest(Resource resource) {
6309 // @SuppressWarnings("unchecked")
6311 // public T perform(ReadGraph graph) throws DatabaseException {
6314 // String uri = graph.getURI(resource);
6315 // if(Layer0.URIs.Functions_functionApplication.equals(uri)) return (T)functionApplication;
6317 // return (T)ReflectionUtils.getValue(uri).getValue();
6319 // } catch(ValueNotFoundException e) {
6320 // throw new DatabaseException("Couldn't convert to external value (r=" + resource + ")", e);
6321 // } catch(ClassCastException e) {
6322 // throw new DatabaseException("Couldn't convert to external value (r=" + resource + ")", e);
6328 @SuppressWarnings("unchecked")
6330 public <T> T getValue2(Resource r, Object context) throws DatabaseException {
6331 Layer0 L0 = processor.getL0(this);
6332 Set<Resource> types = getTypes(r);
6334 if(types.contains(L0.Literal)) {
6335 if(isImmutable(r)) {
6336 return syncRequest(new ValueImplied<T>(r));
6341 else if(types.contains(L0.ExternalValue)) {
6342 return (T)syncRequest(new AdaptValue(r), TransientCacheListener.<Object>instance());
6346 Function3<ReadGraph,Resource,Object,T> function = requestValueFunction(r);
6347 if(function == null) throw new DoesNotContainValueException("Couldn't convert to a value function " + r);
6349 return function.apply(this, r, context);
6350 } catch(RuntimeException e) {
6351 DatabaseException dte = findPossibleRootException(e);
6352 if(dte != null) throw dte;
6353 else throw new DatabaseException(e);
6360 public Variant getVariantValue2(Resource r, Object context) throws DatabaseException {
6361 Layer0 L0 = processor.getL0(this);
6362 Set<Resource> types = getTypes(r);
6364 if(types.contains(L0.Literal)) {
6365 if(isImmutable(r)) {
6366 return syncRequest(new VariantValueImplied(r));
6368 return getVariantValue(r);
6371 else if(types.contains(L0.ExternalValue)) {
6372 Object value = syncRequest(new AdaptValue(r), TransientCacheListener.<Object>instance());
6374 return new Variant(Bindings.OBJECT.getContentBinding(value), value);
6375 } catch ( org.simantics.databoard.binding.error.BindingException e ) {
6376 throw new BindingException( "No binding found for class " + value.getClass().getName(), e );
6381 Function3<ReadGraph,Resource,Object,Object> function = requestValueFunction(r);
6382 if(function == null) throw new DoesNotContainValueException("Couldn't convert to a value function " + r);
6384 Object value = function.apply(this, r, context);
6386 return new Variant(Bindings.OBJECT.getContentBinding(value), value);
6387 } catch ( org.simantics.databoard.binding.error.BindingException e ) {
6388 throw new BindingException( "No binding found for class " + value.getClass().getName(), e );
6390 } catch(RuntimeException e) {
6391 DatabaseException dte = findPossibleRootException(e);
6392 if(dte != null) throw dte;
6393 else throw new DatabaseException(e);
6399 public <T> T getPossibleValue2(Resource subject, Object context) throws DatabaseException {
6401 return getValue2(subject, context);
6402 } catch (DatabaseException e) {
6407 static class PossibleConverterFunction<T> extends ResourceRead<Function3<ReadGraph,Resource,Object,T>> {
6409 public PossibleConverterFunction(Resource resource) {
6414 public Function3<ReadGraph,Resource,Object,T> perform(ReadGraph graph) throws DatabaseException {
6415 return compute(graph, resource);
6418 @SuppressWarnings("unchecked")
6419 public static <T> Function3<ReadGraph,Resource,Object,T> compute(ReadGraph graph, Resource resource) throws DatabaseException {
6420 Layer0 L0 = Layer0.getInstance(graph);
6421 for(Resource converter : graph.getObjects(resource, L0.ConvertsToValueWith)) {
6423 if(L0.Functions_functionApplication.equals(converter)) {
6424 return (Function3<ReadGraph,Resource,Object,T>)graph.syncRequest(new AdaptValue(resource));
6426 return graph.getValue2(converter, resource);
6428 } catch(RuntimeException e) {
6429 DatabaseException dte = findPossibleRootException(e);
6430 if(dte != null) throw dte;
6431 else throw new DatabaseException(e);
6439 <T> Function3<ReadGraph,Resource,Object,T> requestValueFunction(Resource r) throws DatabaseException {
6441 return syncRequest(new PossibleConverterFunction<T>(r), TransientCacheAsyncListener.<Function3<ReadGraph,Resource,Object,T>>instance());
6443 return syncRequest(new PossibleConverterFunction<T>(r));
6447 * Get a value associated with a graph {@link Resource}, using a possible context object and
6448 * a desired value binding. The following methods are tried in order to retreive the value:
6450 * <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>
6451 * <li>If the resource is a {@code L0.ExternalValue}, the value is acquired using
6452 * {@link ReflectionUtils#getValue(String)}.</li>
6453 * <li>If the resource is associated with a suitable value converter with relation {@code L0.ConvertsToValueWith}
6454 * (see {@link #requestValueFunction(Resource)}), the value function is called with the graph, the resource
6455 * and the context object.</li>
6458 * @param r A graph resource with which the value is associated
6459 * @param context A context object that is used for acquiring the value (only applied in case 3)
6460 * @param binding A binding for the value type (only applied in case 1)
6461 * @return The value of the graph node.
6462 * @throws DoesNotContainValueException No value is associated with the graph node.
6463 * @throws DatabaseException Other errors, such as an error in casting the value to the return type or
6464 * a runtime error in the value function.
6466 @SuppressWarnings("unchecked")
6468 public <T> T getValue2(Resource r, Object context, Binding binding) throws DatabaseException {
6469 if (binding instanceof ObjectVariantBinding)
6470 return getValue2(r, context);
6472 Layer0 L0 = processor.getL0(this);
6473 Set<Resource> types = getTypes(r);
6474 if(types.contains(L0.Literal)) {
6475 if(isImmutable(r)) {
6476 return syncRequest(new Value<T>(r, binding));
6478 return getValue(r, binding);
6480 } else if(types.contains(L0.ExternalValue)) {
6482 return (T)ReflectionUtils.getValue(getURI(r)).getValue();
6483 } catch(ValueNotFoundException e) {
6484 throw new DatabaseException(e);
6485 } catch(ClassCastException e) {
6486 throw new DatabaseException(e);
6490 Function3<ReadGraph,Resource,Object,T> function = requestValueFunction(r);
6491 if(function == null) throw new DoesNotContainValueException("Couldn't convert to a value function.");
6493 Object value = function.apply(this, r, context);
6494 if(binding.isInstance(value)) return (T)value;
6495 Binding srcBinding = Bindings.OBJECT.getContentBinding(value);
6496 return (T)Bindings.adapt(value, srcBinding, binding);
6497 } catch(RuntimeException e) {
6498 DatabaseException dte = findPossibleRootException(e);
6499 if(dte != null) throw dte;
6500 else throw new DatabaseException(e);
6501 } catch (AdaptException e) {
6502 throw new DatabaseException(e);
6503 } catch (org.simantics.databoard.binding.error.BindingException e) {
6504 throw new DatabaseException(e);
6510 public <T> T getPossibleValue2(Resource subject, Object context, Binding binding) throws DatabaseException {
6512 return getValue2(subject, context, binding);
6513 } catch (DatabaseException e) {
6518 private static DatabaseException findPossibleRootException(Throwable t) {
6519 if(t == null) return null;
6520 if(t instanceof DatabaseException) return (DatabaseException)t;
6521 if(t instanceof RuntimeException || t instanceof InvocationTargetException) {
6522 return findPossibleRootException(t.getCause());
6528 public <T> T getRelatedValue2(Resource subject, Resource relation) throws DatabaseException {
6529 return getRelatedValue2(subject, relation, subject);
6533 public Variant getRelatedVariantValue2(Resource subject, Resource relation) throws DatabaseException {
6534 return getRelatedVariantValue2(subject, relation, subject);
6538 public <T> T getPossibleRelatedValue2(Resource subject, Resource relation) throws DatabaseException {
6540 Resource object = getPossibleObject(subject, relation);
6541 if(object == null) return null;
6542 else return getValue2(object, subject);
6543 } catch (DatabaseException e) {
6549 public <T> T getRelatedValue2(Resource subject, Resource relation, Object context) throws DatabaseException {
6550 if(Development.DEVELOPMENT) {
6551 String error = L0Validations.checkValueType(this, subject, relation);
6553 Logger.defaultLogError(new ValidationException(error));
6554 //throw new ValidationException(error);
6555 new ValidationException(error).printStackTrace();
6558 return getValue2(getSingleObject(subject, relation), context);
6562 public Variant getRelatedVariantValue2(Resource subject, Resource relation, Object context) throws DatabaseException {
6563 if(Development.DEVELOPMENT) {
6564 String error = L0Validations.checkValueType(this, subject, relation);
6566 Logger.defaultLogError(new ValidationException(error));
6567 //throw new ValidationException(error);
6568 new ValidationException(error).printStackTrace();
6571 return getVariantValue2(getSingleObject(subject, relation), context);
6575 public <T> T getPossibleRelatedValue2(Resource subject, Resource relation, Object context) throws DatabaseException {
6577 Resource object = getPossibleObject(subject, relation);
6578 if(object == null) return null;
6579 else return getValue2(object, context);
6580 } catch (DatabaseException e) {
6586 public <T> T getRelatedValue2(Resource subject, Resource relation, Binding binding) throws DatabaseException {
6587 return getRelatedValue2(subject, relation, subject, binding);
6591 public <T> T getPossibleRelatedValue2(Resource subject, Resource relation, Binding binding) throws DatabaseException {
6593 Resource object = getPossibleObject(subject, relation);
6594 if(object == null) return null;
6595 return getValue2(object, subject, binding);
6596 } catch (DatabaseException e) {
6602 public <T> T getRelatedValue2(Resource subject, Resource relation, Object context, Binding binding) throws DatabaseException {
6603 return getValue2(getSingleObject(subject, relation), context, binding);
6607 public <T> T getPossibleRelatedValue2(Resource subject, Resource relation, Object context, Binding binding) throws DatabaseException {
6609 Resource object = getPossibleObject(subject, relation);
6610 if(object == null) return null;
6611 else return getValue2(object, context, binding);
6612 } catch (DatabaseException e) {
6618 public Type getRelatedValueType(Resource subject, Resource relation) throws DatabaseException {
6619 Layer0 L0 = processor.getL0(this);
6620 Resource property = getSingleObject(subject, relation);
6621 String typeText = (String)getRelatedValue(property, L0.HasValueType, Bindings.STRING);
6623 return org.simantics.scl.compiler.types.Types.parseType(typeText);
6624 } catch (SCLTypeParseException e) {
6625 throw new DatabaseException(e);
6629 private static ThreadLocal<Boolean> syncGraph = new ThreadLocal<Boolean>() {
6630 protected Boolean initialValue() {
6636 public boolean setSynchronous(boolean value) {
6637 boolean old = getSynchronous();
6638 syncGraph.set(value);
6643 public boolean getSynchronous() {
6644 return syncGraph.get();
6647 public void ensureLoaded(int resource) {
6648 processor.querySupport.ensureLoaded(this, resource);
6651 public void ensureLoaded(int resource, int predicate) {
6652 processor.querySupport.ensureLoaded(this, resource, predicate);
6655 public byte[] getValue(int resource) {
6656 return processor.querySupport.getValue(this, resource);
6659 public int thread(int resource) {
6660 return (resource >>> 16) & processor.THREAD_MASK;
6663 public int thread(Resource resource) {
6664 return (((ResourceImpl)resource).id >>> 16) & processor.THREAD_MASK;
6667 public ResourceSupport getResourceSupport() {
6668 return processor.getResourceSupport();
6672 public Object getModificationCounter() {
6673 return processor.getSession().getModificationCounter();
6677 public boolean performPending() {
6678 return processor.performPending(processor.thread.get());