1 /*******************************************************************************
\r
2 * Copyright (c) 2007, 2010 Association for Decentralized Information Management
\r
3 * in Industry THTH ry.
\r
4 * All rights reserved. This program and the accompanying materials
\r
5 * are made available under the terms of the Eclipse Public License v1.0
\r
6 * which accompanies this distribution, and is available at
\r
7 * http://www.eclipse.org/legal/epl-v10.html
\r
10 * VTT Technical Research Centre of Finland - initial API and implementation
\r
11 *******************************************************************************/
\r
12 package org.simantics.db.impl.graph;
\r
14 import gnu.trove.map.hash.TObjectIntHashMap;
\r
16 import java.io.BufferedOutputStream;
\r
17 import java.io.File;
\r
18 import java.io.FileOutputStream;
\r
19 import java.io.IOException;
\r
20 import java.io.PrintStream;
\r
21 import java.lang.reflect.Array;
\r
22 import java.lang.reflect.InvocationTargetException;
\r
23 import java.nio.BufferUnderflowException;
\r
24 import java.util.ArrayList;
\r
25 import java.util.Collection;
\r
26 import java.util.Collections;
\r
27 import java.util.IdentityHashMap;
\r
28 import java.util.Iterator;
\r
29 import java.util.List;
\r
30 import java.util.ListIterator;
\r
31 import java.util.Set;
\r
33 import org.eclipse.core.runtime.Platform;
\r
34 import org.simantics.databoard.Accessors;
\r
35 import org.simantics.databoard.Bindings;
\r
36 import org.simantics.databoard.accessor.Accessor;
\r
37 import org.simantics.databoard.accessor.error.AccessorConstructionException;
\r
38 import org.simantics.databoard.adapter.AdaptException;
\r
39 import org.simantics.databoard.binding.Binding;
\r
40 import org.simantics.databoard.binding.error.RuntimeBindingConstructionException;
\r
41 import org.simantics.databoard.binding.impl.ObjectVariantBinding;
\r
42 import org.simantics.databoard.binding.mutable.Variant;
\r
43 import org.simantics.databoard.serialization.Serializer;
\r
44 import org.simantics.databoard.type.Datatype;
\r
45 import org.simantics.databoard.util.binary.BinaryFile;
\r
46 import org.simantics.databoard.util.binary.RandomAccessBinary;
\r
47 import org.simantics.db.AsyncReadGraph;
\r
48 import org.simantics.db.DevelopmentKeys;
\r
49 import org.simantics.db.ExternalValueSupport;
\r
50 import org.simantics.db.ReadGraph;
\r
51 import org.simantics.db.RelationContext;
\r
52 import org.simantics.db.Resource;
\r
53 import org.simantics.db.Session;
\r
54 import org.simantics.db.Statement;
\r
55 import org.simantics.db.adaption.AdaptionService;
\r
56 import org.simantics.db.common.primitiverequest.Adapter;
\r
57 import org.simantics.db.common.primitiverequest.Builtin;
\r
58 import org.simantics.db.common.primitiverequest.DatatypeBinding;
\r
59 import org.simantics.db.common.primitiverequest.ForEachAssertedObject;
\r
60 import org.simantics.db.common.primitiverequest.ForEachAssertedStatement;
\r
61 import org.simantics.db.common.primitiverequest.HasStatement;
\r
62 import org.simantics.db.common.primitiverequest.HasStatementSubject;
\r
63 import org.simantics.db.common.primitiverequest.HasStatementSubjectObject;
\r
64 import org.simantics.db.common.primitiverequest.HasValue;
\r
65 import org.simantics.db.common.primitiverequest.Inverse;
\r
66 import org.simantics.db.common.primitiverequest.IsInheritedFrom;
\r
67 import org.simantics.db.common.primitiverequest.IsInstanceOf;
\r
68 import org.simantics.db.common.primitiverequest.IsSubrelationOf;
\r
69 import org.simantics.db.common.primitiverequest.OrderedSet;
\r
70 import org.simantics.db.common.primitiverequest.PossibleAdapter;
\r
71 import org.simantics.db.common.primitiverequest.PossibleInverse;
\r
72 import org.simantics.db.common.primitiverequest.PossibleObject;
\r
73 import org.simantics.db.common.primitiverequest.PossibleRelatedValue;
\r
74 import org.simantics.db.common.primitiverequest.PossibleRelatedValueImplied;
\r
75 import org.simantics.db.common.primitiverequest.PossibleStatement;
\r
76 import org.simantics.db.common.primitiverequest.PossibleType;
\r
77 import org.simantics.db.common.primitiverequest.PossibleUniqueAdapter;
\r
78 import org.simantics.db.common.primitiverequest.PossibleValue;
\r
79 import org.simantics.db.common.primitiverequest.PossibleValueImplied;
\r
80 import org.simantics.db.common.primitiverequest.RelatedValue;
\r
81 import org.simantics.db.common.primitiverequest.RelatedValueImplied;
\r
82 import org.simantics.db.common.primitiverequest.SingleObject;
\r
83 import org.simantics.db.common.primitiverequest.SingleStatement;
\r
84 import org.simantics.db.common.primitiverequest.SingleType;
\r
85 import org.simantics.db.common.primitiverequest.SingleTypeAny;
\r
86 import org.simantics.db.common.primitiverequest.Types;
\r
87 import org.simantics.db.common.primitiverequest.UniqueAdapter;
\r
88 import org.simantics.db.common.primitiverequest.Value;
\r
89 import org.simantics.db.common.primitiverequest.ValueImplied;
\r
90 import org.simantics.db.common.primitiverequest.VariantValueImplied;
\r
91 import org.simantics.db.common.procedure.adapter.AsyncMultiProcedureAdapter;
\r
92 import org.simantics.db.common.procedure.adapter.ProcedureAdapter;
\r
93 import org.simantics.db.common.procedure.adapter.TransientCacheAsyncListener;
\r
94 import org.simantics.db.common.procedure.adapter.TransientCacheListener;
\r
95 import org.simantics.db.common.procedure.single.SyncReadProcedure;
\r
96 import org.simantics.db.common.procedure.single.wrapper.DeepSingleOrErrorProcedure;
\r
97 import org.simantics.db.common.procedure.single.wrapper.DeepSingleOrNullProcedure;
\r
98 import org.simantics.db.common.procedure.single.wrapper.ExceptionToNullProcedure;
\r
99 import org.simantics.db.common.procedure.single.wrapper.NullSingleOrNullProcedure;
\r
100 import org.simantics.db.common.procedure.single.wrapper.SingleFunctionalOrNullProcedure;
\r
101 import org.simantics.db.common.procedure.single.wrapper.SingleOrErrorProcedure;
\r
102 import org.simantics.db.common.procedure.single.wrapper.SingleOrNullProcedure;
\r
103 import org.simantics.db.common.procedure.wrapper.NoneToAsyncListener;
\r
104 import org.simantics.db.common.procedure.wrapper.NoneToAsyncMultiListener;
\r
105 import org.simantics.db.common.procedure.wrapper.NoneToAsyncMultiProcedure;
\r
106 import org.simantics.db.common.procedure.wrapper.NoneToAsyncProcedure;
\r
107 import org.simantics.db.common.procedure.wrapper.NoneToAsyncSetProcedure;
\r
108 import org.simantics.db.common.procedure.wrapper.SyncToAsyncListener;
\r
109 import org.simantics.db.common.procedure.wrapper.SyncToAsyncMultiListener;
\r
110 import org.simantics.db.common.procedure.wrapper.SyncToAsyncMultiProcedure;
\r
111 import org.simantics.db.common.procedure.wrapper.SyncToAsyncProcedure;
\r
112 import org.simantics.db.common.procedure.wrapper.SyncToAsyncSetProcedure;
\r
113 import org.simantics.db.common.request.AdaptValue;
\r
114 import org.simantics.db.common.request.ResourceRead;
\r
115 import org.simantics.db.common.utils.Logger;
\r
116 import org.simantics.db.common.utils.NameUtils;
\r
117 import org.simantics.db.common.validation.L0Validations;
\r
118 import org.simantics.db.exception.AdaptionException;
\r
119 import org.simantics.db.exception.ArgumentException;
\r
120 import org.simantics.db.exception.AssumptionException;
\r
121 import org.simantics.db.exception.BindingException;
\r
122 import org.simantics.db.exception.DatabaseException;
\r
123 import org.simantics.db.exception.DoesNotContainValueException;
\r
124 import org.simantics.db.exception.EmptyResourceException;
\r
125 import org.simantics.db.exception.InternalException;
\r
126 import org.simantics.db.exception.InvalidLiteralException;
\r
127 import org.simantics.db.exception.ManyObjectsForFunctionalRelationException;
\r
128 import org.simantics.db.exception.NoInverseException;
\r
129 import org.simantics.db.exception.NoSingleResultException;
\r
130 import org.simantics.db.exception.ResourceNotFoundException;
\r
131 import org.simantics.db.exception.ServiceException;
\r
132 import org.simantics.db.exception.ValidationException;
\r
133 import org.simantics.db.impl.RelationContextImpl;
\r
134 import org.simantics.db.impl.ResourceImpl;
\r
135 import org.simantics.db.impl.internal.RandomAccessValueSupport;
\r
136 import org.simantics.db.impl.internal.ResourceData;
\r
137 import org.simantics.db.impl.procedure.CallWrappedSingleQueryProcedure4;
\r
138 import org.simantics.db.impl.procedure.ResultCallWrappedQueryProcedure4;
\r
139 import org.simantics.db.impl.procedure.ResultCallWrappedSingleQueryProcedure4;
\r
140 import org.simantics.db.impl.query.CacheEntry;
\r
141 import org.simantics.db.impl.query.QueryProcessor;
\r
142 import org.simantics.db.impl.query.QuerySupport;
\r
143 import org.simantics.db.impl.query.TripleIntProcedure;
\r
144 import org.simantics.db.impl.support.ResourceSupport;
\r
145 import org.simantics.db.procedure.AsyncListener;
\r
146 import org.simantics.db.procedure.AsyncMultiListener;
\r
147 import org.simantics.db.procedure.AsyncMultiProcedure;
\r
148 import org.simantics.db.procedure.AsyncProcedure;
\r
149 import org.simantics.db.procedure.AsyncSetListener;
\r
150 import org.simantics.db.procedure.Listener;
\r
151 import org.simantics.db.procedure.ListenerBase;
\r
152 import org.simantics.db.procedure.MultiListener;
\r
153 import org.simantics.db.procedure.MultiProcedure;
\r
154 import org.simantics.db.procedure.Procedure;
\r
155 import org.simantics.db.procedure.SetListener;
\r
156 import org.simantics.db.procedure.StatementProcedure;
\r
157 import org.simantics.db.procedure.SyncListener;
\r
158 import org.simantics.db.procedure.SyncMultiListener;
\r
159 import org.simantics.db.procedure.SyncMultiProcedure;
\r
160 import org.simantics.db.procedure.SyncProcedure;
\r
161 import org.simantics.db.procedure.SyncSetListener;
\r
162 import org.simantics.db.request.AsyncMultiRead;
\r
163 import org.simantics.db.request.AsyncRead;
\r
164 import org.simantics.db.request.DelayedWrite;
\r
165 import org.simantics.db.request.DelayedWriteResult;
\r
166 import org.simantics.db.request.ExternalRead;
\r
167 import org.simantics.db.request.MultiRead;
\r
168 import org.simantics.db.request.Read;
\r
169 import org.simantics.db.request.ReadInterface;
\r
170 import org.simantics.db.request.RequestFlags;
\r
171 import org.simantics.db.request.Write;
\r
172 import org.simantics.db.request.WriteInterface;
\r
173 import org.simantics.db.request.WriteOnly;
\r
174 import org.simantics.db.request.WriteOnlyResult;
\r
175 import org.simantics.db.request.WriteResult;
\r
176 import org.simantics.layer0.Layer0;
\r
177 import org.simantics.scl.compiler.types.Type;
\r
178 import org.simantics.scl.compiler.types.exceptions.SCLTypeParseException;
\r
179 import org.simantics.scl.reflection.ReflectionUtils;
\r
180 import org.simantics.scl.reflection.ValueNotFoundException;
\r
181 import org.simantics.scl.runtime.function.Function3;
\r
182 import org.simantics.utils.DataContainer;
\r
183 import org.simantics.utils.Development;
\r
184 import org.simantics.utils.datastructures.Callback;
\r
185 import org.simantics.utils.datastructures.Pair;
\r
186 import org.simantics.utils.datastructures.collections.CollectionUtils;
\r
188 public class ReadGraphImpl implements ReadGraph {
\r
190 final static boolean EMPTY_RESOURCE_CHECK = false;
\r
192 final public CacheEntry parent;
\r
193 final public QueryProcessor processor;
\r
195 final static Binding DATA_TYPE_BINDING_INTERNAL = Bindings.getBindingUnchecked(Datatype.class);
\r
196 final static Serializer DATA_TYPE_SERIALIZER = Bindings.getSerializerUnchecked(DATA_TYPE_BINDING_INTERNAL);
\r
198 final public static TObjectIntHashMap<String> counters = new TObjectIntHashMap<String>();
\r
200 public static void resetCounters() {
\r
204 public static String listCounters(File file) throws IOException {
\r
206 PrintStream b = new PrintStream(new BufferedOutputStream(new FileOutputStream(file)));
\r
208 for(Pair<String,Integer> p : CollectionUtils.valueSortedEntries(counters)) {
\r
209 b.print(-p.second + " " + p.first + "\n");
\r
214 return "Dumped " + counters.size() + " queries.";
\r
219 * Implementation of the interface ReadGraph
\r
221 final public String getURI(final Resource resource) throws AssumptionException, ValidationException, ServiceException {
\r
223 assert (resource != null);
\r
227 return syncRequest(new org.simantics.db.common.uri.ResourceToURI(resource));
\r
229 } catch (AssumptionException e) {
\r
231 throw new AssumptionException(e);
\r
233 } catch (ValidationException e) {
\r
235 throw new ValidationException(e);
\r
237 } catch (ServiceException e) {
\r
239 throw new ServiceException(e);
\r
241 } catch (DatabaseException e) {
\r
243 throw new ServiceException(INTERNAL_ERROR_STRING, e);
\r
249 final public String getPossibleURI(final Resource resource) throws ValidationException, ServiceException {
\r
251 assert (resource != null);
\r
255 return syncRequest(new org.simantics.db.common.uri.ResourceToPossibleURI(resource));
\r
257 } catch (ValidationException e) {
\r
259 throw new ValidationException(e);
\r
261 } catch (ServiceException e) {
\r
263 throw new ServiceException(e);
\r
265 } catch (DatabaseException e) {
\r
267 throw new ServiceException(INTERNAL_ERROR_STRING, e);
\r
273 final public Resource getResource(final String id)
\r
274 throws ResourceNotFoundException, ValidationException,
\r
277 assert (id != null);
\r
281 return syncRequest(new org.simantics.db.common.primitiverequest.Resource(
\r
284 } catch (ResourceNotFoundException e) {
\r
286 throw new ResourceNotFoundException(e);
\r
288 } catch (ValidationException e) {
\r
290 throw new ValidationException(e);
\r
292 } catch (ServiceException e) {
\r
294 throw new ServiceException(e);
\r
296 } catch (DatabaseException e) {
\r
298 throw new ServiceException(INTERNAL_ERROR_STRING, e);
\r
304 final public Resource getPossibleResource(final String id)
\r
305 throws ResourceNotFoundException, ValidationException,
\r
308 assert (id != null);
\r
312 return syncRequest(new org.simantics.db.common.primitiverequest.Resource(
\r
315 } catch (ResourceNotFoundException e) {
\r
319 } catch (ValidationException e) {
\r
321 throw new ValidationException(e);
\r
323 } catch (ServiceException e) {
\r
325 throw new ServiceException(e);
\r
327 } catch (DatabaseException e) {
\r
329 throw new ServiceException(INTERNAL_ERROR_STRING, e);
\r
335 final public Resource getRootLibrary() {
\r
336 return processor.getRootLibraryResource();
\r
339 final public Resource getBuiltin(final String id)
\r
340 throws ResourceNotFoundException, ServiceException {
\r
342 assert (id != null);
\r
346 return syncRequest(new Builtin(id));
\r
348 } catch (ResourceNotFoundException e) {
\r
350 throw new ResourceNotFoundException(e);
\r
352 } catch (ServiceException e) {
\r
354 throw new ServiceException(e);
\r
356 } catch (DatabaseException e) {
\r
358 throw new ServiceException(INTERNAL_ERROR_STRING, e);
\r
364 static class StatementReadProcedure extends TIntArrayListInternal implements StatementProcedure {
\r
366 private static Throwable DONE = new Throwable();
\r
368 Throwable exception = null;
\r
370 final ResourceSupport support;
\r
372 public StatementReadProcedure(ResourceSupport support) {
\r
373 this.support = support;
\r
377 public synchronized void execute(AsyncReadGraph graph, int s, int p, int o) {
\r
384 public void finished(AsyncReadGraph graph) {
\r
389 public void exception(AsyncReadGraph graph, Throwable t) {
\r
393 public void checkAndThrow() throws DatabaseException {
\r
394 if(exception != DONE) {
\r
395 if (exception instanceof DatabaseException)
\r
396 throw (DatabaseException) exception;
\r
398 throw new DatabaseException(
\r
399 "Unexpected exception in ReadGraph.syncRequest(AsyncMultiRead)",
\r
404 public boolean done() {
\r
405 return exception != null;
\r
409 public boolean contains(Object obj) {
\r
410 if(!(obj instanceof InternalStatement))
\r
412 InternalStatement statement = (InternalStatement)obj;
\r
413 int s = statement.s;
\r
414 int p = statement.p;
\r
415 int o = statement.o;
\r
416 for(int i=0;i<sizeInternal();i+=3)
\r
417 if(s==getQuick(i) && p==getQuick(i+1) && o==getQuick(i+2))
\r
422 @SuppressWarnings("unchecked")
\r
424 public <T> T[] toArray(T[] a) {
\r
425 int length = sizeInternal() / 3;
\r
426 if(length > a.length) {
\r
427 Class<?> arrayType = a.getClass();
\r
428 a = (arrayType == Object[].class)
\r
429 ? (T[]) new Object[length]
\r
430 : (T[]) Array.newInstance(arrayType.getComponentType(), length);
\r
433 for(int i=length;i<a.length;++i)
\r
436 for(int i=0,j=0;i<sizeInternal();i+=3,++j)
\r
437 a[j] = (T)new InternalStatement(support, getQuick(i), getQuick(i+1), getQuick(i+2));
\r
442 public boolean add(Statement e) {
\r
443 throw new UnsupportedOperationException();
\r
447 public boolean remove(Object o) {
\r
448 throw new UnsupportedOperationException();
\r
452 public boolean addAll(Collection<? extends Statement> c) {
\r
453 throw new UnsupportedOperationException();
\r
456 class IteratorImpl implements ListIterator<Statement> {
\r
460 public IteratorImpl(int index) {
\r
461 this.index = index;
\r
465 public boolean hasNext() {
\r
466 return index < sizeInternal();
\r
470 public Statement next() {
\r
471 Statement result = new InternalStatement(support, getQuick(index), getQuick(index+1), getQuick(index+2));
\r
477 public void remove() {
\r
478 throw new Error("Not supported");
\r
482 public boolean hasPrevious() {
\r
487 public Statement previous() {
\r
489 Statement result = new InternalStatement(support, getQuick(index), getQuick(index+1), getQuick(index+2));
\r
494 public int nextIndex() {
\r
499 public int previousIndex() {
\r
504 public void set(Statement e) {
\r
505 throw new UnsupportedOperationException();
\r
509 public void add(Statement e) {
\r
510 throw new UnsupportedOperationException();
\r
516 public Iterator<Statement> iterator() {
\r
517 return new IteratorImpl(0);
\r
521 public int size() {
\r
522 return sizeInternal() / 3;
\r
526 public Object[] toArray() {
\r
527 Object[] result = new Object[sizeInternal() / 3];
\r
528 for(int i=0,j=0;j<sizeInternal();i++,j+=3)
\r
529 result[i] = new InternalStatement(support, getQuick(j), getQuick(j+1), getQuick(j+2));
\r
534 public boolean addAll(int index, Collection<? extends Statement> c) {
\r
535 throw new UnsupportedOperationException();
\r
539 public Statement get(int index) {
\r
541 if(index < 0 || index >= sizeInternal())
\r
542 throw new IndexOutOfBoundsException();
\r
543 return new InternalStatement(support, getQuick(index), getQuick(index+1), getQuick(index+2));
\r
547 public Statement set(int index, Statement element) {
\r
548 throw new UnsupportedOperationException();
\r
552 public void add(int index, Statement element) {
\r
553 throw new UnsupportedOperationException();
\r
557 public Statement remove(int index) {
\r
558 throw new UnsupportedOperationException();
\r
562 public int indexOf(Object obj) {
\r
563 if(!(obj instanceof InternalStatement))
\r
565 InternalStatement statement = (InternalStatement)obj;
\r
566 int s = statement.s;
\r
567 int p = statement.p;
\r
568 int o = statement.o;
\r
569 for(int i=0;i<sizeInternal();i+=3)
\r
570 if(s==getQuick(i) && p==getQuick(i+1) && o==getQuick(i+2))
\r
576 public int lastIndexOf(Object obj) {
\r
577 if(!(obj instanceof InternalStatement))
\r
579 InternalStatement statement = (InternalStatement)obj;
\r
580 int s = statement.s;
\r
581 int p = statement.p;
\r
582 int o = statement.o;
\r
583 for(int i=sizeInternal()-3;i>=0;i-=3)
\r
584 if(s==getQuick(i) && p==getQuick(i+1) && o==getQuick(i+2))
\r
590 public ListIterator<Statement> listIterator() {
\r
591 return new IteratorImpl(0);
\r
595 public ListIterator<Statement> listIterator(int index) {
\r
596 return new IteratorImpl(index*3);
\r
600 public List<Statement> subList(int fromIndex, int toIndex) {
\r
601 if(fromIndex < 0 || toIndex*3 >= sizeInternal() || fromIndex > toIndex)
\r
602 throw new IndexOutOfBoundsException();
\r
603 return new RandomAccessSubList<Statement>(this, fromIndex, toIndex-fromIndex);
\r
608 final public Collection<Statement> getStatements(final Resource subject,
\r
609 final Resource relation)
\r
610 throws ManyObjectsForFunctionalRelationException, ServiceException {
\r
612 assert (subject != null);
\r
613 assert (relation != null);
\r
617 StatementReadProcedure procedure = new StatementReadProcedure(getResourceSupport());
\r
618 processor.forEachStatement(this, subject, relation, procedure);
\r
619 procedure.checkAndThrow();
\r
622 } catch (DatabaseException e) {
\r
624 System.err.println(INTERNAL_ERROR_STRING + " getStatements " + subject + " " + relation);
\r
626 StatementReadProcedure procedure = new StatementReadProcedure(getResourceSupport());
\r
627 processor.forEachStatement(this, subject, relation, procedure);
\r
629 return Collections.emptyList();
\r
631 // throw new ServiceException(INTERNAL_ERROR_STRING + " getStatements " + subject + " " + relation, e);
\r
638 final public Collection<Statement> getAssertedStatements(final Resource subject, final Resource relation)
\r
639 throws ManyObjectsForFunctionalRelationException, ServiceException {
\r
641 assert (subject != null);
\r
642 assert (relation != null);
\r
646 return syncRequest(new ForEachAssertedStatement(subject, relation));
\r
648 } catch (ManyObjectsForFunctionalRelationException e) {
\r
650 throw new ManyObjectsForFunctionalRelationException(e);
\r
652 } catch (ServiceException e) {
\r
654 throw new ServiceException(e);
\r
656 } catch (DatabaseException e) {
\r
658 throw new ServiceException(INTERNAL_ERROR_STRING, e);
\r
665 final public Collection<Resource> getPredicates(final Resource subject) throws ServiceException {
\r
667 assert (subject != null);
\r
671 return processor.getPredicates(this, subject);
\r
673 // AsyncMultiReadProcedure<Resource> procedure = new AsyncMultiReadProcedure<Resource>();
\r
674 // processor.forEachPredicate(this, subject, procedure);
\r
675 // procedure.checkAndThrow();
\r
676 // return procedure;
\r
678 } catch (ServiceException e) {
\r
680 throw new ServiceException(e);
\r
682 } catch (DatabaseException e) {
\r
684 throw new ServiceException(INTERNAL_ERROR_STRING, e);
\r
686 } catch (Throwable e) {
\r
688 throw new ServiceException(e);
\r
695 final public Collection<Resource> getPrincipalTypes(final Resource subject)
\r
696 throws ServiceException {
\r
698 assert (subject != null);
\r
702 AsyncMultiReadProcedure<Resource> procedure = new AsyncMultiReadProcedure<Resource>();
\r
703 processor.forEachPrincipalType(this, subject, procedure);
\r
704 procedure.checkAndThrow();
\r
707 } catch (ServiceException e) {
\r
709 throw new ServiceException(e);
\r
711 } catch (DatabaseException e) {
\r
713 throw new ServiceException(INTERNAL_ERROR_STRING, e);
\r
720 final public Set<Resource> getTypes(final Resource subject) throws ServiceException {
\r
722 assert (subject != null);
\r
726 return processor.getTypes(this, subject);
\r
728 } catch (ServiceException e) {
\r
730 throw new ServiceException(e);
\r
732 } catch (DatabaseException e) {
\r
734 throw new ServiceException(INTERNAL_ERROR_STRING, e);
\r
736 } catch (Throwable e) {
\r
738 throw new ServiceException(e);
\r
745 final public Set<Resource> getSupertypes(final Resource subject)
\r
746 throws ServiceException {
\r
748 assert (subject != null);
\r
752 SyncReadProcedure<Set<Resource>> procedure = new SyncReadProcedure<Set<Resource>>();
\r
753 processor.forSupertypes(this, subject, procedure);
\r
754 procedure.checkAndThrow();
\r
755 return procedure.result;
\r
757 } catch (ServiceException e) {
\r
759 throw new ServiceException(e);
\r
761 } catch (DatabaseException e) {
\r
763 throw new ServiceException(INTERNAL_ERROR_STRING, e);
\r
770 final public Set<Resource> getSuperrelations(final Resource subject)
\r
771 throws ServiceException {
\r
773 assert (subject != null);
\r
777 SyncReadProcedure<Set<Resource>> procedure = new SyncReadProcedure<Set<Resource>>();
\r
778 processor.forSuperrelations(this, subject, procedure);
\r
779 procedure.checkAndThrow();
\r
780 return procedure.result;
\r
782 } catch (ServiceException e) {
\r
784 throw new ServiceException(e);
\r
786 } catch (DatabaseException e) {
\r
788 throw new ServiceException(INTERNAL_ERROR_STRING, e);
\r
795 public Resource getPossibleSuperrelation(Resource subject) throws ServiceException {
\r
799 SyncReadProcedure<Resource> procedure = new SyncReadProcedure<Resource>();
\r
800 processor.forPossibleSuperrelation(this, subject, procedure);
\r
801 procedure.checkAndThrow();
\r
802 return procedure.result;
\r
804 } catch (ServiceException e) {
\r
806 throw new ServiceException(e);
\r
808 } catch (DatabaseException e) {
\r
810 throw new ServiceException(INTERNAL_ERROR_STRING, e);
\r
817 final public Collection<Resource> getObjects(final Resource subject, final Resource relation)
\r
818 throws ServiceException {
\r
820 assert (subject != null);
\r
821 assert (relation != null);
\r
823 if(Development.DEVELOPMENT) {
\r
824 if(Development.isTrue(DevelopmentKeys.READGRAPH_COUNT)) {
\r
825 counters.adjustOrPutValue("objects $" + subject.getResourceId() + " $" + relation.getResourceId(), 1, 1);
\r
827 //if(subject.getResourceId()==xx && relation.getResourceId()==xx) new Exception().printStackTrace();
\r
832 AsyncMultiReadProcedure<Resource> procedure = new AsyncMultiReadProcedure<Resource>();
\r
833 processor.forEachObject(this, subject, relation, procedure);
\r
834 procedure.checkAndThrow();
\r
837 } catch (DatabaseException e) {
\r
839 throw new ServiceException(INTERNAL_ERROR_STRING, e);
\r
846 final public Collection<Resource> getAssertedObjects(
\r
847 final Resource subject, final Resource relation)
\r
848 throws ManyObjectsForFunctionalRelationException, ServiceException {
\r
850 if (subject == null)
\r
851 throw new ArgumentException("Subject must not be null.");
\r
852 if (relation == null)
\r
853 throw new ArgumentException("Relation must not be null. Subject=" + subject);
\r
857 return syncRequest(new ForEachAssertedObject(subject, relation));
\r
859 } catch (ManyObjectsForFunctionalRelationException e) {
\r
861 throw new ManyObjectsForFunctionalRelationException(e);
\r
863 } catch (ServiceException e) {
\r
865 throw new ServiceException(e);
\r
867 } catch (DatabaseException e) {
\r
869 throw new ServiceException(INTERNAL_ERROR_STRING, e);
\r
876 final public Resource getInverse(final Resource relation) throws NoInverseException, ServiceException {
\r
878 assert (relation != null);
\r
882 return getSingleObject(relation, processor.querySupport.getResource(processor.getInverseOf()));
\r
884 } catch (NoSingleResultException e) {
\r
886 throw new NoInverseException(e);
\r
888 } catch (ServiceException e) {
\r
890 throw new ServiceException(e);
\r
897 final public Resource getSingleObject(final Resource subject, final Resource relation) throws NoSingleResultException, ServiceException {
\r
899 if( subject == null) throw new IllegalArgumentException("subject can not be null");
\r
900 if( relation == null) throw new IllegalArgumentException("relation can not be null");
\r
904 int single = processor.getSingleObject(this, subject, relation);
\r
905 if(single == 0) throw new NoSingleResultException("subject=" + subject + " relation="+relation);
\r
906 return processor.querySupport.getResource(single);
\r
908 } catch (NoSingleResultException e) {
\r
910 if(EMPTY_RESOURCE_CHECK) {
\r
911 if(!hasStatement(subject)) throw new EmptyResourceException("Resource " + debugString(subject));
\r
914 throw new NoSingleResultException("No single object for subject "
\r
915 + debugString(subject) + " and relation "
\r
916 + debugString(relation), e);
\r
918 } catch (DatabaseException e) {
\r
920 throw new ServiceException(e);
\r
927 final public Statement getSingleStatement(final Resource subject,
\r
928 final Resource relation) throws NoSingleResultException,
\r
929 ManyObjectsForFunctionalRelationException, ServiceException {
\r
931 assert (subject != null);
\r
932 assert (relation != null);
\r
936 Collection<Statement> statements = getStatements(subject, relation);
\r
937 if(statements.size() == 1) return statements.iterator().next();
\r
938 else throw new NoSingleResultException("");
\r
940 } catch (NoSingleResultException e) {
\r
942 if(EMPTY_RESOURCE_CHECK) {
\r
943 if(!hasStatement(subject)) throw new EmptyResourceException("Resource " + debugString(subject));
\r
946 throw new NoSingleResultException("No single statement for subject "
\r
947 + debugString(subject) + " and relation "
\r
948 + debugString(relation), e);
\r
950 } catch (DatabaseException e) {
\r
952 throw new ServiceException(e);
\r
959 final public Resource getSingleType(final Resource subject) throws NoSingleResultException,
\r
962 assert (subject != null);
\r
966 ArrayList<Resource> principalTypes = (ArrayList<Resource>)getPrincipalTypes(subject);
\r
967 if(principalTypes.size() == 1) return principalTypes.get(0);
\r
968 else throw new NoSingleResultException("");
\r
970 } catch (NoSingleResultException e) {
\r
972 throw new NoSingleResultException(e);
\r
974 } catch (ServiceException e) {
\r
976 throw new ServiceException(e);
\r
983 final public Resource getSingleType(final Resource subject,
\r
984 final Resource baseType) throws NoSingleResultException,
\r
987 assert (subject != null);
\r
988 assert (baseType != null);
\r
992 return syncRequest(new SingleType(subject, baseType));
\r
994 } catch (NoSingleResultException e) {
\r
996 throw new NoSingleResultException(new NoSingleResultException("subject=" + subject + ", baseType=" + baseType, e));
\r
998 } catch (ServiceException e) {
\r
1000 throw new ServiceException(e);
\r
1002 } catch (DatabaseException e) {
\r
1004 throw new ServiceException(INTERNAL_ERROR_STRING, e);
\r
1011 final public <T> T getValue(final Resource subject) throws DoesNotContainValueException, ServiceException {
\r
1013 assert (subject != null);
\r
1017 Layer0 L0 = processor.getL0(this);
\r
1018 int object = processor.getSingleObject(this, subject, L0.HasDataType);
\r
1019 if(object == 0) throw new DoesNotContainValueException("No data type for " + subject);
\r
1021 if(processor.isImmutable(object)) {
\r
1022 Binding binding = syncRequest(new DatatypeBinding(processor.querySupport.getResource(object)), TransientCacheListener.<Binding>instance());
\r
1023 return getValue(subject, binding);
\r
1025 byte[] dt = processor.getValue(this, object);
\r
1026 if(dt == null) throw new ServiceException("No data type for " + subject);
\r
1027 Datatype datatype = (Datatype)DATA_TYPE_SERIALIZER.deserialize(dt);
\r
1028 Binding binding = Bindings.getBinding(datatype);
\r
1029 return getValue(subject, binding);
\r
1032 } catch (IOException e) {
\r
1034 throw new ServiceException(e);
\r
1036 } catch (DoesNotContainValueException e) {
\r
1038 throw new DoesNotContainValueException(e, subject);
\r
1040 } catch (ServiceException e) {
\r
1042 throw new ServiceException(e);
\r
1044 } catch (DatabaseException e) {
\r
1046 throw new ServiceException(INTERNAL_ERROR_STRING, e);
\r
1053 final public Variant getVariantValue(final Resource subject) throws DoesNotContainValueException, ServiceException {
\r
1055 assert (subject != null);
\r
1059 Layer0 L0 = processor.getL0(this);
\r
1060 int object = processor.getSingleObject(this, subject, L0.HasDataType);
\r
1061 if(object == 0) throw new DoesNotContainValueException("No data type for " + subject);
\r
1063 if(processor.isImmutable(object)) {
\r
1064 Binding binding = syncRequest(new DatatypeBinding(processor.querySupport.getResource(object)), TransientCacheListener.<Binding>instance());
\r
1065 return new Variant(binding, getValue(subject, binding));
\r
1067 byte[] dt = processor.getValue(this, object);
\r
1068 if(dt == null) throw new ServiceException("No data type for " + subject);
\r
1069 Datatype datatype = (Datatype)DATA_TYPE_SERIALIZER.deserialize(dt);
\r
1070 Binding binding = Bindings.getBinding(datatype);
\r
1071 return new Variant(binding, getValue(subject, binding));
\r
1074 } catch (IOException e) {
\r
1076 throw new ServiceException(e);
\r
1078 } catch (DoesNotContainValueException e) {
\r
1080 throw new DoesNotContainValueException(e, subject);
\r
1082 } catch (ServiceException e) {
\r
1084 throw new ServiceException(e);
\r
1086 } catch (DatabaseException e) {
\r
1088 throw new ServiceException(INTERNAL_ERROR_STRING, e);
\r
1093 static final IdentityHashMap<Binding,Serializer> serializers = new IdentityHashMap<Binding,Serializer>();
\r
1096 serializers.put(Bindings.STRING, Bindings.STRING.serializer());
\r
1099 final protected Serializer getSerializer(Binding binding) {
\r
1100 return binding.serializer();
\r
1104 final public <T> T getValue(final Resource subject, final Binding binding) throws DoesNotContainValueException, BindingException,
\r
1105 ServiceException {
\r
1107 assert (subject != null);
\r
1111 byte[] bytes = processor.getValue(this, subject);
\r
1112 if (bytes == null) throw new DoesNotContainValueException("No value for resource " + subject);
\r
1114 Serializer serializer = getSerializer(binding);
\r
1115 return (T)serializer.deserialize(bytes);
\r
1117 } catch (DoesNotContainValueException e) {
\r
1119 throw new DoesNotContainValueException(e);
\r
1121 } catch (IOException e) {
\r
1123 throw new ServiceException(e);
\r
1125 } catch (DatabaseException e) {
\r
1127 throw new ServiceException(e);
\r
1129 } catch (BufferUnderflowException e) {
\r
1130 // This is sometimes thrown when deserialize fails because wrong format.
\r
1131 // For callers of this method this is just an service exception.
\r
1132 throw new ServiceException(e);
\r
1138 final public <T> T getRelatedValue(final Resource subject, final Resource relation) throws NoSingleResultException,
\r
1139 DoesNotContainValueException, ServiceException {
\r
1141 assert (subject != null);
\r
1142 assert (relation != null);
\r
1146 Resource object = getSingleObject(subject, relation);
\r
1147 return getValue(object);
\r
1149 } catch (NoSingleResultException e) {
\r
1151 throw new NoSingleResultException(e);
\r
1153 } catch (DoesNotContainValueException e) {
\r
1156 Layer0 L0 = processor.getL0(this);
\r
1157 Resource object = getPossibleObject(subject, relation);
\r
1158 if(isInstanceOf(object, L0.Value)) {
\r
1159 if(isInstanceOf(object, L0.Literal)) {
\r
1160 throw new DoesNotContainValueException(e);
\r
1162 throw new InvalidLiteralException("The object " + object + " is not an instance of L0.Literal (use getRelatedValue2 instead)");
\r
1165 throw new DoesNotContainValueException("The object " + object + " is not an instance of L0.Value");
\r
1167 } catch (DoesNotContainValueException e2) {
\r
1169 } catch (DatabaseException e2) {
\r
1170 throw new InternalException("The client failed to analyse the cause of the following exception", e);
\r
1173 } catch (ServiceException e) {
\r
1175 throw new ServiceException(e);
\r
1182 final public Variant getRelatedVariantValue(final Resource subject, final Resource relation) throws NoSingleResultException,
\r
1183 DoesNotContainValueException, ServiceException {
\r
1185 assert (subject != null);
\r
1186 assert (relation != null);
\r
1190 Resource object = getSingleObject(subject, relation);
\r
1191 return getVariantValue(object);
\r
1193 } catch (NoSingleResultException e) {
\r
1195 throw new NoSingleResultException(e);
\r
1197 } catch (DoesNotContainValueException e) {
\r
1200 Layer0 L0 = processor.getL0(this);
\r
1201 Resource object = getPossibleObject(subject, relation);
\r
1202 if(isInstanceOf(object, L0.Value)) {
\r
1203 if(isInstanceOf(object, L0.Literal)) {
\r
1204 throw new DoesNotContainValueException(e);
\r
1206 throw new InvalidLiteralException("The object " + object + " is not an instance of L0.Literal (use getRelatedValue2 instead)");
\r
1209 throw new DoesNotContainValueException("The object " + object + " is not an instance of L0.Value");
\r
1211 } catch (DoesNotContainValueException e2) {
\r
1213 } catch (DatabaseException e2) {
\r
1214 throw new InternalException("The client failed to analyse the cause of the following exception", e);
\r
1217 } catch (ServiceException e) {
\r
1219 throw new ServiceException(e);
\r
1226 final public <T> T getRelatedValue(final Resource subject, final Resource relation, final Binding binding)
\r
1227 throws NoSingleResultException, DoesNotContainValueException, BindingException, ServiceException {
\r
1229 assert (subject != null);
\r
1230 assert (relation != null);
\r
1234 Resource object = getSingleObject(subject, relation);
\r
1235 return getValue(object, binding);
\r
1237 } catch (NoSingleResultException e) {
\r
1239 String message = "";
\r
1243 String subjectName = NameUtils.getSafeName(this, subject, true);
\r
1244 String relationName = NameUtils.getSafeName(this, relation, true);
\r
1245 message = "Subject: " + subjectName + ", Relation: " + relationName;
\r
1247 } catch (DatabaseException e2) {
\r
1251 throw new NoSingleResultException(message);
\r
1253 } catch (DoesNotContainValueException e) {
\r
1255 throw new DoesNotContainValueException(e);
\r
1257 } catch (ServiceException e) {
\r
1259 throw new ServiceException(e);
\r
1261 } catch (DatabaseException e) {
\r
1263 throw new ServiceException(INTERNAL_ERROR_STRING, e);
\r
1270 final public <T> T adapt(final Resource resource, final Class<T> clazz)
\r
1271 throws AdaptionException, ValidationException, ServiceException {
\r
1273 assert (resource != null);
\r
1274 assert (clazz != null);
\r
1278 return syncRequest(new Adapter<T>(resource, clazz));
\r
1280 } catch (AdaptionException e) {
\r
1282 throw new AdaptionException(e);
\r
1284 } catch (ValidationException e) {
\r
1286 throw new ValidationException(e);
\r
1288 } catch (ServiceException e) {
\r
1290 throw new ServiceException(e);
\r
1292 } catch (DatabaseException e) {
\r
1294 throw new ServiceException(INTERNAL_ERROR_STRING, e);
\r
1301 final public <T,C> T adaptContextual(final Resource resource, final C context, final Class<C> contextClass, final Class<T> clazz)
\r
1302 throws AdaptionException, ValidationException, ServiceException {
\r
1304 assert (resource != null);
\r
1305 assert (context != null);
\r
1307 class ContextualAdapter implements AsyncRead<T> {
\r
1309 final private Resource resource;
\r
1310 final private C context;
\r
1311 final private Class<T> clazz;
\r
1314 public int hashCode() {
\r
1315 return resource.hashCode() + 31 * (clazz.hashCode() + 41 * context.hashCode());
\r
1319 final public int threadHash() {
\r
1320 return resource.getThreadHash();
\r
1324 public boolean equals(Object object) {
\r
1325 if (this == object)
\r
1327 else if (object == null)
\r
1329 else if (getClass() != object.getClass())
\r
1331 ContextualAdapter r = (ContextualAdapter)object;
\r
1332 return resource.equals(r.resource) && context.equals(r.context) && clazz.equals(r.clazz);
\r
1336 public int getFlags() {
\r
1340 public ContextualAdapter(Resource resource, C context, Class<T> clazz) {
\r
1341 this.resource = resource;
\r
1342 this.context = context;
\r
1343 this.clazz = clazz;
\r
1347 public void perform(AsyncReadGraph graph, AsyncProcedure<T> procedure) {
\r
1349 final AdaptionService service = getSession().peekService(AdaptionService.class);
\r
1350 if (service == null)
\r
1351 procedure.exception(graph, new ServiceException("No AdaptionService available"));
\r
1353 service.adapt(graph, resource, context, contextClass, clazz, false, procedure);
\r
1358 public String toString() {
\r
1359 return "Adapter for (" + resource + "," + context + ") as " + clazz.getName();
\r
1366 return syncRequest(new ContextualAdapter(resource, context, clazz));
\r
1368 } catch (AdaptionException e) {
\r
1370 throw new AdaptionException(e);
\r
1372 } catch (ValidationException e) {
\r
1374 throw new ValidationException(e);
\r
1376 } catch (ServiceException e) {
\r
1378 throw new ServiceException(e);
\r
1380 } catch (DatabaseException e) {
\r
1382 throw new ServiceException(INTERNAL_ERROR_STRING, e);
\r
1389 final public <T> T adaptRelated(final Resource resource, final Resource relation, final Class<T> clazz)
\r
1390 throws AdaptionException, NoSingleResultException, ValidationException, ServiceException {
\r
1392 assert (resource != null);
\r
1393 assert (clazz != null);
\r
1395 Statement stm = getSingleStatement(resource, relation);
\r
1397 return adaptContextual(stm.getObject(), new RelationContextImpl(resource, stm), RelationContext.class, clazz);
\r
1402 final public <T> T getPossibleRelatedAdapter(final Resource resource, final Resource relation, final Class<T> clazz)
\r
1403 throws ValidationException, ServiceException {
\r
1406 return adaptRelated(resource, relation, clazz);
\r
1407 } catch (DatabaseException e) {
\r
1414 final public <T,C> T getPossibleContextualAdapter(final Resource resource, final C context, final Class<C> contextClass, final Class<T> clazz)
\r
1415 throws ValidationException, ServiceException {
\r
1417 assert (resource != null);
\r
1418 assert (context != null);
\r
1420 class PossibleContextualAdapter implements AsyncRead<T> {
\r
1422 final private Resource resource;
\r
1423 final private C context;
\r
1424 final private Class<T> clazz;
\r
1427 public int hashCode() {
\r
1428 return resource.hashCode() + 31 * (clazz.hashCode() + 41 * context.hashCode());
\r
1432 final public int threadHash() {
\r
1433 return resource.getThreadHash();
\r
1437 public boolean equals(Object object) {
\r
1438 if (this == object)
\r
1440 else if (object == null)
\r
1442 else if (getClass() != object.getClass())
\r
1444 PossibleContextualAdapter r = (PossibleContextualAdapter)object;
\r
1445 return resource.equals(r.resource) && context.equals(r.context) && clazz.equals(r.clazz);
\r
1449 public int getFlags() {
\r
1453 public PossibleContextualAdapter(Resource resource, C context, Class<T> clazz) {
\r
1454 this.resource = resource;
\r
1455 this.context = context;
\r
1456 this.clazz = clazz;
\r
1460 public void perform(AsyncReadGraph graph, AsyncProcedure<T> procedure) {
\r
1462 final AdaptionService service = getSession().peekService(AdaptionService.class);
\r
1463 if (service == null)
\r
1464 procedure.exception(graph, new ServiceException("No AdaptionService available"));
\r
1466 service.adapt(graph, resource, context, contextClass, clazz, true, procedure);
\r
1471 public String toString() {
\r
1472 return "Possible adapter for (" + resource + "," + context + ") as " + clazz.getName();
\r
1479 return syncRequest(new PossibleContextualAdapter(resource, context, clazz));
\r
1481 } catch (ValidationException e) {
\r
1483 throw new ValidationException(e);
\r
1485 } catch (ServiceException e) {
\r
1487 throw new ServiceException(e);
\r
1489 } catch (DatabaseException e) {
\r
1491 throw new ServiceException(INTERNAL_ERROR_STRING, e);
\r
1498 final public <T> T adaptUnique(final Resource resource, final Class<T> clazz)
\r
1499 throws AdaptionException, ValidationException, ServiceException {
\r
1501 assert (resource != null);
\r
1502 assert (clazz != null);
\r
1506 return syncRequest(new UniqueAdapter<T>(resource, clazz));
\r
1508 } catch (AdaptionException e) {
\r
1510 throw new AdaptionException(e);
\r
1512 } catch (ValidationException e) {
\r
1514 throw new ValidationException(e);
\r
1516 } catch (ServiceException e) {
\r
1518 throw new ServiceException(e);
\r
1520 } catch (DatabaseException e) {
\r
1522 throw new ServiceException(INTERNAL_ERROR_STRING, e);
\r
1529 final public Resource getPossibleInverse(final Resource relation)
\r
1530 throws ServiceException {
\r
1532 assert (relation != null);
\r
1536 return getPossibleObject(relation, processor.querySupport.getResource(processor.getInverseOf()));
\r
1538 } catch (ServiceException e) {
\r
1540 throw new ServiceException(e);
\r
1542 } catch (DatabaseException e) {
\r
1544 throw new ServiceException(INTERNAL_ERROR_STRING, e);
\r
1551 public Resource getPossibleObject(final Resource subject, final Resource relation)
\r
1552 throws ManyObjectsForFunctionalRelationException, ServiceException {
\r
1554 assert (subject != null);
\r
1555 assert (relation != null);
\r
1559 int result = processor.getSingleObject(this, subject, relation);
\r
1560 if(result == 0) return null;
\r
1562 return processor.querySupport.getResource(result);
\r
1564 } catch (ManyObjectsForFunctionalRelationException e) {
\r
1566 throw new ManyObjectsForFunctionalRelationException("subject=" + subject + ", relation=" + relation, e);
\r
1568 } catch (DatabaseException e) {
\r
1570 throw new ServiceException(e);
\r
1577 final public Statement getPossibleStatement(final Resource subject, final Resource relation)
\r
1578 throws ManyObjectsForFunctionalRelationException, ServiceException {
\r
1580 assert (subject != null);
\r
1581 assert (relation != null);
\r
1585 Collection<Statement> statements = getStatements(subject, relation);
\r
1586 if(statements.size() == 1) return statements.iterator().next();
\r
1589 } catch (ManyObjectsForFunctionalRelationException e) {
\r
1591 throw new ManyObjectsForFunctionalRelationException("Many objects in " + subject + " for functional relation " + relation);
\r
1593 } catch (ServiceException e) {
\r
1595 throw new ServiceException(e);
\r
1602 final public Resource getPossibleType(final Resource subject, final Resource baseType) throws ServiceException {
\r
1604 assert (subject != null);
\r
1605 assert (baseType != null);
\r
1609 AsyncReadProcedure<Resource> procedure = new AsyncReadProcedure<Resource>();
\r
1610 forPossibleType(subject, baseType, procedure);
\r
1611 procedure.checkAndThrow();
\r
1612 return procedure.result;
\r
1614 } catch (ServiceException e) {
\r
1616 throw new ServiceException(e);
\r
1618 } catch (DatabaseException e) {
\r
1620 throw new ServiceException(INTERNAL_ERROR_STRING, e);
\r
1627 final public <T> T getPossibleValue(final Resource subject) throws ServiceException {
\r
1629 assert (subject != null);
\r
1633 int object = processor.getSingleObject(this, subject, processor.getL0(this).HasDataType);
\r
1634 if(object == 0) return null;
\r
1636 if(processor.isImmutable(object)) {
\r
1637 Binding binding = syncRequest(new DatatypeBinding(processor.querySupport.getResource(object)), TransientCacheListener.<Binding>instance());
\r
1638 return getPossibleValue(subject, binding);
\r
1640 byte[] dt = processor.getValue(this, object);
\r
1641 if(dt == null) return null;
\r
1642 Datatype datatype = (Datatype)DATA_TYPE_SERIALIZER.deserialize(dt);
\r
1643 Binding binding = Bindings.getBinding(datatype);
\r
1644 return getPossibleValue(subject, binding);
\r
1647 } catch (IOException e) {
\r
1649 throw new ServiceException(e);
\r
1651 } catch (ServiceException e) {
\r
1653 throw new ServiceException(e);
\r
1655 } catch (DatabaseException e) {
\r
1657 throw new ServiceException(INTERNAL_ERROR_STRING, e);
\r
1664 final public <T> T getPossibleValue(final Resource subject, final Binding binding) throws BindingException, ServiceException {
\r
1666 assert (subject != null);
\r
1667 assert (binding != null);
\r
1671 byte[] dt = processor.getValue(this, subject);
\r
1672 if(dt == null) return null;
\r
1673 Serializer serializer = getSerializer(binding);
\r
1674 return (T)serializer.deserialize(dt);
\r
1676 } catch (IOException e) {
\r
1678 throw new ServiceException(e);
\r
1680 } catch (BindingException e) {
\r
1682 throw new BindingException(e);
\r
1684 } catch (ServiceException e) {
\r
1686 throw new ServiceException(e);
\r
1688 } catch (DatabaseException e) {
\r
1689 e.printStackTrace();
\r
1690 throw new ServiceException(INTERNAL_ERROR_STRING, e);
\r
1696 public <T> T getPossibleRelatedValue(final Resource subject, final Resource relation)
\r
1697 throws ManyObjectsForFunctionalRelationException, ServiceException {
\r
1699 assert (subject != null);
\r
1700 assert (relation != null);
\r
1704 Resource object = getPossibleObject(subject, relation);
\r
1705 if(object == null) return null;
\r
1706 else return getPossibleValue(object);
\r
1708 } catch (ManyObjectsForFunctionalRelationException e) {
\r
1710 throw new ManyObjectsForFunctionalRelationException(e);
\r
1712 } catch (ServiceException e) {
\r
1714 throw new ServiceException(e);
\r
1721 public <T> T getPossibleRelatedValue(final Resource subject, final Resource relation, final Binding binding)
\r
1722 throws ManyObjectsForFunctionalRelationException, BindingException, ServiceException {
\r
1724 assert (subject != null);
\r
1725 assert (relation != null);
\r
1726 assert (binding != null);
\r
1730 Resource object = getPossibleObject(subject, relation);
\r
1731 if(object == null) return null;
\r
1732 else return getPossibleValue(object, binding);
\r
1734 } catch (ManyObjectsForFunctionalRelationException e) {
\r
1736 throw new ManyObjectsForFunctionalRelationException(e);
\r
1738 } catch (BindingException e) {
\r
1740 throw new BindingException(e);
\r
1742 } catch (ServiceException e) {
\r
1744 throw new ServiceException(e);
\r
1751 public <T> T getPossibleAdapter(Resource resource, Class<T> clazz) throws ValidationException, ServiceException {
\r
1753 assert (resource != null);
\r
1754 assert (clazz != null);
\r
1758 return syncRequest(new PossibleAdapter<T>(resource, clazz));
\r
1760 } catch (ValidationException e) {
\r
1762 throw new ValidationException(e);
\r
1764 } catch (AdaptionException e) {
\r
1768 } catch (DatabaseException e) {
\r
1770 throw new ServiceException(INTERNAL_ERROR_STRING, e);
\r
1776 public <T> T getPossibleUniqueAdapter(Resource resource, Class<T> clazz) throws ValidationException, ServiceException {
\r
1778 assert (resource != null);
\r
1779 assert (clazz != null);
\r
1783 return syncRequest(new PossibleUniqueAdapter<T>(resource, clazz));
\r
1785 } catch (AdaptionException e) {
\r
1789 } catch (ValidationException e) {
\r
1791 throw new ValidationException(e);
\r
1793 } catch (DatabaseException e) {
\r
1795 throw new ServiceException(INTERNAL_ERROR_STRING, e);
\r
1802 final public boolean isInstanceOf(final Resource resource, final Resource type) throws ServiceException {
\r
1804 assert (resource != null);
\r
1805 assert (type != null);
\r
1807 Set<Resource> resources = getTypes(resource);
\r
1808 // This check was necessary because some of the callers of this method got stuck when the NPE was thrown from here.
\r
1809 if (null == resources)
\r
1812 if(EMPTY_RESOURCE_CHECK) {
\r
1813 if (resources.isEmpty()) {
\r
1814 if(!hasStatement(resource)) throw new EmptyResourceException("Resource " + debugString(resource));
\r
1818 return resources.contains(type);
\r
1823 final public boolean isInheritedFrom(final Resource resource, final Resource type) throws ServiceException {
\r
1825 assert (resource != null);
\r
1826 assert (type != null);
\r
1830 if(resource.equals(type)) return true;
\r
1832 return getSupertypes(resource).contains(type);
\r
1834 } catch (ServiceException e) {
\r
1836 throw new ServiceException(e);
\r
1843 final public boolean isSubrelationOf(final Resource resource, final Resource type) throws ServiceException {
\r
1845 assert (resource != null);
\r
1846 assert (type != null);
\r
1850 if(resource.equals(type)) return true;
\r
1852 return getSuperrelations(resource).contains(type);
\r
1854 } catch (ServiceException e) {
\r
1856 throw new ServiceException(e);
\r
1863 final public boolean hasStatement(final Resource subject) throws ServiceException {
\r
1865 assert (subject != null);
\r
1869 SyncReadProcedure<Boolean> procedure = new SyncReadProcedure<Boolean>();
\r
1870 processor.forHasStatement(this, subject, procedure);
\r
1871 procedure.checkAndThrow();
\r
1872 return procedure.result;
\r
1874 } catch (ServiceException e) {
\r
1876 throw new ServiceException(e);
\r
1878 } catch (DatabaseException e) {
\r
1880 throw new ServiceException(INTERNAL_ERROR_STRING, e);
\r
1887 final public boolean hasStatement(final Resource subject, final Resource relation) throws ServiceException {
\r
1889 assert (subject != null);
\r
1890 assert (relation != null);
\r
1894 Collection<Resource> objects = getObjects(subject, relation);
\r
1895 return !objects.isEmpty();
\r
1897 } catch (ServiceException e) {
\r
1899 throw new ServiceException(e);
\r
1906 final public boolean hasStatement(final Resource subject, final Resource relation, final Resource object) throws ServiceException {
\r
1908 assert (subject != null);
\r
1909 assert (relation != null);
\r
1910 assert (object != null);
\r
1914 for(Resource o : getObjects(subject, relation)) {
\r
1915 if(object.equals(o)) return true;
\r
1920 } catch (ServiceException e) {
\r
1922 throw new ServiceException(e);
\r
1929 final public boolean hasValue(final Resource subject) throws ServiceException {
\r
1931 assert (subject != null);
\r
1935 SyncReadProcedure<Boolean> procedure = new SyncReadProcedure<Boolean>();
\r
1936 processor.forHasValue(this, subject, procedure);
\r
1937 procedure.checkAndThrow();
\r
1938 return procedure.result;
\r
1940 } catch (ServiceException e) {
\r
1942 throw new ServiceException(e);
\r
1944 } catch (DatabaseException e) {
\r
1946 throw new ServiceException(INTERNAL_ERROR_STRING, e);
\r
1952 final AsyncProcedure NONE = new AsyncProcedure() {
\r
1955 public void execute(AsyncReadGraph graph, Object result) {
\r
1959 public void exception(AsyncReadGraph graph, Throwable throwable) {
\r
1965 * Implementation of the interface RequestProcessor
\r
1969 public <T> T syncRequest(final Read<T> request) throws DatabaseException {
\r
1971 assert (request != null);
\r
1973 if (parent != null) {
\r
1976 return processor.queryRead(this, request, parent, null, null);
\r
1977 } catch (Throwable e) {
\r
1978 if(e instanceof DatabaseException) throw (DatabaseException)e;
\r
1979 else throw new DatabaseException(e);
\r
1986 return processor.tryQuery(this, request);
\r
1988 } catch (Throwable throwable) {
\r
1990 //Logger.defaultLogError("Internal read request failure", throwable);
\r
1992 if (throwable instanceof DatabaseException)
\r
1993 throw (DatabaseException) throwable;
\r
1995 throw new DatabaseException(
\r
1996 "Unexpected exception in ReadGraph.syncRequest(Read,Procedure)",
\r
2006 public <T> T syncRequest(Read<T> request, SyncListener<T> procedure)
\r
2007 throws DatabaseException {
\r
2008 return syncRequest(request, new SyncToAsyncListener<T>(procedure));
\r
2012 public <T> T syncRequest(Read<T> request, final Listener<T> procedure)
\r
2013 throws DatabaseException {
\r
2014 return syncRequest(request, new NoneToAsyncListener<T>(procedure));
\r
2018 public <T> T syncRequest(final Read<T> request, final AsyncProcedure<T> procedure) throws DatabaseException {
\r
2020 assert (request != null);
\r
2022 ListenerBase listener = procedure != null ? getListenerBase(procedure) : null;
\r
2024 if (parent != null || listener != null) {
\r
2027 return processor.queryRead(this, request, parent, procedure, listener);
\r
2028 } catch (Throwable e) {
\r
2029 if(e instanceof DatabaseException) throw (DatabaseException)e;
\r
2030 else throw new DatabaseException(e);
\r
2037 T t = processor.tryQuery(this, request);
\r
2038 if(procedure != null)
\r
2039 procedure.execute(this, t);
\r
2043 } catch (Throwable throwable) {
\r
2045 Logger.defaultLogError("Internal read request failure", throwable);
\r
2047 if(procedure != null)
\r
2048 procedure.exception(this, throwable);
\r
2050 if (throwable instanceof DatabaseException)
\r
2051 throw (DatabaseException) throwable;
\r
2053 throw new DatabaseException(
\r
2054 "Unexpected exception in ReadGraph.syncRequest(Read,Procedure)",
\r
2064 public <T> T syncRequest(final Read<T> request,
\r
2065 final SyncProcedure<T> procedure) throws DatabaseException {
\r
2066 return syncRequest(request, new SyncToAsyncProcedure<T>(procedure));
\r
2070 public <T> T syncRequest(Read<T> request, Procedure<T> procedure)
\r
2071 throws DatabaseException {
\r
2072 return syncRequest(request, new NoneToAsyncProcedure<T>(procedure));
\r
2075 static class AsyncReadProcedure<T> implements AsyncProcedure<T> {
\r
2077 private static Throwable DONE = new Throwable();
\r
2080 Throwable exception = null;
\r
2083 public void execute(AsyncReadGraph graph, T t) {
\r
2089 public void exception(AsyncReadGraph graph, Throwable t) {
\r
2093 public void checkAndThrow() throws DatabaseException {
\r
2094 if(exception != DONE) {
\r
2095 if (exception instanceof DatabaseException)
\r
2096 throw (DatabaseException) exception;
\r
2098 throw new DatabaseException(
\r
2099 "Unexpected exception in ReadGraph.syncRequest(AsyncMultiRead)",
\r
2104 public boolean done() {
\r
2105 return exception != null;
\r
2111 public <T> T syncRequest(final AsyncRead<T> request)
\r
2112 throws DatabaseException {
\r
2114 assert (request != null);
\r
2115 AsyncReadProcedure<T> procedure = new AsyncReadProcedure<T>();
\r
2116 syncRequest(request, procedure);
\r
2117 procedure.checkAndThrow();
\r
2118 return procedure.result;
\r
2120 // return syncRequest(request, new AsyncProcedureAdapter<T>());
\r
2125 public <T> T syncRequest(AsyncRead<T> request, AsyncListener<T> procedure)
\r
2126 throws DatabaseException {
\r
2127 return syncRequest(request, (AsyncProcedure<T>) procedure);
\r
2131 public <T> T syncRequest(AsyncRead<T> request, SyncListener<T> procedure)
\r
2132 throws DatabaseException {
\r
2133 return syncRequest(request, new SyncToAsyncListener<T>(procedure));
\r
2137 public <T> T syncRequest(AsyncRead<T> request, Listener<T> procedure)
\r
2138 throws DatabaseException {
\r
2139 return syncRequest(request, new NoneToAsyncListener<T>(procedure));
\r
2143 final public <T> T syncRequest(final AsyncRead<T> request,
\r
2144 final AsyncProcedure<T> procedure) throws DatabaseException {
\r
2146 assert (request != null);
\r
2148 // System.out.println("syncRequest " + request + " syncParent=" +
\r
2151 ListenerBase listener = getListenerBase(procedure);
\r
2153 if (parent != null || listener != null || ((request.getFlags() & RequestFlags.SCHEDULE) > 0)) {
\r
2155 Object syncParent = request;
\r
2157 // final ReadGraphImpl newGraph = newSync();
\r
2159 final ResultCallWrappedSingleQueryProcedure4<T> wrapper = new ResultCallWrappedSingleQueryProcedure4<T>(
\r
2160 procedure, request);
\r
2162 processor.query(this, request, parent, wrapper, listener);
\r
2164 // newGraph.waitAsync(syncParent);
\r
2166 Throwable e = wrapper.getException();
\r
2168 // The request was async - produce meaningful stack trace by
\r
2170 if (e instanceof DatabaseException)
\r
2171 throw (DatabaseException) e;
\r
2173 throw new DatabaseException(e);
\r
2176 return wrapper.getResult();
\r
2180 // System.out.println("direct call " + request );
\r
2182 // Do not set the sync state.parent for external threads
\r
2183 Object syncParent = request;
\r
2185 // final ReadGraphImpl newGraph = newSync();
\r
2187 final ResultCallWrappedSingleQueryProcedure4<T> wrapper = new ResultCallWrappedSingleQueryProcedure4<T>(
\r
2188 procedure, request);
\r
2192 processor.tryQuery(this, request, wrapper);
\r
2194 } catch (Throwable t) {
\r
2196 wrapper.exception(this, t);
\r
2200 Throwable e = wrapper.getException();
\r
2202 // The request was async - produce meaningful stack trace by
\r
2204 if (e instanceof DatabaseException)
\r
2205 throw (DatabaseException) e;
\r
2207 throw new DatabaseException(e);
\r
2210 return wrapper.getResult();
\r
2216 final private <T> void syncRequest(final AsyncRead<T> request, final AsyncReadProcedure<T> procedure) throws DatabaseException {
\r
2218 assert (request != null);
\r
2220 // System.out.println("syncRequest " + request + " syncParent=" +
\r
2223 ListenerBase listener = getListenerBase(procedure);
\r
2225 if (parent != null || listener != null || ((request.getFlags() & RequestFlags.SCHEDULE) > 0)) {
\r
2227 // final ReadGraphImpl newGraph = newSync();
\r
2229 final ResultCallWrappedSingleQueryProcedure4<T> wrapper = new ResultCallWrappedSingleQueryProcedure4<T>(
\r
2230 procedure, request);
\r
2232 processor.query(this, request, parent, wrapper, listener);
\r
2238 // final ReadGraphImpl newGraph = newSync();
\r
2239 processor.tryQuery(this, request, procedure);
\r
2240 // newGraph.waitAsync(null);
\r
2241 waitAsyncProcedure(procedure);
\r
2243 } catch (Throwable t) {
\r
2244 if(Development.DEVELOPMENT) {
\r
2245 if(Development.<Boolean>getProperty(DevelopmentKeys.WRITEGRAPH_EXCEPTION_STACKTRACES, Bindings.BOOLEAN)) {
\r
2246 t.printStackTrace();
\r
2249 procedure.exception(this, t);
\r
2250 waitAsyncProcedure(procedure);
\r
2258 public <T> T syncRequest(AsyncRead<T> request,
\r
2259 final SyncProcedure<T> procedure) throws DatabaseException {
\r
2260 return syncRequest(request, new SyncToAsyncProcedure<T>(procedure));
\r
2264 final public <T> T syncRequest(final AsyncRead<T> request,
\r
2265 final Procedure<T> procedure) throws DatabaseException {
\r
2266 return syncRequest(request, new NoneToAsyncProcedure<T>(procedure));
\r
2270 public <T> Collection<T> syncRequest(final MultiRead<T> request)
\r
2271 throws DatabaseException {
\r
2273 assert (request != null);
\r
2275 final ArrayList<T> result = new ArrayList<T>();
\r
2276 final DataContainer<Throwable> exception = new DataContainer<Throwable>();
\r
2278 syncRequest(request, new AsyncMultiProcedure<T>() {
\r
2281 public void execute(AsyncReadGraph graph, T t) {
\r
2282 synchronized (result) {
\r
2288 public void finished(AsyncReadGraph graph) {
\r
2292 public void exception(AsyncReadGraph graph, Throwable t) {
\r
2297 public String toString() {
\r
2298 return "syncRequest(MultiRead) -> " + request;
\r
2303 Throwable t = exception.get();
\r
2305 if (t instanceof DatabaseException)
\r
2306 throw (DatabaseException) t;
\r
2308 throw new DatabaseException(
\r
2309 "Unexpected exception in ReadGraph.syncRequest(Read)",
\r
2318 public <T> Collection<T> syncRequest(MultiRead<T> request,
\r
2319 AsyncMultiListener<T> procedure) {
\r
2320 return syncRequest(request, (AsyncMultiProcedure<T>) procedure);
\r
2324 public <T> Collection<T> syncRequest(MultiRead<T> request,
\r
2325 SyncMultiListener<T> procedure) {
\r
2326 return syncRequest(request, new SyncToAsyncMultiListener<T>(procedure));
\r
2330 public <T> Collection<T> syncRequest(MultiRead<T> request,
\r
2331 MultiListener<T> procedure) {
\r
2332 return syncRequest(request, new NoneToAsyncMultiListener<T>(procedure));
\r
2336 public <T> Collection<T> syncRequest(MultiRead<T> request,
\r
2337 AsyncMultiProcedure<T> procedure) {
\r
2339 assert (request != null);
\r
2341 ListenerBase listener = getListenerBase(procedure);
\r
2343 if (parent != null || listener != null) {
\r
2345 Object syncParent = request;
\r
2347 // final ReadGraphImpl newGraph = newSync();
\r
2349 processor.query(this, request, parent, procedure, listener);
\r
2351 // newGraph.waitAsync(syncParent);
\r
2355 Object syncParent = request;
\r
2357 // final ReadGraphImpl newGraph = newSync();
\r
2359 final ResultCallWrappedQueryProcedure4<T> wrapper = new ResultCallWrappedQueryProcedure4<T>(procedure);
\r
2363 request.perform(this, wrapper);
\r
2365 } catch (Throwable t) {
\r
2367 wrapper.exception(this, t);
\r
2368 // newGraph.waitAsync(syncParent);
\r
2380 public <T> Collection<T> syncRequest(MultiRead<T> request,
\r
2381 SyncMultiProcedure<T> procedure) {
\r
2382 return syncRequest(request, new SyncToAsyncMultiProcedure<T>(procedure));
\r
2386 public <T> Collection<T> syncRequest(MultiRead<T> request,
\r
2387 MultiProcedure<T> procedure) {
\r
2388 return syncRequest(request, new NoneToAsyncMultiProcedure<T>(procedure));
\r
2391 static class AsyncMultiReadProcedure<T> extends ArrayList<T> implements AsyncMultiProcedure<T> {
\r
2393 private static Throwable DONE = new Throwable();
\r
2395 private static final long serialVersionUID = -6494230465108115812L;
\r
2397 Throwable exception = null;
\r
2400 public synchronized void execute(AsyncReadGraph graph, T t) {
\r
2405 public void finished(AsyncReadGraph graph) {
\r
2410 public void exception(AsyncReadGraph graph, Throwable t) {
\r
2414 public void checkAndThrow() throws DatabaseException {
\r
2415 if(exception != DONE) {
\r
2416 if (exception instanceof DatabaseException)
\r
2417 throw (DatabaseException) exception;
\r
2419 throw new DatabaseException(
\r
2420 "Unexpected exception in ReadGraph.syncRequest(AsyncMultiRead)",
\r
2425 public boolean done() {
\r
2426 return exception != null;
\r
2432 final public <T> Collection<T> syncRequest(AsyncMultiRead<T> request)
\r
2433 throws DatabaseException {
\r
2435 assert (request != null);
\r
2437 final AsyncMultiReadProcedure<T> procedure = new AsyncMultiReadProcedure<T>();
\r
2439 syncRequest(request, procedure);
\r
2441 procedure.checkAndThrow();
\r
2447 public <T> Collection<T> syncRequest(AsyncMultiRead<T> request,
\r
2448 AsyncMultiListener<T> procedure) {
\r
2449 return syncRequest(request, (AsyncMultiProcedure<T>) procedure);
\r
2453 public <T> Collection<T> syncRequest(AsyncMultiRead<T> request,
\r
2454 SyncMultiListener<T> procedure) {
\r
2455 return syncRequest(request, new SyncToAsyncMultiListener<T>(procedure));
\r
2459 public <T> Collection<T> syncRequest(AsyncMultiRead<T> request,
\r
2460 MultiListener<T> procedure) {
\r
2461 return syncRequest(request, new NoneToAsyncMultiListener<T>(procedure));
\r
2464 final private <T> void syncRequest(final AsyncMultiRead<T> request,
\r
2465 final AsyncMultiReadProcedure<T> procedure) {
\r
2467 assert (request != null);
\r
2468 assert (procedure != null);
\r
2470 ListenerBase listener = getListenerBase(procedure);
\r
2472 if (parent != null || listener != null) {
\r
2474 Object syncParent = request;
\r
2476 // final ReadGraphImpl newGraph = newSync();
\r
2478 processor.query(this, request, parent, procedure, listener);
\r
2480 // newGraph.waitAsync(syncParent);
\r
2481 waitAsyncProcedure(procedure);
\r
2485 // Object syncParent = callerThread == Integer.MIN_VALUE ? null
\r
2488 // final ReadGraphImpl newGraph = newSyncAsync(syncParent);
\r
2493 // ReadGraphImpl sync = newSync();
\r
2494 request.perform(this, procedure);
\r
2495 // sync.waitAsync(null);
\r
2496 waitAsyncProcedure(procedure);
\r
2499 } catch (Throwable t) {
\r
2501 waitAsyncProcedure(procedure);
\r
2512 final public <T> Collection<T> syncRequest(final AsyncMultiRead<T> request,
\r
2513 final AsyncMultiProcedure<T> procedure) {
\r
2515 assert (request != null);
\r
2516 assert (procedure != null);
\r
2518 ListenerBase listener = getListenerBase(procedure);
\r
2520 if (parent != null || listener != null) {
\r
2522 Object syncParent = request;
\r
2524 // final ReadGraphImpl newGraph = newSync();
\r
2526 processor.query(this, request, parent, procedure, listener);
\r
2528 // newGraph.waitAsync(syncParent);
\r
2532 Object syncParent = request;
\r
2534 // final ReadGraphImpl newGraph = newSync();
\r
2538 request.perform(this, new AsyncMultiProcedure<T>() {
\r
2541 public void execute(AsyncReadGraph graph, T result) {
\r
2542 procedure.execute(graph, result);
\r
2546 public void finished(AsyncReadGraph graph) {
\r
2547 procedure.finished(graph);
\r
2551 public void exception(AsyncReadGraph graph, Throwable t) {
\r
2552 procedure.exception(graph, t);
\r
2556 public String toString() {
\r
2557 return "syncRequest(AsyncMultiRead) -> " + procedure;
\r
2562 } catch (Throwable t) {
\r
2574 public <T> Collection<T> syncRequest(AsyncMultiRead<T> request,
\r
2575 final SyncMultiProcedure<T> procedure) {
\r
2576 return syncRequest(request, new SyncToAsyncMultiProcedure<T>(procedure));
\r
2580 final public <T> Collection<T> syncRequest(final AsyncMultiRead<T> request,
\r
2581 final MultiProcedure<T> procedure) {
\r
2582 return syncRequest(request, new NoneToAsyncMultiProcedure<T>(procedure));
\r
2586 public <T> T syncRequest(final ExternalRead<T> request)
\r
2587 throws DatabaseException {
\r
2589 assert (request != null);
\r
2591 return syncRequest(request, new Procedure<T>() {
\r
2594 public void execute(T t) {
\r
2598 public void exception(Throwable t) {
\r
2602 public String toString() {
\r
2603 return "syncRequest(AsyncRead) -> " + request;
\r
2611 public <T> T syncRequest(ExternalRead<T> request, Listener<T> procedure) throws DatabaseException {
\r
2612 return syncRequest(request, (Procedure<T>) procedure);
\r
2616 final public <T> T syncRequest(final ExternalRead<T> request,
\r
2617 final Procedure<T> procedure) throws DatabaseException {
\r
2619 assert (request != null);
\r
2621 ListenerBase listener = getListenerBase(procedure);
\r
2623 final DataContainer<Throwable> exception = new DataContainer<Throwable>();
\r
2624 final DataContainer<T> result = new DataContainer<T>();
\r
2626 if (parent != null || listener != null) {
\r
2628 // final ReadGraphImpl newGraph = newSync();
\r
2630 processor.query(this, request, parent, new Procedure<T>() {
\r
2633 public void exception(Throwable throwable) {
\r
2634 exception.set(throwable);
\r
2635 procedure.exception(throwable);
\r
2639 public void execute(T t) {
\r
2641 procedure.execute(t);
\r
2646 // newGraph.waitAsync(request);
\r
2652 T t = processor.tryQuery(this, request);
\r
2654 procedure.execute(t);
\r
2656 } catch (Throwable t) {
\r
2658 if (t instanceof DatabaseException) {
\r
2659 exception.set((DatabaseException)t);
\r
2660 procedure.exception(exception.get());
\r
2662 exception.set(new DatabaseException(
\r
2663 "Unexpected exception in ReadGraph.syncRequest(Read)",
\r
2665 procedure.exception(exception.get());
\r
2672 Throwable t = exception.get();
\r
2674 if (t instanceof DatabaseException)
\r
2675 throw (DatabaseException) t;
\r
2677 throw new DatabaseException(
\r
2678 "Unexpected exception in ReadGraph.syncRequest(Read)",
\r
2682 return result.get();
\r
2687 public void syncRequest(final Write request) throws DatabaseException {
\r
2689 assert (request != null);
\r
2691 throw new DatabaseException(
\r
2692 "Write operations are not supported during read transactions!");
\r
2697 public <T> T syncRequest(final WriteResult<T> request) throws DatabaseException {
\r
2699 assert (request != null);
\r
2701 throw new DatabaseException(
\r
2702 "Write operations are not supported during read transactions!");
\r
2707 public void syncRequest(final DelayedWrite request)
\r
2708 throws DatabaseException {
\r
2710 assert (request != null);
\r
2712 throw new DatabaseException(
\r
2713 "Write operations are not supported during read transactions!");
\r
2718 public <T> T syncRequest(final DelayedWriteResult<T> request) throws DatabaseException {
\r
2720 assert (request != null);
\r
2722 throw new DatabaseException(
\r
2723 "Write operations are not supported during read transactions!");
\r
2728 public void syncRequest(final WriteOnly request) throws DatabaseException {
\r
2730 assert (request != null);
\r
2732 throw new DatabaseException(
\r
2733 "Write operations are not supported during read transactions!");
\r
2738 public <T> T syncRequest(final WriteOnlyResult<T> request) throws DatabaseException {
\r
2740 assert (request != null);
\r
2742 throw new DatabaseException(
\r
2743 "Write operations are not supported during read transactions!");
\r
2748 public <T> void async(ReadInterface<T> r, AsyncProcedure<T> procedure) {
\r
2749 r.request(this, procedure);
\r
2753 public <T> void async(ReadInterface<T> r, Procedure<T> procedure) {
\r
2754 r.request(this, procedure);
\r
2758 public <T> void async(ReadInterface<T> r, SyncProcedure<T> procedure) {
\r
2759 r.request(this, procedure);
\r
2763 public <T> void async(ReadInterface<T> r, AsyncListener<T> procedure) {
\r
2764 r.request(this, procedure);
\r
2768 public <T> void async(ReadInterface<T> r, Listener<T> procedure) {
\r
2769 r.request(this, procedure);
\r
2773 public <T> void async(ReadInterface<T> r, SyncListener<T> procedure) {
\r
2774 r.request(this, procedure);
\r
2778 public <T> T sync(ReadInterface<T> r) throws DatabaseException {
\r
2779 return r.request(this);
\r
2783 public <T> T sync(WriteInterface<T> r) throws DatabaseException {
\r
2784 return r.request(this);
\r
2788 public <T> void async(WriteInterface<T> r, Procedure<T> procedure) {
\r
2789 r.request(this, procedure);
\r
2793 public <T> void async(WriteInterface<T> r) {
\r
2794 r.request(this, new ProcedureAdapter<T>());
\r
2798 * Implementation of the interface AsyncReadGraph
\r
2802 public void forURI(Resource resource, AsyncListener<String> listener) {
\r
2803 asyncRequest(new org.simantics.db.common.uri.ResourceToURI(resource),
\r
2808 public void forURI(Resource resource, SyncListener<String> listener) {
\r
2809 asyncRequest(new org.simantics.db.common.uri.ResourceToURI(resource),
\r
2814 public void forURI(Resource resource, Listener<String> listener) {
\r
2815 asyncRequest(new org.simantics.db.common.uri.ResourceToURI(resource),
\r
2820 final public void forURI(final Resource resource,
\r
2821 final AsyncProcedure<String> procedure) {
\r
2823 assert (resource != null);
\r
2824 assert (procedure != null);
\r
2826 asyncRequest(new org.simantics.db.common.uri.ResourceToURI(resource),
\r
2832 public void forURI(Resource resource, SyncProcedure<String> procedure) {
\r
2833 forURI(resource, new SyncToAsyncProcedure<String>(procedure));
\r
2837 public void forURI(Resource resource, Procedure<String> procedure) {
\r
2838 forURI(resource, new NoneToAsyncProcedure<String>(procedure));
\r
2842 public void forResource(String id, AsyncListener<Resource> listener) {
\r
2843 asyncRequest(new org.simantics.db.common.primitiverequest.Resource(id),
\r
2848 public void forResource(String id, SyncListener<Resource> listener) {
\r
2849 asyncRequest(new org.simantics.db.common.primitiverequest.Resource(id),
\r
2854 public void forResource(String id, Listener<Resource> listener) {
\r
2855 asyncRequest(new org.simantics.db.common.primitiverequest.Resource(id),
\r
2860 final public void forResource(final String id,
\r
2861 final AsyncProcedure<Resource> procedure) {
\r
2863 assert (id != null);
\r
2864 assert (procedure != null);
\r
2866 processor.forResource(this, id, procedure);
\r
2871 public void forResource(String id, SyncProcedure<Resource> procedure) {
\r
2872 forResource(id, new SyncToAsyncProcedure<Resource>(procedure));
\r
2876 public void forResource(String id, Procedure<Resource> procedure) {
\r
2877 forResource(id, new NoneToAsyncProcedure<Resource>(procedure));
\r
2881 public void forBuiltin(String id, AsyncListener<Resource> listener) {
\r
2882 asyncRequest(new Builtin(id), listener);
\r
2886 public void forBuiltin(String id, SyncListener<Resource> listener) {
\r
2887 asyncRequest(new Builtin(id), listener);
\r
2891 public void forBuiltin(String id, Listener<Resource> listener) {
\r
2892 asyncRequest(new Builtin(id), listener);
\r
2896 final public void forBuiltin(final String id,
\r
2897 final AsyncProcedure<Resource> procedure) {
\r
2899 assert (id != null);
\r
2900 assert (procedure != null);
\r
2902 processor.forBuiltin(this, id, procedure);
\r
2907 public void forBuiltin(String id, SyncProcedure<Resource> procedure) {
\r
2908 forBuiltin(id, new SyncToAsyncProcedure<Resource>(procedure));
\r
2912 public void forBuiltin(String id, Procedure<Resource> procedure) {
\r
2913 forBuiltin(id, new NoneToAsyncProcedure<Resource>(procedure));
\r
2917 final public void forEachStatement(Resource subject, Resource relation,
\r
2918 AsyncMultiProcedure<Statement> procedure) {
\r
2920 assert (subject != null);
\r
2921 assert (relation != null);
\r
2922 assert (procedure != null);
\r
2924 processor.forEachStatement(this, subject, relation, procedure);
\r
2929 public void forEachStatement(Resource subject, Resource relation,
\r
2930 SyncMultiProcedure<Statement> procedure) {
\r
2931 forEachStatement(subject, relation,
\r
2932 new SyncToAsyncMultiProcedure<Statement>(procedure));
\r
2936 final public void forEachStatement(Resource subject, Resource relation,
\r
2937 MultiProcedure<Statement> procedure) {
\r
2939 assert (subject != null);
\r
2940 assert (relation != null);
\r
2941 assert (procedure != null);
\r
2943 processor.forEachStatement(this, subject, relation, procedure);
\r
2948 final public void forStatementSet(Resource subject, Resource relation,
\r
2949 AsyncSetListener<Statement> procedure) {
\r
2951 assert (subject != null);
\r
2952 assert (relation != null);
\r
2953 assert (procedure != null);
\r
2955 processor.forStatementSet(this, subject, relation, procedure);
\r
2960 final public void forStatementSet(Resource subject, Resource relation,
\r
2961 SyncSetListener<Statement> procedure) {
\r
2962 forStatementSet(subject, relation,
\r
2963 new SyncToAsyncSetProcedure<Statement>(procedure));
\r
2967 public void forStatementSet(Resource subject, Resource relation,
\r
2968 SetListener<Statement> listener) {
\r
2969 forStatementSet(subject, relation,
\r
2970 new NoneToAsyncSetProcedure<Statement>(listener));
\r
2974 final public void forEachAssertedStatement(final Resource subject,
\r
2975 final Resource relation,
\r
2976 final AsyncMultiProcedure<Statement> procedure) {
\r
2978 assert (subject != null);
\r
2979 assert (relation != null);
\r
2980 assert (procedure != null);
\r
2982 processor.forEachAssertedStatement(this, subject, relation, procedure);
\r
2987 public void forEachAssertedStatement(Resource subject, Resource relation,
\r
2988 SyncMultiProcedure<Statement> procedure) {
\r
2989 forEachAssertedStatement(subject, relation,
\r
2990 new SyncToAsyncMultiProcedure<Statement>(procedure));
\r
2994 public void forEachAssertedStatement(Resource subject, Resource relation,
\r
2995 MultiProcedure<Statement> procedure) {
\r
2996 forEachAssertedStatement(subject, relation,
\r
2997 new NoneToAsyncMultiProcedure<Statement>(procedure));
\r
3001 public void forAssertedStatementSet(Resource subject, Resource relation,
\r
3002 AsyncSetListener<Statement> procedure) {
\r
3004 assert (subject != null);
\r
3005 assert (relation != null);
\r
3006 assert (procedure != null);
\r
3008 processor.forAssertedStatementSet(this, subject, relation, procedure);
\r
3013 public void forAssertedStatementSet(Resource subject, Resource relation,
\r
3014 SyncSetListener<Statement> procedure) {
\r
3016 assert (subject != null);
\r
3017 assert (relation != null);
\r
3018 assert (procedure != null);
\r
3020 forAssertedStatementSet(subject, relation,
\r
3021 new SyncToAsyncSetProcedure<Statement>(procedure));
\r
3026 public void forAssertedStatementSet(Resource subject, Resource relation,
\r
3027 SetListener<Statement> procedure) {
\r
3029 assert (subject != null);
\r
3030 assert (relation != null);
\r
3031 assert (procedure != null);
\r
3033 forAssertedStatementSet(subject, relation,
\r
3034 new NoneToAsyncSetProcedure<Statement>(procedure));
\r
3039 final public void forEachPredicate(final Resource subject,
\r
3040 final AsyncMultiProcedure<Resource> procedure) {
\r
3042 assert (subject != null);
\r
3043 assert (procedure != null);
\r
3045 processor.forEachPredicate(this, subject, procedure);
\r
3050 public void forEachPredicate(Resource subject,
\r
3051 SyncMultiProcedure<Resource> procedure) {
\r
3052 forEachPredicate(subject, new SyncToAsyncMultiProcedure<Resource>(
\r
3057 final public void forEachPredicate(final Resource subject,
\r
3058 final MultiProcedure<Resource> procedure) {
\r
3060 assert (subject != null);
\r
3061 assert (procedure != null);
\r
3063 processor.forEachPredicate(this, subject, procedure);
\r
3068 final public void forPredicateSet(final Resource subject,
\r
3069 final AsyncSetListener<Resource> procedure) {
\r
3071 assert (subject != null);
\r
3072 assert (procedure != null);
\r
3074 processor.forPredicateSet(this, subject, procedure);
\r
3079 final public void forPredicateSet(final Resource subject,
\r
3080 final SyncSetListener<Resource> procedure) {
\r
3082 assert (subject != null);
\r
3083 assert (procedure != null);
\r
3085 forPredicateSet(subject, new SyncToAsyncSetProcedure<Resource>(
\r
3091 final public void forPredicateSet(final Resource subject,
\r
3092 final SetListener<Resource> procedure) {
\r
3094 assert (subject != null);
\r
3095 assert (procedure != null);
\r
3097 forPredicateSet(subject, new NoneToAsyncSetProcedure<Resource>(
\r
3103 final public void forEachPrincipalType(final Resource subject,
\r
3104 final AsyncMultiProcedure<Resource> procedure) {
\r
3106 assert (subject != null);
\r
3107 assert (procedure != null);
\r
3109 processor.forEachPrincipalType(this, subject, procedure);
\r
3114 public void forEachPrincipalType(Resource subject,
\r
3115 SyncMultiProcedure<Resource> procedure) {
\r
3116 forEachPrincipalType(subject, new SyncToAsyncMultiProcedure<Resource>(
\r
3121 final public void forEachPrincipalType(final Resource subject,
\r
3122 final MultiProcedure<Resource> procedure) {
\r
3124 assert (subject != null);
\r
3125 assert (procedure != null);
\r
3127 processor.forEachPrincipalType(this, subject, procedure);
\r
3132 final public void forPrincipalTypeSet(final Resource subject,
\r
3133 final AsyncSetListener<Resource> procedure) {
\r
3135 assert (subject != null);
\r
3136 assert (procedure != null);
\r
3138 processor.forPrincipalTypeSet(this, subject, procedure);
\r
3143 final public void forPrincipalTypeSet(final Resource subject,
\r
3144 final SyncSetListener<Resource> procedure) {
\r
3146 assert (subject != null);
\r
3147 assert (procedure != null);
\r
3149 forPrincipalTypeSet(subject, new SyncToAsyncSetProcedure<Resource>(
\r
3155 final public void forPrincipalTypeSet(final Resource subject,
\r
3156 final SetListener<Resource> procedure) {
\r
3158 assert (subject != null);
\r
3159 assert (procedure != null);
\r
3161 forPrincipalTypeSet(subject, new NoneToAsyncSetProcedure<Resource>(
\r
3167 public void forTypes(Resource subject, AsyncListener<Set<Resource>> listener) {
\r
3168 asyncRequest(new Types(subject), listener);
\r
3172 public void forTypes(Resource subject, SyncListener<Set<Resource>> listener) {
\r
3173 asyncRequest(new Types(subject), listener);
\r
3177 public void forTypes(Resource subject, Listener<Set<Resource>> listener) {
\r
3178 asyncRequest(new Types(subject), listener);
\r
3182 final public void forTypes(final Resource subject,
\r
3183 final AsyncProcedure<Set<Resource>> procedure) {
\r
3185 assert (subject != null);
\r
3186 assert (procedure != null);
\r
3188 processor.forTypes(this, subject, procedure);
\r
3193 public void forTypes(Resource subject,
\r
3194 SyncProcedure<Set<Resource>> procedure) {
\r
3195 forTypes(subject, new SyncToAsyncProcedure<Set<Resource>>(procedure));
\r
3199 public void forTypes(Resource subject, Procedure<Set<Resource>> procedure) {
\r
3200 forTypes(subject, new NoneToAsyncProcedure<Set<Resource>>(procedure));
\r
3204 public void forSupertypes(Resource subject,
\r
3205 AsyncListener<Set<Resource>> listener) {
\r
3206 asyncRequest(new Types(subject), listener);
\r
3210 public void forSupertypes(Resource subject,
\r
3211 SyncListener<Set<Resource>> listener) {
\r
3212 asyncRequest(new Types(subject), listener);
\r
3216 public void forSupertypes(Resource subject, Listener<Set<Resource>> listener) {
\r
3217 asyncRequest(new Types(subject), listener);
\r
3221 final public void forSupertypes(final Resource subject,
\r
3222 final AsyncProcedure<Set<Resource>> procedure) {
\r
3224 assert (subject != null);
\r
3225 assert (procedure != null);
\r
3227 processor.forSupertypes(this, subject, procedure);
\r
3232 public void forSupertypes(Resource subject,
\r
3233 SyncProcedure<Set<Resource>> procedure) {
\r
3234 forSupertypes(subject, new SyncToAsyncProcedure<Set<Resource>>(
\r
3239 public void forSupertypes(Resource subject,
\r
3240 Procedure<Set<Resource>> procedure) {
\r
3241 forSupertypes(subject, new NoneToAsyncProcedure<Set<Resource>>(
\r
3246 public void forDirectSuperrelations(Resource subject,
\r
3247 AsyncMultiProcedure<Resource> procedure) {
\r
3249 assert (subject != null);
\r
3250 assert (procedure != null);
\r
3252 processor.forDirectSuperrelations(this, subject, procedure);
\r
3257 public void forPossibleSuperrelation(Resource subject, AsyncProcedure<Resource> procedure) {
\r
3259 assert (subject != null);
\r
3260 assert (procedure != null);
\r
3262 processor.forPossibleSuperrelation(this, subject, procedure);
\r
3267 public void forSuperrelations(Resource subject,
\r
3268 AsyncListener<Set<Resource>> listener) {
\r
3269 asyncRequest(new Types(subject), listener);
\r
3273 public void forSuperrelations(Resource subject,
\r
3274 SyncListener<Set<Resource>> listener) {
\r
3275 asyncRequest(new Types(subject), listener);
\r
3279 public void forSuperrelations(Resource subject,
\r
3280 Listener<Set<Resource>> listener) {
\r
3281 asyncRequest(new Types(subject), listener);
\r
3285 final public void forSuperrelations(final Resource subject,
\r
3286 final AsyncProcedure<Set<Resource>> procedure) {
\r
3288 assert (subject != null);
\r
3289 assert (procedure != null);
\r
3291 processor.forSuperrelations(this, subject, procedure);
\r
3296 public void forSuperrelations(Resource subject,
\r
3297 SyncProcedure<Set<Resource>> procedure) {
\r
3298 forSuperrelations(subject, new SyncToAsyncProcedure<Set<Resource>>(
\r
3303 public void forSuperrelations(Resource subject,
\r
3304 Procedure<Set<Resource>> procedure) {
\r
3305 forSuperrelations(subject, new NoneToAsyncProcedure<Set<Resource>>(
\r
3310 final public void forEachObject(final Resource subject, final Resource relation, final AsyncMultiProcedure<Resource> procedure) {
\r
3311 processor.forEachObject(this, subject, relation, procedure);
\r
3315 public void forEachObject(Resource subject, Resource relation,
\r
3316 SyncMultiProcedure<Resource> procedure) {
\r
3317 forEachObject(subject, relation,
\r
3318 new SyncToAsyncMultiProcedure<Resource>(procedure));
\r
3322 public void forEachObject(Resource subject, Resource relation,
\r
3323 MultiProcedure<Resource> procedure) {
\r
3325 processor.forEachObject(this, subject, relation, procedure);
\r
3330 // final public void forEachDirectObject(final Resource subject,
\r
3331 // final Resource relation,
\r
3332 // final AsyncMultiProcedure<Resource> procedure) {
\r
3334 // processor.forEachDirectObject(this, subject, relation, procedure);
\r
3339 // public void forEachDirectObject(Resource subject, Resource relation,
\r
3340 // SyncMultiProcedure<Resource> procedure) {
\r
3341 // forEachDirectObject(subject, relation,
\r
3342 // new SyncToAsyncMultiProcedure<Resource>(procedure));
\r
3346 // public void forEachDirectObject(Resource subject, Resource relation,
\r
3347 // MultiProcedure<Resource> procedure) {
\r
3348 // forEachDirectObject(subject, relation,
\r
3349 // new NoneToAsyncMultiProcedure<Resource>(procedure));
\r
3353 final public void forEachDirectPredicate(final Resource subject, final AsyncMultiProcedure<Resource> procedure) {
\r
3354 processor.forEachDirectPredicate(this, subject, procedure);
\r
3358 public void forEachDirectPredicate(Resource subject, SyncMultiProcedure<Resource> procedure) {
\r
3359 forEachDirectPredicate(subject, new SyncToAsyncMultiProcedure<Resource>(procedure));
\r
3363 public void forEachDirectPredicate(Resource subject, MultiProcedure<Resource> procedure) {
\r
3364 forEachDirectPredicate(subject, new NoneToAsyncMultiProcedure<Resource>(procedure));
\r
3368 final public void forObjectSet(final Resource subject,
\r
3369 final Resource relation, final AsyncSetListener<Resource> procedure) {
\r
3371 assert (subject != null);
\r
3372 assert (relation != null);
\r
3373 assert (procedure != null);
\r
3375 processor.forObjectSet(this, subject, relation, procedure);
\r
3380 final public void forObjectSet(final Resource subject,
\r
3381 final Resource relation, final SyncSetListener<Resource> procedure) {
\r
3383 assert (subject != null);
\r
3384 assert (relation != null);
\r
3385 assert (procedure != null);
\r
3387 forObjectSet(subject, relation, new SyncToAsyncSetProcedure<Resource>(
\r
3393 final public void forObjectSet(final Resource subject,
\r
3394 final Resource relation, final SetListener<Resource> procedure) {
\r
3396 assert (subject != null);
\r
3397 assert (relation != null);
\r
3398 assert (procedure != null);
\r
3400 forObjectSet(subject, relation, new NoneToAsyncSetProcedure<Resource>(
\r
3406 final public void forEachAssertedObject(final Resource subject,
\r
3407 final Resource relation,
\r
3408 final AsyncMultiProcedure<Resource> procedure) {
\r
3410 assert (subject != null);
\r
3411 assert (relation != null);
\r
3412 assert (procedure != null);
\r
3414 processor.forEachAssertedObject(this, subject, relation, procedure);
\r
3419 public void forEachAssertedObject(Resource subject, Resource relation,
\r
3420 SyncMultiProcedure<Resource> procedure) {
\r
3422 assert (subject != null);
\r
3423 assert (relation != null);
\r
3424 assert (procedure != null);
\r
3426 forEachAssertedObject(subject, relation,
\r
3427 new SyncToAsyncMultiProcedure<Resource>(procedure));
\r
3432 public void forEachAssertedObject(Resource subject, Resource relation,
\r
3433 MultiProcedure<Resource> procedure) {
\r
3435 assert (subject != null);
\r
3436 assert (relation != null);
\r
3437 assert (procedure != null);
\r
3439 forEachAssertedObject(subject, relation,
\r
3440 new NoneToAsyncMultiProcedure<Resource>(procedure));
\r
3445 public void forAssertedObjectSet(Resource subject, Resource relation,
\r
3446 AsyncSetListener<Resource> procedure) {
\r
3448 assert (subject != null);
\r
3449 assert (relation != null);
\r
3450 assert (procedure != null);
\r
3452 processor.forAssertedObjectSet(this, subject, relation, procedure);
\r
3457 public void forAssertedObjectSet(Resource subject, Resource relation,
\r
3458 SyncSetListener<Resource> procedure) {
\r
3460 assert (subject != null);
\r
3461 assert (relation != null);
\r
3462 assert (procedure != null);
\r
3464 forAssertedObjectSet(subject, relation,
\r
3465 new SyncToAsyncSetProcedure<Resource>(procedure));
\r
3470 public void forAssertedObjectSet(Resource subject, Resource relation,
\r
3471 SetListener<Resource> procedure) {
\r
3473 assert (subject != null);
\r
3474 assert (relation != null);
\r
3475 assert (procedure != null);
\r
3477 forAssertedObjectSet(subject, relation,
\r
3478 new NoneToAsyncSetProcedure<Resource>(procedure));
\r
3483 public void forInverse(Resource relation, AsyncListener<Resource> listener) {
\r
3484 asyncRequest(new Inverse(relation), listener);
\r
3488 public void forInverse(Resource relation, SyncListener<Resource> listener) {
\r
3489 asyncRequest(new Inverse(relation), listener);
\r
3493 public void forInverse(Resource relation, Listener<Resource> listener) {
\r
3494 asyncRequest(new Inverse(relation), listener);
\r
3498 final public void forInverse(final Resource relation,
\r
3499 final AsyncProcedure<Resource> procedure) {
\r
3501 assert (relation != null);
\r
3502 assert (procedure != null);
\r
3504 processor.forInverse(this, relation, new AsyncProcedure<Resource>() {
\r
3507 public void execute(AsyncReadGraph graph, Resource result) {
\r
3508 if (result != null)
\r
3509 procedure.execute(graph, result);
\r
3511 procedure.exception(graph, new NoInverseException(relation
\r
3517 public void exception(AsyncReadGraph graph, Throwable throwable) {
\r
3518 procedure.exception(graph, throwable);
\r
3522 public String toString() {
\r
3523 return "forInverse -> " + procedure;
\r
3531 public void forInverse(Resource relation, SyncProcedure<Resource> procedure) {
\r
3532 forInverse(relation, new SyncToAsyncProcedure<Resource>(procedure));
\r
3536 public void forInverse(Resource relation, Procedure<Resource> procedure) {
\r
3537 forInverse(relation, new NoneToAsyncProcedure<Resource>(procedure));
\r
3541 public void forSingleObject(Resource subject, Resource relation,
\r
3542 AsyncListener<Resource> listener) {
\r
3543 asyncRequest(new SingleObject(subject, relation), listener);
\r
3547 public void forSingleObject(Resource subject, Resource relation,
\r
3548 SyncListener<Resource> listener) {
\r
3549 asyncRequest(new SingleObject(subject, relation), listener);
\r
3553 public void forSingleObject(Resource subject, Resource relation,
\r
3554 Listener<Resource> listener) {
\r
3555 asyncRequest(new SingleObject(subject, relation), listener);
\r
3559 final public void forSingleObject(final Resource subject,
\r
3560 final Resource relation, final AsyncProcedure<Resource> procedure) {
\r
3562 assert (subject != null);
\r
3563 assert (relation != null);
\r
3564 assert (procedure != null);
\r
3566 processor.forEachObject(this, subject, relation,
\r
3567 new SingleOrErrorProcedure<Resource>(procedure));
\r
3572 public void forSingleObject(Resource subject, Resource relation,
\r
3573 SyncProcedure<Resource> procedure) {
\r
3574 forSingleObject(subject, relation, new SyncToAsyncProcedure<Resource>(
\r
3579 public void forSingleObject(Resource subject, Resource relation,
\r
3580 Procedure<Resource> procedure) {
\r
3581 forSingleObject(subject, relation, new NoneToAsyncProcedure<Resource>(
\r
3586 public void forSingleStatement(Resource subject, Resource relation,
\r
3587 AsyncListener<Statement> listener) {
\r
3588 asyncRequest(new SingleStatement(subject, relation), listener);
\r
3592 public void forSingleStatement(Resource subject, Resource relation,
\r
3593 SyncListener<Statement> listener) {
\r
3594 asyncRequest(new SingleStatement(subject, relation), listener);
\r
3598 public void forSingleStatement(Resource subject, Resource relation,
\r
3599 Listener<Statement> listener) {
\r
3600 asyncRequest(new SingleStatement(subject, relation), listener);
\r
3604 final public void forSingleStatement(final Resource subject,
\r
3605 final Resource relation, final AsyncProcedure<Statement> procedure) {
\r
3607 assert (subject != null);
\r
3608 assert (relation != null);
\r
3609 assert (procedure != null);
\r
3611 processor.forEachStatement(this, subject, relation,
\r
3612 new SingleOrErrorProcedure<Statement>(procedure));
\r
3617 public void forSingleStatement(Resource subject, Resource relation,
\r
3618 SyncProcedure<Statement> procedure) {
\r
3619 forSingleStatement(subject, relation,
\r
3620 new SyncToAsyncProcedure<Statement>(procedure));
\r
3624 public void forSingleStatement(Resource subject, Resource relation,
\r
3625 Procedure<Statement> procedure) {
\r
3626 forSingleStatement(subject, relation,
\r
3627 new NoneToAsyncProcedure<Statement>(procedure));
\r
3631 public void forSingleType(Resource subject,
\r
3632 AsyncListener<Resource> listener) {
\r
3633 asyncRequest(new SingleTypeAny(subject), listener);
\r
3637 public void forSingleType(Resource subject,
\r
3638 SyncListener<Resource> listener) {
\r
3639 asyncRequest(new SingleTypeAny(subject), listener);
\r
3643 public void forSingleType(Resource subject,
\r
3644 Listener<Resource> listener) {
\r
3645 asyncRequest(new SingleTypeAny(subject), listener);
\r
3649 final public void forSingleType(final Resource subject, final AsyncProcedure<Resource> procedure) {
\r
3651 assert (subject != null);
\r
3652 assert (procedure != null);
\r
3654 final DeepSingleOrErrorProcedure<Resource> checkedProcedure = new DeepSingleOrErrorProcedure<Resource>(procedure);
\r
3656 processor.forEachPrincipalType(this, subject, new AsyncMultiProcedureAdapter<Resource>() {
\r
3659 public void execute(AsyncReadGraph graph, final Resource principalType) {
\r
3660 checkedProcedure.offer(graph, principalType);
\r
3664 public void finished(AsyncReadGraph graph) {
\r
3665 checkedProcedure.dec(graph);
\r
3669 public void exception(AsyncReadGraph graph, Throwable t) {
\r
3670 checkedProcedure.exception(graph, t);
\r
3674 public String toString() {
\r
3675 return "forSingleType -> " + procedure;
\r
3683 public void forSingleType(Resource subject, SyncProcedure<Resource> procedure) {
\r
3684 forSingleType(subject, new SyncToAsyncProcedure<Resource>(
\r
3689 public void forSingleType(Resource subject, Procedure<Resource> procedure) {
\r
3690 forSingleType(subject, new NoneToAsyncProcedure<Resource>(
\r
3695 public void forSingleType(Resource subject, Resource relation,
\r
3696 AsyncListener<Resource> listener) {
\r
3697 asyncRequest(new SingleType(subject, relation), listener);
\r
3701 public void forSingleType(Resource subject, Resource relation,
\r
3702 SyncListener<Resource> listener) {
\r
3703 asyncRequest(new SingleType(subject, relation), listener);
\r
3707 public void forSingleType(Resource subject, Resource relation,
\r
3708 Listener<Resource> listener) {
\r
3709 asyncRequest(new SingleType(subject, relation), listener);
\r
3713 final public void forSingleType(final Resource subject,
\r
3714 final Resource baseType, final AsyncProcedure<Resource> procedure) {
\r
3716 assert (subject != null);
\r
3717 assert (procedure != null);
\r
3719 final DeepSingleOrErrorProcedure<Resource> checkedProcedure = new DeepSingleOrErrorProcedure<Resource>(procedure);
\r
3721 processor.forEachPrincipalType(this, subject,
\r
3722 new AsyncMultiProcedureAdapter<Resource>() {
\r
3725 public void execute(AsyncReadGraph graph,
\r
3726 final Resource principalType) {
\r
3728 checkedProcedure.inc();
\r
3730 if(baseType == null) {
\r
3732 checkedProcedure.offer(graph, principalType);
\r
3733 checkedProcedure.dec(graph);
\r
3735 } else if(principalType.equals(baseType)) {
\r
3737 checkedProcedure.offer(graph, principalType);
\r
3738 checkedProcedure.dec(graph);
\r
3742 processor.forSupertypes((ReadGraphImpl)graph, principalType,
\r
3743 new AsyncProcedure<Set<Resource>>() {
\r
3746 public void execute(
\r
3747 AsyncReadGraph graph,
\r
3748 Set<Resource> result) {
\r
3750 if (result.contains(baseType))
\r
3751 checkedProcedure.offer(graph,
\r
3753 checkedProcedure.dec(graph);
\r
3758 public void exception(
\r
3759 AsyncReadGraph graph,
\r
3762 .exception(graph, t);
\r
3772 public void finished(AsyncReadGraph graph) {
\r
3773 checkedProcedure.dec(graph);
\r
3777 public void exception(AsyncReadGraph graph, Throwable t) {
\r
3778 checkedProcedure.exception(graph, t);
\r
3782 public String toString() {
\r
3783 return "forSingleType -> " + procedure;
\r
3791 public void forSingleType(Resource subject, Resource relation,
\r
3792 SyncProcedure<Resource> procedure) {
\r
3793 forSingleType(subject, relation, new SyncToAsyncProcedure<Resource>(
\r
3798 public void forSingleType(Resource subject, Resource relation,
\r
3799 Procedure<Resource> procedure) {
\r
3800 forSingleType(subject, relation, new NoneToAsyncProcedure<Resource>(
\r
3805 public <T> void forValue(Resource subject, Binding binding,
\r
3806 AsyncListener<T> listener) {
\r
3807 asyncRequest(new Value<T>(subject, binding), listener);
\r
3811 public <T> void forValue(Resource subject, Binding binding,
\r
3812 SyncListener<T> listener) {
\r
3813 asyncRequest(new Value<T>(subject, binding), listener);
\r
3817 public <T> void forValue(Resource subject, Binding binding,
\r
3818 Listener<T> listener) {
\r
3819 asyncRequest(new Value<T>(subject, binding), listener);
\r
3823 public <T> void forValue(final Resource resource, final Binding binding,
\r
3824 final AsyncProcedure<T> procedure) {
\r
3826 assert (resource != null);
\r
3827 assert (binding != null);
\r
3828 assert (procedure != null);
\r
3830 processor.forValue(this, resource, new AsyncProcedure<byte[]>() {
\r
3833 public void execute(AsyncReadGraph graph, byte[] result) {
\r
3837 if (result == null) {
\r
3838 procedure.exception(graph,
\r
3839 new DoesNotContainValueException(
\r
3840 "No value for resource " + resource));
\r
3844 Serializer serializer = binding.serializer();
\r
3845 // Serializer serializer = Bindings.getSerializer( binding );
\r
3846 Object obj = serializer.deserialize(result);
\r
3847 // if (!binding.isInstance(obj))
\r
3848 // procedure.exception(graph, new ClassCastException(
\r
3849 // "Cannot get value " + obj + " with binding "
\r
3852 procedure.execute(graph, (T) obj);
\r
3854 } catch (IOException e) {
\r
3855 procedure.exception(graph, e);
\r
3856 } catch (BufferUnderflowException e) {
\r
3857 procedure.exception(graph, e);
\r
3858 } catch (Throwable t) {
\r
3859 procedure.exception(graph, t);
\r
3865 public void exception(AsyncReadGraph graph, Throwable t) {
\r
3867 procedure.exception(graph, t);
\r
3868 } catch (Throwable t2) {
\r
3869 Logger.defaultLogError(t2);
\r
3874 public String toString() {
\r
3875 return "forValue -> " + procedure;
\r
3883 public <T> void forValue(Resource subject, Binding binding,
\r
3884 SyncProcedure<T> procedure) {
\r
3885 forValue(subject, binding, new SyncToAsyncProcedure<T>(procedure));
\r
3889 public <T> void forValue(Resource subject, Binding binding,
\r
3890 Procedure<T> procedure) {
\r
3891 forValue(subject, binding, new NoneToAsyncProcedure<T>(procedure));
\r
3895 public <T> void forValue(Resource subject, AsyncListener<T> listener) {
\r
3896 asyncRequest(new ValueImplied<T>(subject), listener);
\r
3900 public <T> void forValue(Resource subject, SyncListener<T> listener) {
\r
3901 asyncRequest(new ValueImplied<T>(subject), listener);
\r
3905 public <T> void forValue(Resource subject, Listener<T> listener) {
\r
3906 asyncRequest(new ValueImplied<T>(subject), listener);
\r
3910 final public <T> void forValue(final Resource subject, final AsyncProcedure<T> procedure) {
\r
3912 assert (subject != null);
\r
3913 assert (procedure != null);
\r
3915 forRelatedValue(subject, processor.getL0(this).HasDataType, DATA_TYPE_BINDING_INTERNAL, new AsyncProcedure<Datatype>() {
\r
3918 public void execute(AsyncReadGraph graph, Datatype type) {
\r
3919 // TODO: consider trying Bindings.getBeanBinding(type);
\r
3920 Binding binding = Bindings.getBinding(type);
\r
3921 graph.forValue(subject, binding, procedure);
\r
3925 public void exception(AsyncReadGraph graph, Throwable throwable) {
\r
3926 procedure.exception(graph, new DoesNotContainValueException("Invalid data type", throwable));
\r
3934 public <T> void forValue(Resource subject, SyncProcedure<T> procedure) {
\r
3935 forValue(subject, new SyncToAsyncProcedure<T>(procedure));
\r
3939 public <T> void forValue(Resource subject, Procedure<T> procedure) {
\r
3940 forValue(subject, new NoneToAsyncProcedure<T>(procedure));
\r
3944 public <T> void forRelatedValue(Resource subject, Resource relation,
\r
3945 AsyncListener<T> listener) {
\r
3946 asyncRequest(new RelatedValueImplied<T>(subject, relation), listener);
\r
3950 public <T> void forRelatedValue(Resource subject, Resource relation,
\r
3951 SyncListener<T> listener) {
\r
3952 asyncRequest(new RelatedValueImplied<T>(subject, relation), listener);
\r
3956 public <T> void forRelatedValue(Resource subject, Resource relation,
\r
3957 Listener<T> listener) {
\r
3958 asyncRequest(new RelatedValueImplied<T>(subject, relation), listener);
\r
3962 final public <T> void forRelatedValue(final Resource subject,
\r
3963 final Resource relation, final AsyncProcedure<T> procedure) {
\r
3965 assert (subject != null);
\r
3966 assert (relation != null);
\r
3967 assert (procedure != null);
\r
3969 final DeepSingleOrErrorProcedure<T> checkedProcedure = new DeepSingleOrErrorProcedure<T>(procedure);
\r
3971 processor.forEachObject(this, subject, relation,
\r
3972 new AsyncMultiProcedureAdapter<Resource>() {
\r
3975 public void execute(AsyncReadGraph graph,
\r
3976 final Resource object) {
\r
3978 checkedProcedure.inc();
\r
3980 graph.forValue(object, new AsyncProcedure<Object>() {
\r
3983 public void execute(AsyncReadGraph graph,
\r
3985 checkedProcedure.offer(graph, (T) result);
\r
3986 checkedProcedure.dec(graph);
\r
3990 public void exception(AsyncReadGraph graph,
\r
3992 checkedProcedure.exception(graph, t);
\r
3996 public String toString() {
\r
3997 return "forRelatedValue -> " + procedure;
\r
4005 public void finished(AsyncReadGraph graph) {
\r
4006 checkedProcedure.dec(graph);
\r
4010 public void exception(AsyncReadGraph graph, Throwable t) {
\r
4011 checkedProcedure.exception(graph, t);
\r
4019 public <T> void forRelatedValue(Resource subject, Resource relation,
\r
4020 SyncProcedure<T> procedure) {
\r
4021 forRelatedValue(subject, relation, new SyncToAsyncProcedure<T>(
\r
4026 public <T> void forRelatedValue(Resource subject, Resource relation,
\r
4027 Procedure<T> procedure) {
\r
4028 forRelatedValue(subject, relation, new NoneToAsyncProcedure<T>(
\r
4033 public <T> void forRelatedValue(Resource subject, Resource relation,
\r
4034 Binding binding, AsyncListener<T> listener) {
\r
4035 asyncRequest(new RelatedValue<T>(subject, relation, binding), listener);
\r
4039 public <T> void forRelatedValue(Resource subject, Resource relation,
\r
4040 Binding binding, SyncListener<T> listener) {
\r
4041 asyncRequest(new RelatedValue<T>(subject, relation, binding), listener);
\r
4045 public <T> void forRelatedValue(Resource subject, Resource relation,
\r
4046 Binding binding, Listener<T> listener) {
\r
4047 asyncRequest(new RelatedValue<T>(subject, relation, binding), listener);
\r
4051 final public <T> void forRelatedValue(final Resource subject,
\r
4052 final Resource relation, final Binding binding,
\r
4053 final AsyncProcedure<T> procedure) {
\r
4055 assert (subject != null);
\r
4056 assert (relation != null);
\r
4057 assert (binding != null);
\r
4058 assert (procedure != null);
\r
4060 final DeepSingleOrErrorProcedure<T> checkedProcedure = new DeepSingleOrErrorProcedure<T>(procedure);
\r
4062 processor.forEachObject(this, subject, relation,
\r
4063 new AsyncMultiProcedureAdapter<Resource>() {
\r
4066 public void execute(AsyncReadGraph graph,
\r
4067 final Resource object) {
\r
4069 checkedProcedure.inc();
\r
4071 graph.forValue(object, binding, new AsyncProcedure<Object>() {
\r
4074 public void execute(AsyncReadGraph graph,
\r
4077 checkedProcedure.offer(graph,
\r
4079 checkedProcedure.dec(graph);
\r
4083 public void exception(AsyncReadGraph graph,
\r
4085 checkedProcedure.exception(graph, t);
\r
4089 public String toString() {
\r
4090 return "forRelatedValue -> "
\r
4099 public void finished(AsyncReadGraph graph) {
\r
4100 checkedProcedure.dec(graph);
\r
4104 public void exception(AsyncReadGraph graph, Throwable t) {
\r
4105 checkedProcedure.exception(graph, t);
\r
4113 public <T> void forRelatedValue(Resource subject, Resource relation,
\r
4114 Binding binding, SyncProcedure<T> procedure) {
\r
4115 forRelatedValue(subject, relation, binding,
\r
4116 new SyncToAsyncProcedure<T>(procedure));
\r
4120 public <T> void forRelatedValue(Resource subject, Resource relation,
\r
4121 Binding binding, Procedure<T> procedure) {
\r
4122 forRelatedValue(subject, relation, binding,
\r
4123 new NoneToAsyncProcedure<T>(procedure));
\r
4127 public <T> void forAdapted(Resource resource, Class<T> clazz,
\r
4128 AsyncListener<T> listener) {
\r
4129 asyncRequest(new Adapter<T>(resource, clazz), listener);
\r
4133 public <T> void forAdapted(Resource resource, Class<T> clazz,
\r
4134 SyncListener<T> listener) {
\r
4135 asyncRequest(new Adapter<T>(resource, clazz), listener);
\r
4139 public <T> void forAdapted(Resource resource, Class<T> clazz,
\r
4140 Listener<T> listener) {
\r
4141 asyncRequest(new Adapter<T>(resource, clazz), listener);
\r
4145 final public <T> void forAdapted(final Resource resource,
\r
4146 final Class<T> clazz, final AsyncProcedure<T> procedure) {
\r
4148 assert (resource != null);
\r
4149 assert (clazz != null);
\r
4150 assert (procedure != null);
\r
4152 final AdaptionService service = getSession().peekService(AdaptionService.class);
\r
4153 if (service == null)
\r
4154 procedure.exception(this, new ServiceException("No AdaptionService available"));
\r
4156 service.adapt(this, resource, resource, Resource.class, clazz, false, procedure);
\r
4161 public <T> void forAdapted(Resource resource, Class<T> clazz,
\r
4162 SyncProcedure<T> procedure) {
\r
4163 forAdapted(resource, clazz, new SyncToAsyncProcedure<T>(procedure));
\r
4167 public <T> void forAdapted(Resource resource, Class<T> clazz,
\r
4168 Procedure<T> procedure) {
\r
4169 forAdapted(resource, clazz, new NoneToAsyncProcedure<T>(procedure));
\r
4173 public <T> void forUniqueAdapted(Resource resource, Class<T> clazz,
\r
4174 AsyncListener<T> listener) {
\r
4175 asyncRequest(new UniqueAdapter<T>(resource, clazz), listener);
\r
4179 public <T> void forUniqueAdapted(Resource resource, Class<T> clazz,
\r
4180 SyncListener<T> listener) {
\r
4181 asyncRequest(new UniqueAdapter<T>(resource, clazz), listener);
\r
4185 public <T> void forUniqueAdapted(Resource resource, Class<T> clazz,
\r
4186 Listener<T> listener) {
\r
4187 asyncRequest(new UniqueAdapter<T>(resource, clazz), listener);
\r
4191 final public <T> void forUniqueAdapted(final Resource resource,
\r
4192 final Class<T> clazz, final AsyncProcedure<T> procedure) {
\r
4194 assert (resource != null);
\r
4195 assert (clazz != null);
\r
4196 assert (procedure != null);
\r
4198 final AdaptionService service = getSession().peekService(AdaptionService.class);
\r
4199 if (service == null)
\r
4200 procedure.exception(this, new ServiceException("No AdaptionService available"));
\r
4202 service.adaptNew(this, resource, clazz, false, procedure);
\r
4207 public <T> void forUniqueAdapted(Resource resource, Class<T> clazz,
\r
4208 SyncProcedure<T> procedure) {
\r
4209 forUniqueAdapted(resource, clazz,
\r
4210 new SyncToAsyncProcedure<T>(procedure));
\r
4214 public <T> void forUniqueAdapted(Resource resource, Class<T> clazz,
\r
4215 Procedure<T> procedure) {
\r
4216 forUniqueAdapted(resource, clazz,
\r
4217 new NoneToAsyncProcedure<T>(procedure));
\r
4221 public void forPossibleInverse(Resource subject,
\r
4222 AsyncListener<Resource> listener) {
\r
4223 asyncRequest(new PossibleInverse(subject), listener);
\r
4227 public void forPossibleInverse(Resource subject,
\r
4228 SyncListener<Resource> listener) {
\r
4229 asyncRequest(new PossibleInverse(subject), listener);
\r
4233 public void forPossibleInverse(Resource subject, Listener<Resource> listener) {
\r
4234 asyncRequest(new PossibleInverse(subject), listener);
\r
4238 final public void forPossibleInverse(final Resource relation,
\r
4239 final AsyncProcedure<Resource> procedure) {
\r
4241 assert (relation != null);
\r
4242 assert (procedure != null);
\r
4244 processor.forInverse(this, relation, new ExceptionToNullProcedure<Resource>(procedure));
\r
4249 public void forPossibleInverse(Resource subject,
\r
4250 SyncProcedure<Resource> procedure) {
\r
4251 forPossibleInverse(subject, new SyncToAsyncProcedure<Resource>(
\r
4256 public void forPossibleInverse(Resource subject,
\r
4257 Procedure<Resource> procedure) {
\r
4258 forPossibleInverse(subject, new NoneToAsyncProcedure<Resource>(
\r
4263 public void forPossibleObject(Resource subject, Resource relation,
\r
4264 AsyncListener<Resource> listener) {
\r
4265 asyncRequest(new PossibleObject(subject, relation), listener);
\r
4269 public void forPossibleObject(Resource subject, Resource relation,
\r
4270 SyncListener<Resource> listener) {
\r
4271 asyncRequest(new PossibleObject(subject, relation), listener);
\r
4275 public void forPossibleObject(Resource subject, Resource relation,
\r
4276 Listener<Resource> listener) {
\r
4277 asyncRequest(new PossibleObject(subject, relation), listener);
\r
4281 final public void forPossibleObject(final Resource subject,
\r
4282 final Resource relation, final AsyncProcedure<Resource> procedure) {
\r
4284 assert (subject != null);
\r
4285 assert (relation != null);
\r
4286 assert (procedure != null);
\r
4288 processor.forEachObject(this, subject, relation,
\r
4289 new SingleOrNullProcedure<Resource>(procedure));
\r
4294 public void forPossibleObject(Resource subject, Resource relation,
\r
4295 SyncProcedure<Resource> procedure) {
\r
4296 forPossibleObject(subject, relation,
\r
4297 new SyncToAsyncProcedure<Resource>(procedure));
\r
4301 public void forPossibleObject(Resource subject, Resource relation,
\r
4302 Procedure<Resource> procedure) {
\r
4303 forPossibleObject(subject, relation,
\r
4304 new NoneToAsyncProcedure<Resource>(procedure));
\r
4308 public void forPossibleStatement(Resource subject, Resource relation,
\r
4309 AsyncListener<Statement> listener) {
\r
4310 asyncRequest(new PossibleStatement(subject, relation), listener);
\r
4314 public void forPossibleStatement(Resource subject, Resource relation,
\r
4315 SyncListener<Statement> listener) {
\r
4316 asyncRequest(new PossibleStatement(subject, relation), listener);
\r
4320 public void forPossibleStatement(Resource subject, Resource relation,
\r
4321 Listener<Statement> listener) {
\r
4322 asyncRequest(new PossibleStatement(subject, relation), listener);
\r
4326 final public void forPossibleStatement(final Resource subject,
\r
4327 final Resource relation, final AsyncProcedure<Statement> procedure) {
\r
4329 assert (subject != null);
\r
4330 assert (relation != null);
\r
4331 assert (procedure != null);
\r
4333 processor.forEachStatement(this, subject, relation,
\r
4334 new SingleFunctionalOrNullProcedure<Statement>(
\r
4335 "forPossibleStatement", procedure));
\r
4340 public void forPossibleStatement(Resource subject, Resource relation,
\r
4341 SyncProcedure<Statement> procedure) {
\r
4342 forPossibleStatement(subject, relation,
\r
4343 new SyncToAsyncProcedure<Statement>(procedure));
\r
4347 public void forPossibleStatement(Resource subject, Resource relation,
\r
4348 Procedure<Statement> procedure) {
\r
4349 forPossibleStatement(subject, relation,
\r
4350 new NoneToAsyncProcedure<Statement>(procedure));
\r
4354 public void forPossibleType(Resource subject, Resource relation,
\r
4355 AsyncListener<Resource> listener) {
\r
4356 asyncRequest(new PossibleType(subject, relation), listener);
\r
4360 public void forPossibleType(Resource subject, Resource relation,
\r
4361 SyncListener<Resource> listener) {
\r
4362 asyncRequest(new PossibleType(subject, relation), listener);
\r
4366 public void forPossibleType(Resource subject, Resource relation,
\r
4367 Listener<Resource> listener) {
\r
4368 asyncRequest(new PossibleType(subject, relation), listener);
\r
4372 final public void forPossibleType(final Resource subject,
\r
4373 final Resource baseType, final AsyncProcedure<Resource> procedure) {
\r
4375 assert (subject != null);
\r
4376 assert (procedure != null);
\r
4378 final NullSingleOrNullProcedure<Resource> checkedProcedure = new NullSingleOrNullProcedure<Resource>(procedure);
\r
4380 processor.forEachPrincipalType(this, subject, new AsyncMultiProcedureAdapter<Resource>() {
\r
4383 public void execute(AsyncReadGraph graph,
\r
4384 final Resource principalType) {
\r
4386 if (baseType == null) {
\r
4388 checkedProcedure.offer(graph, principalType);
\r
4390 } else if (principalType.equals(baseType)) {
\r
4392 checkedProcedure.offer(graph, principalType);
\r
4396 checkedProcedure.inc();
\r
4398 processor.forSupertypes((ReadGraphImpl)graph, principalType,
\r
4399 new AsyncProcedure<Set<Resource>>() {
\r
4402 public void execute(
\r
4403 AsyncReadGraph graph,
\r
4404 Set<Resource> result) {
\r
4406 if (result.contains(baseType)) {
\r
4407 checkedProcedure.offer(graph,
\r
4411 checkedProcedure.dec(graph);
\r
4416 public void exception(
\r
4417 AsyncReadGraph graph,
\r
4419 checkedProcedure.exception(graph, t);
\r
4420 checkedProcedure.dec(graph);
\r
4424 public String toString() {
\r
4425 return "forPossibleType -> "
\r
4436 public void finished(AsyncReadGraph graph) {
\r
4437 checkedProcedure.dec(graph);
\r
4441 public void exception(AsyncReadGraph graph, Throwable t) {
\r
4442 checkedProcedure.exception(graph, t);
\r
4443 checkedProcedure.dec(graph);
\r
4451 public void forPossibleType(Resource subject, Resource relation,
\r
4452 SyncProcedure<Resource> procedure) {
\r
4453 forPossibleType(subject, relation, new SyncToAsyncProcedure<Resource>(
\r
4458 public void forPossibleType(Resource subject, Resource relation,
\r
4459 Procedure<Resource> procedure) {
\r
4460 forPossibleType(subject, relation, new NoneToAsyncProcedure<Resource>(
\r
4465 public <T> void forPossibleValue(Resource subject, AsyncListener<T> listener) {
\r
4466 asyncRequest(new PossibleValueImplied<T>(subject), listener);
\r
4470 public <T> void forPossibleValue(Resource subject, SyncListener<T> listener) {
\r
4471 asyncRequest(new PossibleValueImplied<T>(subject), listener);
\r
4475 public <T> void forPossibleValue(Resource subject, Listener<T> listener) {
\r
4476 asyncRequest(new PossibleValueImplied<T>(subject), listener);
\r
4480 final public <T> void forPossibleValue(final Resource subject,
\r
4481 final AsyncProcedure<T> procedure) {
\r
4483 assert (subject != null);
\r
4484 assert (procedure != null);
\r
4486 forPossibleRelatedValue(subject, processor.getL0(this).HasDataType, DATA_TYPE_BINDING_INTERNAL, new AsyncProcedure<Datatype>() {
\r
4489 public void execute(AsyncReadGraph graph, final Datatype type) {
\r
4490 if (type == null) {
\r
4491 procedure.execute(graph, null);
\r
4494 // TODO: consider trying Bindings.getBeanBinding(type);
\r
4495 Binding binding = Bindings.getBinding(type);
\r
4496 graph.forPossibleValue(subject, binding, procedure);
\r
4497 } catch (RuntimeBindingConstructionException e) {
\r
4498 procedure.exception(graph, e);
\r
4504 public void exception(AsyncReadGraph graph, Throwable t) {
\r
4505 procedure.exception(graph, t);
\r
4509 public String toString() {
\r
4510 return "forPossibleValue -> " + procedure;
\r
4518 public <T> void forPossibleValue(Resource subject,
\r
4519 SyncProcedure<T> procedure) {
\r
4520 forPossibleValue(subject, new SyncToAsyncProcedure<T>(procedure));
\r
4524 public <T> void forPossibleValue(Resource subject, Procedure<T> procedure) {
\r
4525 forPossibleValue(subject, new NoneToAsyncProcedure<T>(procedure));
\r
4529 public <T> void forPossibleValue(Resource subject, Binding binding,
\r
4530 AsyncListener<T> listener) {
\r
4531 asyncRequest(new PossibleValue<T>(subject, binding), listener);
\r
4535 public <T> void forPossibleValue(Resource subject, Binding binding,
\r
4536 SyncListener<T> listener) {
\r
4537 asyncRequest(new PossibleValue<T>(subject, binding), listener);
\r
4541 public <T> void forPossibleValue(Resource subject, Binding binding,
\r
4542 Listener<T> listener) {
\r
4543 asyncRequest(new PossibleValue<T>(subject, binding), listener);
\r
4547 final public <T> void forPossibleValue(final Resource resource,
\r
4548 final Binding binding, final AsyncProcedure<T> procedure) {
\r
4550 assert (resource != null);
\r
4551 assert (binding != null);
\r
4552 assert (procedure != null);
\r
4554 processor.forValue(this, resource, new AsyncProcedure<byte[]>() {
\r
4557 public void execute(AsyncReadGraph graph, byte[] result) {
\r
4561 if (result == null) {
\r
4562 procedure.execute(graph, null);
\r
4566 Serializer serializer = Bindings.getSerializer( binding );
\r
4567 Object obj = serializer.deserialize(result);
\r
4568 if (!binding.isInstance(obj))
\r
4569 procedure.exception(graph, new ClassCastException(
\r
4570 "Cannot get value " + obj + " with binding "
\r
4573 procedure.execute(graph, (T) obj);
\r
4575 } catch (IOException e) {
\r
4576 procedure.exception(graph, e);
\r
4577 } catch (BufferUnderflowException e) {
\r
4578 procedure.exception(graph, e);
\r
4579 } catch (Throwable t) {
\r
4580 procedure.exception(graph, t);
\r
4586 public void exception(AsyncReadGraph graph, Throwable t) {
\r
4588 procedure.exception(graph, t);
\r
4589 } catch (Throwable t2) {
\r
4590 Logger.defaultLogError(t2);
\r
4595 public String toString() {
\r
4596 return "forPossibleValue -> " + procedure;
\r
4604 public <T> void forPossibleValue(Resource subject, Binding binding,
\r
4605 SyncProcedure<T> procedure) {
\r
4606 forPossibleValue(subject, binding, new SyncToAsyncProcedure<T>(
\r
4611 public <T> void forPossibleValue(Resource subject, Binding binding,
\r
4612 Procedure<T> procedure) {
\r
4613 forPossibleValue(subject, binding, new NoneToAsyncProcedure<T>(
\r
4618 public <T> void forPossibleRelatedValue(Resource subject,
\r
4619 Resource relation, AsyncListener<T> listener) {
\r
4620 asyncRequest(new PossibleRelatedValueImplied<T>(subject, relation),
\r
4625 public <T> void forPossibleRelatedValue(Resource subject,
\r
4626 Resource relation, SyncListener<T> listener) {
\r
4627 asyncRequest(new PossibleRelatedValueImplied<T>(subject, relation),
\r
4632 public <T> void forPossibleRelatedValue(Resource subject,
\r
4633 Resource relation, Listener<T> listener) {
\r
4634 asyncRequest(new PossibleRelatedValueImplied<T>(subject, relation),
\r
4639 final public <T> void forPossibleRelatedValue(final Resource subject,
\r
4640 final Resource relation, final AsyncProcedure<T> procedure) {
\r
4642 assert (subject != null);
\r
4643 assert (relation != null);
\r
4644 assert (procedure != null);
\r
4646 final DeepSingleOrNullProcedure<T> checkedProcedure = new DeepSingleOrNullProcedure<T>(procedure);
\r
4648 processor.forEachObject(this, subject, relation,
\r
4649 new AsyncMultiProcedureAdapter<Resource>() {
\r
4652 public void execute(AsyncReadGraph graph,
\r
4653 final Resource object) {
\r
4655 checkedProcedure.inc();
\r
4657 graph.forValue(object, new AsyncProcedure<Object>() {
\r
4660 public void execute(AsyncReadGraph graph,
\r
4662 checkedProcedure.offer(graph, (T) result);
\r
4663 checkedProcedure.dec(graph);
\r
4667 public void exception(AsyncReadGraph graph,
\r
4669 checkedProcedure.exception(graph, t);
\r
4670 checkedProcedure.dec(graph);
\r
4678 public void finished(AsyncReadGraph graph) {
\r
4680 checkedProcedure.dec(graph);
\r
4684 public void exception(AsyncReadGraph graph, Throwable t) {
\r
4685 checkedProcedure.exception(graph, t);
\r
4686 checkedProcedure.dec(graph);
\r
4690 public String toString() {
\r
4691 return "forPossibleRelatedValue -> " + procedure;
\r
4698 public <T> void forPossibleRelatedValue(Resource subject,
\r
4699 Resource relation, SyncProcedure<T> procedure) {
\r
4700 forPossibleRelatedValue(subject, relation, new SyncToAsyncProcedure<T>(
\r
4705 public <T> void forPossibleRelatedValue(Resource subject,
\r
4706 Resource relation, Procedure<T> procedure) {
\r
4707 forPossibleRelatedValue(subject, relation, new NoneToAsyncProcedure<T>(
\r
4712 public <T> void forPossibleRelatedValue(Resource subject,
\r
4713 Resource relation, Binding binding, AsyncListener<T> listener) {
\r
4714 asyncRequest(new PossibleRelatedValue<T>(subject, relation, binding),
\r
4719 public <T> void forPossibleRelatedValue(Resource subject,
\r
4720 Resource relation, Binding binding, SyncListener<T> listener) {
\r
4721 asyncRequest(new PossibleRelatedValue<T>(subject, relation, binding),
\r
4726 public <T> void forPossibleRelatedValue(Resource subject,
\r
4727 Resource relation, Binding binding, Listener<T> listener) {
\r
4728 asyncRequest(new PossibleRelatedValue<T>(subject, relation, binding),
\r
4733 // final public <T> void forPossibleRelatedValue(final Resource subject, final Resource relation, final Binding binding,
\r
4734 // final AsyncProcedure<T> procedure) {
\r
4736 // forPossibleRelatedValue(subject, relation, binding, procedure, false);
\r
4740 final public <T> void forPossibleRelatedValue(final Resource subject, final Resource relation, final Binding binding,
\r
4741 final AsyncProcedure<T> procedure) {
\r
4743 assert (subject != null);
\r
4744 assert (relation != null);
\r
4745 assert (procedure != null);
\r
4747 processor.forPossibleObject(this, subject, relation, new AsyncProcedure<Resource>() {
\r
4750 public void execute(AsyncReadGraph graph, Resource object) {
\r
4752 if(object == null) {
\r
4753 procedure.execute(graph, null);
\r
4757 processor.forPossibleValue((ReadGraphImpl)graph, object, new AsyncProcedure<byte[]>() {
\r
4760 public void execute(AsyncReadGraph graph, byte[] bytes) {
\r
4762 if(bytes != null) {
\r
4766 Serializer serializer = binding.serializer();
\r
4767 Object obj = serializer.deserialize(bytes);
\r
4768 if (!binding.isInstance(obj)) {
\r
4769 procedure.exception(graph, new ClassCastException("Cannot get value " + obj + " with binding " + binding));
\r
4771 procedure.execute(graph, (T) obj);
\r
4774 } catch (Throwable t) {
\r
4776 procedure.exception(graph, t);
\r
4782 procedure.execute(graph, null);
\r
4789 public void exception(AsyncReadGraph graph, Throwable t) {
\r
4790 procedure.exception(graph, t);
\r
4798 public void exception(AsyncReadGraph graph, Throwable throwable) {
\r
4799 throwable.printStackTrace();
\r
4800 procedure.exception(graph, throwable);
\r
4808 public <T> void forPossibleRelatedValue(Resource subject,
\r
4809 Resource relation, Binding binding, SyncProcedure<T> procedure) {
\r
4810 forPossibleRelatedValue(subject, relation, binding,
\r
4811 new SyncToAsyncProcedure<T>(procedure));
\r
4815 public <T> void forPossibleRelatedValue(Resource subject,
\r
4816 Resource relation, Binding binding, Procedure<T> procedure) {
\r
4817 forPossibleRelatedValue(subject, relation, binding,
\r
4818 new NoneToAsyncProcedure<T>(procedure));
\r
4822 public void forIsInstanceOf(Resource subject, Resource relation,
\r
4823 AsyncListener<Boolean> listener) {
\r
4824 asyncRequest(new IsInstanceOf(subject, relation), listener);
\r
4828 public void forIsInstanceOf(Resource subject, Resource relation,
\r
4829 SyncListener<Boolean> listener) {
\r
4830 asyncRequest(new IsInstanceOf(subject, relation), listener);
\r
4834 public void forIsInstanceOf(Resource subject, Resource relation,
\r
4835 Listener<Boolean> listener) {
\r
4836 asyncRequest(new IsInstanceOf(subject, relation), listener);
\r
4840 final public void forIsInstanceOf(final Resource resource,
\r
4841 final Resource type, final AsyncProcedure<Boolean> procedure) {
\r
4843 assert (resource != null);
\r
4844 assert (type != null);
\r
4845 assert (procedure != null);
\r
4847 forTypes(resource, new AsyncProcedure<Set<Resource>>() {
\r
4850 public void execute(AsyncReadGraph graph, Set<Resource> result) {
\r
4853 if (result.contains(type))
\r
4854 procedure.execute(graph, true);
\r
4856 procedure.execute(graph, false);
\r
4857 } catch (Throwable t) {
\r
4858 Logger.defaultLogError(t);
\r
4863 public void exception(AsyncReadGraph graph, Throwable t) {
\r
4865 procedure.exception(graph, t);
\r
4866 } catch (Throwable t2) {
\r
4867 Logger.defaultLogError(t2);
\r
4872 public String toString() {
\r
4873 return "forIsInstanceOf -> " + procedure;
\r
4881 public void forIsInstanceOf(Resource subject, Resource relation,
\r
4882 SyncProcedure<Boolean> procedure) {
\r
4883 forIsInstanceOf(subject, relation, new SyncToAsyncProcedure<Boolean>(
\r
4888 public void forIsInstanceOf(Resource subject, Resource relation,
\r
4889 Procedure<Boolean> procedure) {
\r
4890 forIsInstanceOf(subject, relation, new NoneToAsyncProcedure<Boolean>(
\r
4895 public void forIsInheritedFrom(Resource subject, Resource relation,
\r
4896 AsyncListener<Boolean> listener) {
\r
4897 asyncRequest(new IsInheritedFrom(subject, relation), listener);
\r
4901 public void forIsInheritedFrom(Resource subject, Resource relation,
\r
4902 SyncListener<Boolean> listener) {
\r
4903 asyncRequest(new IsInheritedFrom(subject, relation), listener);
\r
4907 public void forIsInheritedFrom(Resource subject, Resource relation,
\r
4908 Listener<Boolean> listener) {
\r
4909 asyncRequest(new IsInheritedFrom(subject, relation), listener);
\r
4913 final public void forIsInheritedFrom(final Resource resource,
\r
4914 final Resource type, final AsyncProcedure<Boolean> procedure) {
\r
4916 assert (resource != null);
\r
4917 assert (type != null);
\r
4918 assert (procedure != null);
\r
4920 if (resource.equals(type)) {
\r
4922 procedure.execute(this, true);
\r
4923 } catch (Throwable t) {
\r
4924 Logger.defaultLogError(t);
\r
4929 forSupertypes(resource, new AsyncProcedure<Set<Resource>>() {
\r
4932 public void execute(AsyncReadGraph graph, Set<Resource> result) {
\r
4934 if (result.contains(type))
\r
4935 procedure.execute(graph, true);
\r
4937 procedure.execute(graph, false);
\r
4938 } catch (Throwable t) {
\r
4939 Logger.defaultLogError(t);
\r
4944 public void exception(AsyncReadGraph graph, Throwable t) {
\r
4946 procedure.exception(graph, t);
\r
4947 } catch (Throwable t2) {
\r
4948 Logger.defaultLogError(t2);
\r
4953 public String toString() {
\r
4954 return "forIsInheritedFrom -> " + procedure;
\r
4962 public void forIsInheritedFrom(Resource subject, Resource relation,
\r
4963 SyncProcedure<Boolean> procedure) {
\r
4964 forIsInheritedFrom(subject, relation,
\r
4965 new SyncToAsyncProcedure<Boolean>(procedure));
\r
4969 public void forIsInheritedFrom(Resource subject, Resource relation,
\r
4970 Procedure<Boolean> procedure) {
\r
4971 forIsInheritedFrom(subject, relation,
\r
4972 new NoneToAsyncProcedure<Boolean>(procedure));
\r
4976 public void forIsSubrelationOf(Resource subject, Resource relation,
\r
4977 AsyncListener<Boolean> listener) {
\r
4978 asyncRequest(new IsSubrelationOf(subject, relation), listener);
\r
4982 public void forIsSubrelationOf(Resource subject, Resource relation,
\r
4983 SyncListener<Boolean> listener) {
\r
4984 asyncRequest(new IsSubrelationOf(subject, relation), listener);
\r
4988 public void forIsSubrelationOf(Resource subject, Resource relation,
\r
4989 Listener<Boolean> listener) {
\r
4990 asyncRequest(new IsSubrelationOf(subject, relation), listener);
\r
4994 final public void forIsSubrelationOf(final Resource resource,
\r
4995 final Resource relation, final AsyncProcedure<Boolean> procedure) {
\r
4997 assert (resource != null);
\r
4998 assert (relation != null);
\r
4999 assert (procedure != null);
\r
5001 if (resource.equals(relation)) {
\r
5002 procedure.execute(this, true);
\r
5006 forSuperrelations(resource, new AsyncProcedure<Set<Resource>>() {
\r
5009 public void execute(AsyncReadGraph graph, Set<Resource> result) {
\r
5011 if (result.contains(relation))
\r
5012 procedure.execute(graph, true);
\r
5014 procedure.execute(graph, false);
\r
5015 } catch (Throwable t) {
\r
5016 Logger.defaultLogError(t);
\r
5021 public void exception(AsyncReadGraph graph, Throwable t) {
\r
5023 procedure.exception(graph, t);
\r
5024 } catch (Throwable t2) {
\r
5025 Logger.defaultLogError(t2);
\r
5030 public String toString() {
\r
5031 return "forIsSubrelationOf -> " + procedure;
\r
5039 public void forIsSubrelationOf(Resource subject, Resource relation,
\r
5040 SyncProcedure<Boolean> procedure) {
\r
5041 forIsSubrelationOf(subject, relation,
\r
5042 new SyncToAsyncProcedure<Boolean>(procedure));
\r
5046 public void forIsSubrelationOf(Resource subject, Resource relation,
\r
5047 Procedure<Boolean> procedure) {
\r
5048 forIsSubrelationOf(subject, relation,
\r
5049 new NoneToAsyncProcedure<Boolean>(procedure));
\r
5053 public void forHasStatement(Resource subject,
\r
5054 AsyncListener<Boolean> listener) {
\r
5055 asyncRequest(new HasStatementSubject(subject), listener);
\r
5059 public void forHasStatement(Resource subject, SyncListener<Boolean> listener) {
\r
5060 asyncRequest(new HasStatementSubject(subject), listener);
\r
5064 public void forHasStatement(Resource subject, Listener<Boolean> listener) {
\r
5065 asyncRequest(new HasStatementSubject(subject), listener);
\r
5069 final public void forHasStatement(final Resource subject,
\r
5070 final AsyncProcedure<Boolean> procedure) {
\r
5072 assert (subject != null);
\r
5073 assert (procedure != null);
\r
5075 processor.forHasStatement(this, subject, procedure);
\r
5080 public void forHasStatement(Resource subject,
\r
5081 SyncProcedure<Boolean> procedure) {
\r
5082 forHasStatement(subject, new SyncToAsyncProcedure<Boolean>(procedure));
\r
5086 public void forHasStatement(Resource subject, Procedure<Boolean> procedure) {
\r
5087 forHasStatement(subject, new NoneToAsyncProcedure<Boolean>(procedure));
\r
5091 public void forHasStatement(Resource subject, Resource relation,
\r
5092 AsyncListener<Boolean> listener) {
\r
5093 asyncRequest(new HasStatement(subject, relation), listener);
\r
5097 public void forHasStatement(Resource subject, Resource relation,
\r
5098 SyncListener<Boolean> listener) {
\r
5099 asyncRequest(new HasStatement(subject, relation), listener);
\r
5103 public void forHasStatement(Resource subject, Resource relation,
\r
5104 Listener<Boolean> listener) {
\r
5105 asyncRequest(new HasStatement(subject, relation), listener);
\r
5109 final public void forHasStatement(final Resource subject,
\r
5110 final Resource relation, final AsyncProcedure<Boolean> procedure) {
\r
5112 assert (subject != null);
\r
5113 assert (relation != null);
\r
5114 assert (procedure != null);
\r
5116 processor.forHasStatement(this, subject, relation, procedure);
\r
5121 public void forHasStatement(Resource subject, Resource relation,
\r
5122 SyncProcedure<Boolean> procedure) {
\r
5123 forHasStatement(subject, relation, new SyncToAsyncProcedure<Boolean>(
\r
5128 public void forHasStatement(Resource subject, Resource relation,
\r
5129 Procedure<Boolean> procedure) {
\r
5130 forHasStatement(subject, relation, new NoneToAsyncProcedure<Boolean>(
\r
5135 public void forHasStatement(Resource subject, Resource relation,
\r
5136 Resource object, AsyncListener<Boolean> listener) {
\r
5137 asyncRequest(new HasStatementSubjectObject(subject, relation, object),
\r
5142 public void forHasStatement(Resource subject, Resource relation,
\r
5143 Resource object, SyncListener<Boolean> listener) {
\r
5144 asyncRequest(new HasStatementSubjectObject(subject, relation, object),
\r
5149 public void forHasStatement(Resource subject, Resource relation,
\r
5150 Resource object, Listener<Boolean> listener) {
\r
5151 asyncRequest(new HasStatementSubjectObject(subject, relation, object),
\r
5156 final public void forHasStatement(final Resource subject,
\r
5157 final Resource relation, final Resource object,
\r
5158 final AsyncProcedure<Boolean> procedure) {
\r
5160 assert (subject != null);
\r
5161 assert (relation != null);
\r
5162 assert (object != null);
\r
5163 assert (procedure != null);
\r
5165 processor.forHasStatement(this, subject, relation, object, procedure);
\r
5170 public void forHasStatement(Resource subject, Resource relation,
\r
5171 Resource object, SyncProcedure<Boolean> procedure) {
\r
5172 forHasStatement(subject, relation, object,
\r
5173 new SyncToAsyncProcedure<Boolean>(procedure));
\r
5177 public void forHasStatement(Resource subject, Resource relation,
\r
5178 Resource object, Procedure<Boolean> procedure) {
\r
5179 forHasStatement(subject, relation, object,
\r
5180 new NoneToAsyncProcedure<Boolean>(procedure));
\r
5184 public void forHasValue(Resource subject, AsyncListener<Boolean> listener) {
\r
5185 asyncRequest(new HasValue(subject), listener);
\r
5189 public void forHasValue(Resource subject, SyncListener<Boolean> listener) {
\r
5190 asyncRequest(new HasValue(subject), listener);
\r
5194 public void forHasValue(Resource subject, Listener<Boolean> listener) {
\r
5195 asyncRequest(new HasValue(subject), listener);
\r
5199 final public void forHasValue(final Resource subject,
\r
5200 final AsyncProcedure<Boolean> procedure) {
\r
5202 assert (subject != null);
\r
5203 assert (procedure != null);
\r
5205 processor.forValue(this, subject, new AsyncProcedure<byte[]>() {
\r
5208 public void execute(AsyncReadGraph graph, byte[] result) {
\r
5210 if (result == null)
\r
5211 procedure.execute(graph, false);
\r
5213 procedure.execute(graph, true);
\r
5214 } catch (Throwable t) {
\r
5215 Logger.defaultLogError(t);
\r
5220 public void exception(AsyncReadGraph graph, Throwable t) {
\r
5222 procedure.exception(graph, t);
\r
5223 } catch (Throwable t2) {
\r
5224 Logger.defaultLogError(t2);
\r
5229 public String toString() {
\r
5230 return "forHasValue -> " + procedure;
\r
5238 public void forHasValue(Resource subject, SyncProcedure<Boolean> procedure) {
\r
5239 forHasValue(subject, new SyncToAsyncProcedure<Boolean>(procedure));
\r
5243 public void forHasValue(Resource subject, Procedure<Boolean> procedure) {
\r
5244 forHasValue(subject, new NoneToAsyncProcedure<Boolean>(procedure));
\r
5248 public void forOrderedSet(Resource subject,
\r
5249 AsyncMultiListener<Resource> listener) {
\r
5250 asyncRequest(new OrderedSet(subject), listener);
\r
5254 public void forOrderedSet(Resource subject,
\r
5255 SyncMultiListener<Resource> listener) {
\r
5256 asyncRequest(new OrderedSet(subject), listener);
\r
5260 public void forOrderedSet(Resource subject, MultiListener<Resource> listener) {
\r
5261 asyncRequest(new OrderedSet(subject), listener);
\r
5265 final public void forOrderedSet(final Resource subject,
\r
5266 final AsyncMultiProcedure<Resource> procedure) {
\r
5268 assert (subject != null);
\r
5269 assert (procedure != null);
\r
5271 processor.forOrderedSet(this, subject,
\r
5272 new AsyncMultiProcedure<Resource>() {
\r
5275 public void finished(AsyncReadGraph graph) {
\r
5277 procedure.finished(graph);
\r
5278 } catch (Throwable t) {
\r
5279 Logger.defaultLogError(t);
\r
5284 public void execute(AsyncReadGraph graph, Resource result) {
\r
5286 procedure.execute(graph, result);
\r
5287 } catch (Throwable t) {
\r
5288 Logger.defaultLogError(t);
\r
5293 public void exception(AsyncReadGraph graph, Throwable t) {
\r
5295 procedure.exception(graph, t);
\r
5296 } catch (Throwable t2) {
\r
5297 Logger.defaultLogError(t2);
\r
5302 public String toString() {
\r
5303 return "forOrderedSet -> " + procedure;
\r
5311 public void forOrderedSet(Resource subject,
\r
5312 SyncMultiProcedure<Resource> procedure) {
\r
5313 forOrderedSet(subject, new SyncToAsyncMultiProcedure<Resource>(
\r
5318 public void forOrderedSet(Resource subject,
\r
5319 MultiProcedure<Resource> procedure) {
\r
5320 forOrderedSet(subject, new NoneToAsyncMultiProcedure<Resource>(
\r
5325 public <T> void forPossibleAdapted(Resource resource, Class<T> clazz,
\r
5326 AsyncListener<T> listener) {
\r
5327 asyncRequest(new PossibleAdapter<T>(resource, clazz), listener);
\r
5331 public <T> void forPossibleAdapted(Resource resource, Class<T> clazz,
\r
5332 SyncListener<T> listener) {
\r
5333 asyncRequest(new PossibleAdapter<T>(resource, clazz), listener);
\r
5337 public <T> void forPossibleAdapted(Resource resource, Class<T> clazz,
\r
5338 Listener<T> listener) {
\r
5339 asyncRequest(new PossibleAdapter<T>(resource, clazz), listener);
\r
5343 final public <T> void forPossibleAdapted(final Resource resource,
\r
5344 final Class<T> clazz, final AsyncProcedure<T> procedure) {
\r
5346 assert (resource != null);
\r
5347 assert (clazz != null);
\r
5348 assert (procedure != null);
\r
5350 final AdaptionService service = getSession().peekService(AdaptionService.class);
\r
5351 if (service == null)
\r
5352 procedure.exception(this, new ServiceException("No AdaptionService available"));
\r
5354 service.adapt(this, resource, resource, Resource.class, clazz, true, procedure);
\r
5358 public <T> void forPossibleAdapted(Resource resource, Class<T> clazz,
\r
5359 SyncProcedure<T> procedure) {
\r
5360 forPossibleAdapted(resource, clazz, new SyncToAsyncProcedure<T>(
\r
5365 public <T> void forPossibleAdapted(Resource resource, Class<T> clazz,
\r
5366 Procedure<T> procedure) {
\r
5367 forPossibleAdapted(resource, clazz, new NoneToAsyncProcedure<T>(
\r
5372 public <T> void forPossibleUniqueAdapted(Resource resource, Class<T> clazz,
\r
5373 AsyncListener<T> listener) {
\r
5374 asyncRequest(new PossibleUniqueAdapter<T>(resource, clazz), listener);
\r
5378 public <T> void forPossibleUniqueAdapted(Resource resource, Class<T> clazz,
\r
5379 SyncListener<T> listener) {
\r
5380 asyncRequest(new PossibleUniqueAdapter<T>(resource, clazz), listener);
\r
5384 public <T> void forPossibleUniqueAdapted(Resource resource, Class<T> clazz,
\r
5385 Listener<T> listener) {
\r
5386 asyncRequest(new PossibleUniqueAdapter<T>(resource, clazz), listener);
\r
5390 final public <T> void forPossibleUniqueAdapted(final Resource resource,
\r
5391 final Class<T> clazz, final AsyncProcedure<T> procedure) {
\r
5393 assert (resource != null);
\r
5394 assert (clazz != null);
\r
5395 assert (procedure != null);
\r
5397 final AdaptionService service = getSession().peekService(AdaptionService.class);
\r
5398 if (service == null)
\r
5399 procedure.exception(this, new ServiceException("No AdaptionService available"));
\r
5401 service.adaptNew(this, resource, clazz, true, procedure);
\r
5406 public <T> void forPossibleUniqueAdapted(Resource resource, Class<T> clazz,
\r
5407 SyncProcedure<T> procedure) {
\r
5408 forPossibleUniqueAdapted(resource, clazz, new SyncToAsyncProcedure<T>(
\r
5413 public <T> void forPossibleUniqueAdapted(Resource resource, Class<T> clazz,
\r
5414 Procedure<T> procedure) {
\r
5415 forPossibleUniqueAdapted(resource, clazz, new NoneToAsyncProcedure<T>(
\r
5420 * Implementation of the interface AsyncRequestProcessor
\r
5424 final public Session getSession() {
\r
5425 return processor.getSession();
\r
5429 // final public Builtins getBuiltins() {
\r
5430 // return processor.getSession().getBuiltins();
\r
5434 public <T> void asyncRequest(final Read<T> request) {
\r
5436 asyncRequest(request, new AsyncProcedure<T>() {
\r
5439 public void execute(AsyncReadGraph graph, T result) {
\r
5443 public void exception(AsyncReadGraph graph, Throwable t) {
\r
5444 Logger.defaultLogError(t);
\r
5448 public String toString() {
\r
5449 return "asyncRequest(Read) -> " + request;
\r
5457 public <T> void asyncRequest(Read<T> request, AsyncListener<T> procedure) {
\r
5458 asyncRequest(request, (AsyncProcedure<T>) procedure);
\r
5462 public <T> void asyncRequest(Read<T> request,
\r
5463 final SyncListener<T> procedure) {
\r
5464 asyncRequest(request, new SyncToAsyncListener<T>(procedure));
\r
5468 public <T> void asyncRequest(Read<T> request, final Listener<T> procedure) {
\r
5469 asyncRequest(request, new NoneToAsyncListener<T>(procedure));
\r
5473 public <T> void asyncRequest(final Read<T> request, final AsyncProcedure<T> procedure) {
\r
5475 assert (request != null);
\r
5476 assert (procedure != null);
\r
5478 final ListenerBase listener = getListenerBase(procedure);
\r
5480 if (parent != null || listener != null) {
\r
5483 processor.queryRead(this, request, parent, procedure,
\r
5485 } catch (Throwable e) {
\r
5486 // This throwable has already been transferred to procedure at this point - do nothing about it
\r
5487 //Logger.defaultLogError("Internal error ", e);
\r
5492 // final ReadGraphImpl newGraph = newSync();
\r
5496 T result = request.perform(this);
\r
5499 procedure.execute(this, result);
\r
5500 } catch (Throwable t) {
\r
5501 Logger.defaultLogError(t);
\r
5504 } catch (Throwable t) {
\r
5507 procedure.exception(this, t);
\r
5508 } catch (Throwable t2) {
\r
5509 Logger.defaultLogError(t2);
\r
5520 public static ReadGraphImpl createAsync(QueryProcessor support) {
\r
5521 return new ReadGraphImpl(null, support);
\r
5524 public static ReadGraphImpl forRecompute(CacheEntry entry, QueryProcessor support) {
\r
5525 return new ReadGraphImpl(entry, support);
\r
5529 public <T> void asyncRequest(Read<T> request, SyncProcedure<T> procedure) {
\r
5530 asyncRequest(request, new SyncToAsyncProcedure<T>(procedure));
\r
5534 public <T> void asyncRequest(Read<T> request, final Procedure<T> procedure) {
\r
5535 asyncRequest(request, new NoneToAsyncProcedure<T>(procedure));
\r
5539 final public <T> void asyncRequest(final AsyncRead<T> request) {
\r
5541 assert (request != null);
\r
5543 asyncRequest(request, new AsyncProcedure<T>() {
\r
5546 public void execute(AsyncReadGraph graph, T result) {
\r
5550 public void exception(AsyncReadGraph graph, Throwable t) {
\r
5551 Logger.defaultLogError(t);
\r
5555 public String toString() {
\r
5556 return "asyncRequest(AsyncRead) -> " + request;
\r
5564 public <T> void asyncRequest(AsyncRead<T> request,
\r
5565 AsyncListener<T> procedure) {
\r
5566 asyncRequest(request, (AsyncProcedure<T>) procedure);
\r
5570 final public <T> void asyncRequest(AsyncRead<T> request,
\r
5571 final SyncListener<T> procedure) {
\r
5572 asyncRequest(request, new SyncToAsyncListener<T>(procedure));
\r
5576 final public <T> void asyncRequest(AsyncRead<T> request,
\r
5577 final Listener<T> procedure) {
\r
5578 asyncRequest(request, new NoneToAsyncListener<T>(procedure));
\r
5582 final public <T> void asyncRequest(final AsyncRead<T> request,
\r
5583 final AsyncProcedure<T> procedure) {
\r
5585 assert (request != null);
\r
5586 assert (procedure != null);
\r
5588 final ListenerBase listener = getListenerBase(procedure);
\r
5590 if (parent != null || listener != null) {
\r
5592 processor.query(this, request, parent, procedure, listener);
\r
5598 request.perform(this, new CallWrappedSingleQueryProcedure4<T>(procedure, request));
\r
5600 } catch (Throwable t) {
\r
5602 if (t instanceof DatabaseException)
\r
5603 procedure.exception(this, t);
\r
5608 new DatabaseException(
\r
5609 "Unexpected exception in ReadGraph.asyncRequest(SingleAsyncRead, SingleProcedure)",
\r
5619 public <T> void asyncRequest(AsyncRead<T> request,
\r
5620 SyncProcedure<T> procedure) {
\r
5621 asyncRequest(request, new SyncToAsyncProcedure<T>(procedure));
\r
5625 final public <T> void asyncRequest(final AsyncRead<T> request,
\r
5626 final Procedure<T> procedure) {
\r
5627 asyncRequest(request, new NoneToAsyncProcedure<T>(procedure));
\r
5631 public <T> void asyncRequest(final MultiRead<T> request) {
\r
5633 assert (request != null);
\r
5635 asyncRequest(request, new AsyncMultiProcedureAdapter<T>() {
\r
5637 public void exception(AsyncReadGraph graph, Throwable t) {
\r
5638 Logger.defaultLogError(t);
\r
5642 public String toString() {
\r
5643 return "asyncRequest(MultiRead) -> " + request;
\r
5650 public <T> void asyncRequest(MultiRead<T> request,
\r
5651 AsyncMultiListener<T> procedure) {
\r
5652 asyncRequest(request, (AsyncMultiProcedure<T>) procedure);
\r
5656 public <T> void asyncRequest(MultiRead<T> request,
\r
5657 SyncMultiListener<T> procedure) {
\r
5658 asyncRequest(request, new SyncToAsyncMultiListener<T>(procedure));
\r
5662 public <T> void asyncRequest(MultiRead<T> request,
\r
5663 MultiListener<T> procedure) {
\r
5664 asyncRequest(request, new NoneToAsyncMultiListener<T>(procedure));
\r
5668 public <T> void asyncRequest(final MultiRead<T> request,
\r
5669 final AsyncMultiProcedure<T> procedure) {
\r
5671 assert (request != null);
\r
5672 assert (procedure != null);
\r
5674 final ListenerBase listener = getListenerBase(procedure);
\r
5676 if (parent != null || listener != null) {
\r
5678 // final ReadGraphImpl newGraph = newSync();
\r
5679 processor.query(this, request, parent, procedure,listener);
\r
5683 // final ReadGraphImpl newGraph = newSync();
\r
5687 request.perform(this, procedure);
\r
5689 } catch (Throwable t) {
\r
5691 procedure.exception(this, t);
\r
5700 public <T> void asyncRequest(MultiRead<T> request,
\r
5701 SyncMultiProcedure<T> procedure) {
\r
5702 asyncRequest(request, new SyncToAsyncMultiProcedure<T>(procedure));
\r
5706 public <T> void asyncRequest(MultiRead<T> request,
\r
5707 MultiProcedure<T> procedure) {
\r
5708 asyncRequest(request, new NoneToAsyncMultiProcedure<T>(procedure));
\r
5712 final public <T> void asyncRequest(final AsyncMultiRead<T> request) {
\r
5714 assert (request != null);
\r
5716 asyncRequest(request, new AsyncMultiProcedureAdapter<T>() {
\r
5718 public void exception(AsyncReadGraph graph, Throwable t) {
\r
5719 Logger.defaultLogError(t);
\r
5723 public String toString() {
\r
5724 return "asyncRequest(AsyncMultiRead) -> " + request;
\r
5731 public <T> void asyncRequest(AsyncMultiRead<T> request,
\r
5732 AsyncMultiListener<T> procedure) {
\r
5733 asyncRequest(request, (AsyncMultiProcedure<T>) procedure);
\r
5737 public <T> void asyncRequest(AsyncMultiRead<T> request,
\r
5738 SyncMultiListener<T> procedure) {
\r
5739 asyncRequest(request, new SyncToAsyncMultiListener<T>(procedure));
\r
5743 public <T> void asyncRequest(AsyncMultiRead<T> request,
\r
5744 MultiListener<T> procedure) {
\r
5745 asyncRequest(request, new NoneToAsyncMultiListener<T>(procedure));
\r
5749 final public <T> void asyncRequest(AsyncMultiRead<T> request,
\r
5750 final AsyncMultiProcedure<T> procedure) {
\r
5752 assert (request != null);
\r
5753 assert (procedure != null);
\r
5755 ListenerBase listener = getListenerBase(procedure);
\r
5757 if (parent != null || listener != null) {
\r
5759 processor.query(this, request, parent, procedure, listener);
\r
5765 request.perform(this, new AsyncMultiProcedure<T>() {
\r
5768 public void execute(AsyncReadGraph graph, T result) {
\r
5769 procedure.execute(graph, result);
\r
5773 public void finished(AsyncReadGraph graph) {
\r
5774 procedure.finished(graph);
\r
5778 public void exception(AsyncReadGraph graph, Throwable t) {
\r
5779 procedure.exception(graph, t);
\r
5783 public String toString() {
\r
5784 return "asyncRequest(AsyncMultiRead) -> " + procedure;
\r
5789 } catch (Throwable t) {
\r
5791 procedure.exception(this, new DatabaseException(t));
\r
5799 public <T> void asyncRequest(AsyncMultiRead<T> request,
\r
5800 SyncMultiProcedure<T> procedure) {
\r
5801 asyncRequest(request, new SyncToAsyncMultiProcedure<T>(procedure));
\r
5805 final public <T> void asyncRequest(AsyncMultiRead<T> request,
\r
5806 final MultiProcedure<T> procedure) {
\r
5807 asyncRequest(request, new NoneToAsyncMultiProcedure<T>(procedure));
\r
5811 final public <T> void asyncRequest(final ExternalRead<T> request) {
\r
5813 assert (request != null);
\r
5815 asyncRequest(request, new Procedure<T>() {
\r
5818 public void execute(T result) {
\r
5822 public void exception(Throwable t) {
\r
5823 Logger.defaultLogError(t);
\r
5827 public String toString() {
\r
5828 return "asyncRequest(PrimitiveRead) -> " + request;
\r
5836 public <T> void asyncRequest(ExternalRead<T> request,
\r
5837 final Listener<T> procedure) {
\r
5838 asyncRequest(request, (Procedure<T>) procedure);
\r
5842 final public <T> void asyncRequest(final ExternalRead<T> request,
\r
5843 final Procedure<T> procedure) {
\r
5845 assert (request != null);
\r
5846 assert (procedure != null);
\r
5848 ListenerBase listener = getListenerBase(procedure);
\r
5850 if (parent != null || listener != null) {
\r
5852 processor.query(this, request, parent, procedure, listener);
\r
5858 request.register(this, new Listener<T>() {
\r
5861 public void execute(T result) {
\r
5862 procedure.execute(result);
\r
5866 public void exception(Throwable t) {
\r
5867 procedure.exception(t);
\r
5871 public String toString() {
\r
5872 return "asyncRequest(PrimitiveRead) -> " + request;
\r
5876 public boolean isDisposed() {
\r
5882 } catch (Throwable t) {
\r
5884 if (t instanceof DatabaseException)
\r
5885 procedure.exception(t);
\r
5888 .exception(new DatabaseException(
\r
5889 "Unexpected exception in ReadGraph.asyncRequest(SingleAsyncRead, SingleProcedure)",
\r
5899 public void asyncRequest(final Write request) {
\r
5901 assert (request != null);
\r
5903 getSession().asyncRequest(request);
\r
5905 // processor.asyncWrite(request);
\r
5910 public <T> void asyncRequest(final WriteResult<T> request, Procedure<T> procedure) {
\r
5911 throw new Error("Not implemented.");
\r
5915 public void asyncRequest(Write request, Callback<DatabaseException> callback) {
\r
5917 assert (request != null);
\r
5919 getSession().asyncRequest(request, callback);
\r
5924 public void asyncRequest(final DelayedWrite request) {
\r
5926 assert (request != null);
\r
5928 getSession().asyncRequest(request);
\r
5933 public <T> void asyncRequest(final DelayedWriteResult<T> request, Procedure<T> procedure) {
\r
5934 throw new Error("Not implemented.");
\r
5938 public void asyncRequest(DelayedWrite r,
\r
5939 Callback<DatabaseException> callback) {
\r
5940 throw new Error("Not implemented.");
\r
5944 public void asyncRequest(final WriteOnly request) {
\r
5946 assert (request != null);
\r
5948 getSession().asyncRequest(request);
\r
5953 public <T> void asyncRequest(final WriteOnlyResult<T> request, Procedure<T> procedure) {
\r
5954 throw new Error("Not implemented.");
\r
5958 public void asyncRequest(WriteOnly r, Callback<DatabaseException> callback) {
\r
5959 throw new Error("Not implemented.");
\r
5963 * Implementation of the interface ServiceLocator
\r
5967 public <T> T getService(Class<T> api) {
\r
5968 if(WriteSupport.class == api) {
\r
5969 if(this instanceof WriteGraphImpl) {
\r
5970 WriteGraphImpl impl = (WriteGraphImpl)this;
\r
5971 return (T)impl.writeSupport;
\r
5974 return getSession().getService(api);
\r
5978 public <T> T peekService(Class<T> api) {
\r
5979 return getSession().peekService(api);
\r
5983 public boolean hasService(Class<?> api) {
\r
5984 return getSession().hasService(api);
\r
5988 public <T> void registerService(Class<T> api, T service) {
\r
5989 getSession().registerService(api, service);
\r
5993 public boolean isImmutable(Resource resource) throws DatabaseException {
\r
5994 ResourceImpl impl = (ResourceImpl)resource;
\r
5995 return processor.isImmutable(impl.id);
\r
5999 * Internal routines
\r
6002 protected static String INTERNAL_ERROR_STRING = "Transaction aborted due to internal client error. Contact application support.";
\r
6005 * callerThread is the currently running thread state.syncThread is blocking for
\r
6006 * this execution state.syncParent is the blocking request
\r
6009 final private boolean isExternal(int thread) {
\r
6010 return thread == Integer.MIN_VALUE;
\r
6013 // final private boolean isSync(int thread) {
\r
6014 // return thread < -1 && thread > Integer.MIN_VALUE;
\r
6017 ReadGraphImpl(ReadGraphImpl graph) {
\r
6018 this(graph.parent, graph.processor);
\r
6021 ReadGraphImpl(CacheEntry parent, QueryProcessor support) {
\r
6022 // this.state = new ReadGraphState(barrier, support);
\r
6023 this.parent = parent;
\r
6024 this.processor = support;
\r
6027 ReadGraphImpl(final QueryProcessor support) {
\r
6029 // this.state = state;
\r
6030 this.processor = support;
\r
6031 this.parent = null;
\r
6035 // public static ReadGraphImpl createSync(int syncThread, Object syncParent,
\r
6036 // ReadGraphSupportImpl support) {
\r
6037 // return new ReadGraphImpl(syncThread, syncThread, syncParent, null,
\r
6038 // support, new AsyncBarrierImpl(null));
\r
6041 public static ReadGraphImpl create(QueryProcessor support) {
\r
6042 return new ReadGraphImpl(support);
\r
6045 // public ReadGraphImpl newAsync() {
\r
6047 //// if(!state.synchronizedExecution) {
\r
6050 //// return new ReadGraphImpl(false, parent, state.support, state.barrier);
\r
6054 // public ReadGraphImpl newSync() {
\r
6055 // return new ReadGraphImpl(parent, processor);
\r
6058 public ReadGraphImpl newSync(CacheEntry parentEntry) {
\r
6059 return new ReadGraphImpl(parentEntry, processor);
\r
6062 public ReadGraphImpl newRestart(ReadGraphImpl impl) {
\r
6064 WriteGraphImpl write = processor.getSession().getService(
\r
6065 WriteGraphImpl.class);
\r
6067 // if (write.callerThread != impl.callerThread)
\r
6068 // return new WriteGraphImpl(impl.callerThread, parent, state.support, write.writeSupport, write.provider, write.state.barrier);
\r
6073 // public ReadGraphImpl newSync(Object parentRequest) {
\r
6074 // return new ReadGraphImpl(callerThread, state.parent, state.support, new AsyncBarrierImpl(state.barrier));
\r
6077 // public ReadGraphImpl newSync(final int callerThread, Object parentRequest) {
\r
6078 // assert (state.syncThread == callerThread || (state.syncThread == Integer.MIN_VALUE && callerThread != Integer.MIN_VALUE));
\r
6079 // return new ReadGraphImpl(callerThread, callerThread, parentRequest,
\r
6080 // state.parent, state.support, new AsyncBarrierImpl(state.barrier));
\r
6083 // public ReadGraphImpl newSyncAsync(Object parentRequest) {
\r
6084 //// assert (callerThread < 0);
\r
6085 // return new ReadGraphImpl(callerThread, state.syncThread, parentRequest,
\r
6086 // state.parent, state.support, new AsyncBarrierImpl(state.barrier));
\r
6089 // public ReadGraphImpl newSyncAsync(final int callerThread,
\r
6090 // Object parentRequest) {
\r
6091 //// assert (callerThread < 0);
\r
6092 // // assert(state.syncThread == callerThread || (state.syncThread == Integer.MIN_VALUE
\r
6093 // // && callerThread != Integer.MIN_VALUE) );
\r
6094 // return new ReadGraphImpl(callerThread, callerThread, parentRequest,
\r
6095 // state.parent, state.support, new AsyncBarrierImpl(state.barrier));
\r
6098 public ReadGraphImpl withAsyncParent(CacheEntry parent) {
\r
6099 return new ReadGraphImpl(parent, processor);
\r
6102 public ReadGraphImpl withParent(CacheEntry parent) {
\r
6103 if(parent == this.parent) return this;
\r
6104 else return new ReadGraphImpl(parent, processor);
\r
6107 final private ListenerBase getListenerBase(final Object procedure) {
\r
6108 if (procedure instanceof ListenerBase)
\r
6109 return (ListenerBase) procedure;
\r
6114 public <T> void waitAsyncProcedure(AsyncMultiReadProcedure<T> procedure) {
\r
6116 assert(procedure.done());
\r
6118 // while (!procedure.done()) {
\r
6120 // boolean executed = processor.resumeTasks(callerThread, null, null);
\r
6121 // if (!executed) {
\r
6123 // Thread.sleep(1);
\r
6124 // // sema.tryAcquire(1, TimeUnit.MILLISECONDS);
\r
6125 // } catch (InterruptedException e) {
\r
6126 // e.printStackTrace();
\r
6134 public <T> void waitAsyncProcedure(AsyncReadProcedure<T> procedure) {
\r
6136 assert(procedure.done());
\r
6138 // while (!procedure.done()) {
\r
6140 // boolean executed = processor.processor.resume(this);
\r
6141 // if (!executed) {
\r
6143 // Thread.sleep(1);
\r
6144 // // sema.tryAcquire(1, TimeUnit.MILLISECONDS);
\r
6145 // } catch (InterruptedException e) {
\r
6146 // e.printStackTrace();
\r
6154 // public void waitAsync(Object request) {
\r
6156 // state.barrier.waitBarrier(request, this);
\r
6157 // } catch (Throwable t) {
\r
6158 // t.printStackTrace();
\r
6159 // processor.scanPending();
\r
6160 // processor.querySupport.checkTasks();
\r
6161 // throw new RuntimeDatabaseException(t);
\r
6165 // public void restart() {
\r
6166 // state.barrier.restart();
\r
6169 public boolean resumeTasks() {
\r
6170 return processor.resumeTasks(this);
\r
6173 Class<?> singleClass(Set<Resource> types) {
\r
6174 Class<?> result = null;
\r
6175 for (Resource type : types) {
\r
6176 Class<?> clazz = processor.getBuiltinValue(type);
\r
6177 if (clazz != null) {
\r
6178 if (result != null)
\r
6187 private String debugString(Resource r) {
\r
6188 String name = null;
\r
6190 name = getPossibleRelatedValue(r, processor.getL0(this).HasName);
\r
6191 } catch (ManyObjectsForFunctionalRelationException e) {
\r
6192 Logger.defaultLogError(e);
\r
6193 } catch (ServiceException e) {
\r
6194 Logger.defaultLogError(e);
\r
6196 return "[" + name + " - " + r + "]";
\r
6200 public String toString() {
\r
6201 return "ReadGraphImpl[thread=" + Thread.currentThread() + "]";
\r
6205 final public int thread() {
\r
6209 static class MultiTripleIntProcedure implements TripleIntProcedure {
\r
6211 final private AsyncMultiProcedure<Statement> procedure;
\r
6212 final private ReadGraphImpl impl;
\r
6213 final private QuerySupport support;
\r
6215 public MultiTripleIntProcedure(AsyncMultiProcedure<Statement> procedure, ReadGraphImpl impl, QuerySupport support) {
\r
6216 this.procedure = procedure;
\r
6218 this.support = support;
\r
6222 public void execute(ReadGraphImpl graph, int s, int p, int o) {
\r
6224 procedure.execute(graph, support.getStatement(s, p, o));
\r
6225 } catch (Throwable t2) {
\r
6226 Logger.defaultLogError(t2);
\r
6231 public void finished(ReadGraphImpl graph) {
\r
6233 procedure.finished(graph);
\r
6234 // impl.state.barrier.dec("ReadGraphSupportImpl.516");
\r
6235 } catch (Throwable t2) {
\r
6236 Logger.defaultLogError(t2);
\r
6241 public void exception(ReadGraphImpl graph, Throwable t) {
\r
6243 procedure.exception(graph, t);
\r
6244 } catch (Throwable t2) {
\r
6245 Logger.defaultLogError(t2);
\r
6247 // impl.state.barrier.dec("ReadGraphSupportImpl.516");
\r
6251 public String toString() {
\r
6252 return "forEachObject with " + procedure;
\r
6257 // private AsyncMultiProcedure<Resource> cacheKey = null;
\r
6258 // private MultiIntProcedure cacheResult = null;
\r
6260 // final IntProcedure forMultiProcedure(final AsyncMultiProcedure<Resource> procedure) {
\r
6262 // if(procedure == cacheKey) return cacheResult;
\r
6264 // cacheResult = new MultiIntProcedure(procedure, this, processor.support);
\r
6265 // cacheKey = procedure;
\r
6267 // return cacheResult;
\r
6271 // private AsyncMultiProcedure<Statement> cacheKey2 = null;
\r
6272 // private MultiTripleIntProcedure cacheResult2 = null;
\r
6274 // final synchronized TripleIntProcedure forMultiProcedure(final AsyncMultiProcedure<Statement> procedure) {
\r
6276 // if(procedure == cacheKey2) return cacheResult2;
\r
6278 // cacheResult2 = new MultiTripleIntProcedure(procedure, this, processor.support);
\r
6279 // cacheKey2 = procedure;
\r
6281 // return cacheResult2;
\r
6286 public Datatype getDataType(Resource subject) throws DatabaseException {
\r
6287 for(Resource dataTypeResource : getObjects(subject, processor.getL0(this).HasDataType))
\r
6288 return getValue(dataTypeResource, Bindings.getBindingUnchecked(Datatype.class));
\r
6289 throw new DoesNotContainValueException("The literal has no data type.");
\r
6292 protected <T extends Accessor> T getAccessor4File(Resource subject)
\r
6293 throws DatabaseException {
\r
6296 byte[] bytes = processor.support.getValue(g, subject);
\r
6297 if (null == bytes)
\r
6300 BinaryVariant va = (BinaryVariant) Accessors.getAccessor(bytes, Datatypes.VARIANT);
\r
6301 Accessor ca = va.getContentAccessor();
\r
6303 } catch (AccessorConstructionException e) {
\r
6304 throw new DatabaseException(e);
\r
6308 if (null == bytes)
\r
6310 Binding datatype_binding = Bindings.getBindingUnchecked(DataType.class);
\r
6311 Serializer datatype_serializer = datatype_binding.serializer();
\r
6312 DataType datatype;
\r
6314 BinaryMemory in = new BinaryMemory(ByteBuffer.wrap(bytes));
\r
6315 datatype = (DataType)datatype_serializer.deserialize(in);
\r
6316 Binding data_binding = Bindings.getBinding(datatype);
\r
6317 Serializer data_serializer = data_binding.serializer(BinarySerializationFormat.INSTANCE);
\r
6318 Object o = data_serializer.deserialize(in);
\r
6320 return (T)Accessors.getAccessor(data_binding, o);
\r
6321 } catch(AccessorConstructionException e) {
\r
6324 } catch (Exception e) {
\r
6325 throw new DatabaseException(e);
\r
6328 @SuppressWarnings("unchecked")
\r
6330 public <T extends Accessor> T getAccessor(Resource subject) throws DatabaseException {
\r
6331 RandomAccessBinary rab = getRandomAccessBinary(subject);
\r
6333 return (T)Accessors.getAccessor(rab, getDataType(subject));
\r
6334 } catch(AccessorConstructionException e) {
\r
6335 throw new DatabaseException(e);
\r
6338 @SuppressWarnings("unchecked")
\r
6339 protected <T extends Accessor> T createAccessor(Resource resource, Datatype datatype, Object intialValue)
\r
6340 throws DatabaseException {
\r
6341 RandomAccessBinary rab = createRandomAccessBinary(resource, datatype, intialValue);
\r
6343 return (T)Accessors.getAccessor(rab, datatype);
\r
6344 } catch(AccessorConstructionException e) {
\r
6345 throw new DatabaseException(e);
\r
6349 public RandomAccessBinary getRandomAccessBinary(Resource subject) throws DatabaseException {
\r
6350 RandomAccessValueSupport ravs = getSession().getService(RandomAccessValueSupport.class);
\r
6351 ResourceData rd = ravs.get(subject);
\r
6355 ExternalValueSupport evs = getService(ExternalValueSupport.class);
\r
6356 long size = evs.getValueSize(this, subject); // Throws DatabaseException if no old external value.
\r
6358 File platform = Platform.getLocation().toFile();
\r
6359 File tempFiles = new File(platform, "tempFiles");
\r
6360 File dbDir = new File(tempFiles, "db");
\r
6362 File file = new File(dbDir, "ResourceFile" + subject.getResourceId());
\r
6363 rd = new ResourceData(new BinaryFile(file), true); // Old external value.
\r
6364 final int N = 1<<20;
\r
6367 while (left > 0) {
\r
6368 int length = N < left ? N : (int)left;
\r
6369 byte[] bytes = evs.readValue(this, subject, offset, length);
\r
6370 offset += bytes.length;
\r
6371 left -= bytes.length;
\r
6372 rd.binaryFile.write(bytes);
\r
6374 ravs.put(subject, rd);
\r
6376 } catch (Exception e) {
\r
6377 throw new DatabaseException("Resource " + subject + " have value but there was problem with accessing value data.", e);
\r
6379 } catch (Exception e) {
\r
6380 if(Development.DEVELOPMENT) {
\r
6381 if(Development.<Boolean>getProperty(DevelopmentKeys.WRITEGRAPH_EXCEPTION_STACKTRACES, Bindings.BOOLEAN)) {
\r
6382 e.printStackTrace();
\r
6386 Datatype datatype = getDataType(subject);
\r
6387 Object value = getPossibleValue(subject, Bindings.getBinding(datatype));
\r
6388 return createRandomAccessBinary(subject, datatype, value);
\r
6390 public RandomAccessBinary createRandomAccessBinary(Resource resource, Datatype datatype, Object initialValue)
\r
6391 throws DatabaseException {
\r
6392 RandomAccessValueSupport ravs = getSession().getService(RandomAccessValueSupport.class);
\r
6394 File platform = Platform.getLocation().toFile();
\r
6395 File tempFiles = new File(platform, "tempFiles");
\r
6396 File dbDir = new File(tempFiles, "db");
\r
6398 File file = new File(dbDir, "ResourceFile" + resource.getResourceId());
\r
6399 ResourceData rd = new ResourceData(new BinaryFile(file), false);
\r
6400 Binding binding = Bindings.getBinding(datatype);
\r
6401 if (null == initialValue) {
\r
6402 initialValue = binding.createDefault();
\r
6404 Serializer serializer = binding.serializer();
\r
6405 byte[] bytes = serializer.serialize(initialValue);
\r
6406 rd.binaryFile.write(bytes);
\r
6407 ravs.put(resource, rd);
\r
6409 } catch (Exception e) {
\r
6410 if (e instanceof DatabaseException)
\r
6411 throw (DatabaseException)e;
\r
6413 throw new DatabaseException(e);
\r
6417 // static class ExternalValueRequest<T> extends ResourceRead<T> {
\r
6419 // public ExternalValueRequest(Resource resource) {
\r
6420 // super(resource);
\r
6423 // @SuppressWarnings("unchecked")
\r
6425 // public T perform(ReadGraph graph) throws DatabaseException {
\r
6428 // String uri = graph.getURI(resource);
\r
6429 // if(Layer0.URIs.Functions_functionApplication.equals(uri)) return (T)functionApplication;
\r
6431 // return (T)ReflectionUtils.getValue(uri).getValue();
\r
6433 // } catch(ValueNotFoundException e) {
\r
6434 // throw new DatabaseException("Couldn't convert to external value (r=" + resource + ")", e);
\r
6435 // } catch(ClassCastException e) {
\r
6436 // throw new DatabaseException("Couldn't convert to external value (r=" + resource + ")", e);
\r
6442 @SuppressWarnings("unchecked")
\r
6444 public <T> T getValue2(Resource r, Object context) throws DatabaseException {
\r
6445 Layer0 L0 = processor.getL0(this);
\r
6446 Set<Resource> types = getTypes(r);
\r
6448 if(types.contains(L0.Literal)) {
\r
6449 if(isImmutable(r)) {
\r
6450 return syncRequest(new ValueImplied<T>(r));
\r
6452 return getValue(r);
\r
6455 else if(types.contains(L0.ExternalValue)) {
\r
6456 return (T)syncRequest(new AdaptValue(r), TransientCacheListener.<Object>instance());
\r
6460 Function3<ReadGraph,Resource,Object,T> function = requestValueFunction(r);
\r
6461 if(function == null) throw new DoesNotContainValueException("Couldn't convert to a value function " + r);
\r
6463 return function.apply(this, r, context);
\r
6464 } catch(RuntimeException e) {
\r
6465 DatabaseException dte = findPossibleRootException(e);
\r
6466 if(dte != null) throw dte;
\r
6467 else throw new DatabaseException(e);
\r
6473 @SuppressWarnings("unchecked")
\r
6475 public Variant getVariantValue2(Resource r, Object context) throws DatabaseException {
\r
6476 Layer0 L0 = processor.getL0(this);
\r
6477 Set<Resource> types = getTypes(r);
\r
6479 if(types.contains(L0.Literal)) {
\r
6480 if(isImmutable(r)) {
\r
6481 return syncRequest(new VariantValueImplied(r));
\r
6483 return getVariantValue(r);
\r
6486 else if(types.contains(L0.ExternalValue)) {
\r
6487 Object value = syncRequest(new AdaptValue(r), TransientCacheListener.<Object>instance());
\r
6489 return new Variant(Bindings.OBJECT.getContentBinding(value), value);
\r
6490 } catch ( org.simantics.databoard.binding.error.BindingException e ) {
\r
6491 throw new BindingException( "No binding found for class " + value.getClass().getName(), e );
\r
6496 Function3<ReadGraph,Resource,Object,Object> function = requestValueFunction(r);
\r
6497 if(function == null) throw new DoesNotContainValueException("Couldn't convert to a value function " + r);
\r
6499 Object value = function.apply(this, r, context);
\r
6501 return new Variant(Bindings.OBJECT.getContentBinding(value), value);
\r
6502 } catch ( org.simantics.databoard.binding.error.BindingException e ) {
\r
6503 throw new BindingException( "No binding found for class " + value.getClass().getName(), e );
\r
6505 } catch(RuntimeException e) {
\r
6506 DatabaseException dte = findPossibleRootException(e);
\r
6507 if(dte != null) throw dte;
\r
6508 else throw new DatabaseException(e);
\r
6514 public <T> T getPossibleValue2(Resource subject, Object context) throws DatabaseException {
\r
6516 return getValue2(subject, context);
\r
6517 } catch (DatabaseException e) {
\r
6522 static class PossibleConverterFunction<T> extends ResourceRead<Function3<ReadGraph,Resource,Object,T>> {
\r
6524 public PossibleConverterFunction(Resource resource) {
\r
6529 public Function3<ReadGraph,Resource,Object,T> perform(ReadGraph graph) throws DatabaseException {
\r
6530 return compute(graph, resource);
\r
6533 @SuppressWarnings("unchecked")
\r
6534 public static <T> Function3<ReadGraph,Resource,Object,T> compute(ReadGraph graph, Resource resource) throws DatabaseException {
\r
6535 Layer0 L0 = Layer0.getInstance(graph);
\r
6536 for(Resource converter : graph.getObjects(resource, L0.ConvertsToValueWith)) {
\r
6538 if(L0.Functions_functionApplication.equals(converter)) {
\r
6539 return (Function3<ReadGraph,Resource,Object,T>)graph.syncRequest(new AdaptValue(resource));
\r
6541 return graph.getValue2(converter, resource);
\r
6543 } catch(RuntimeException e) {
\r
6544 DatabaseException dte = findPossibleRootException(e);
\r
6545 if(dte != null) throw dte;
\r
6546 else throw new DatabaseException(e);
\r
6554 <T> Function3<ReadGraph,Resource,Object,T> requestValueFunction(Resource r) throws DatabaseException {
\r
6555 if(isImmutable(r))
\r
6556 return syncRequest(new PossibleConverterFunction<T>(r), TransientCacheAsyncListener.<Function3<ReadGraph,Resource,Object,T>>instance());
\r
6558 return syncRequest(new PossibleConverterFunction<T>(r));
\r
6562 * Get a value associated with a graph {@link Resource}, using a possible context object and
\r
6563 * a desired value binding. The following methods are tried in order to retreive the value:
\r
6565 * <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>
\r
6566 * <li>If the resource is a {@code L0.ExternalValue}, the value is acquired using
\r
6567 * {@link ReflectionUtils#getValue(String)}.</li>
\r
6568 * <li>If the resource is associated with a suitable value converter with relation {@code L0.ConvertsToValueWith}
\r
6569 * (see {@link #requestValueFunction(Resource)}), the value function is called with the graph, the resource
\r
6570 * and the context object.</li>
\r
6573 * @param r A graph resource with which the value is associated
\r
6574 * @param context A context object that is used for acquiring the value (only applied in case 3)
\r
6575 * @param binding A binding for the value type (only applied in case 1)
\r
6576 * @return The value of the graph node.
\r
6577 * @throws DoesNotContainValueException No value is associated with the graph node.
\r
6578 * @throws DatabaseException Other errors, such as an error in casting the value to the return type or
\r
6579 * a runtime error in the value function.
\r
6581 @SuppressWarnings("unchecked")
\r
6583 public <T> T getValue2(Resource r, Object context, Binding binding) throws DatabaseException {
\r
6584 if (binding instanceof ObjectVariantBinding)
\r
6585 return getValue2(r, context);
\r
6587 Layer0 L0 = processor.getL0(this);
\r
6588 Set<Resource> types = getTypes(r);
\r
6589 if(types.contains(L0.Literal)) {
\r
6590 if(isImmutable(r)) {
\r
6591 return syncRequest(new Value<T>(r, binding));
\r
6593 return getValue(r, binding);
\r
6595 } else if(types.contains(L0.ExternalValue)) {
\r
6597 return (T)ReflectionUtils.getValue(getURI(r)).getValue();
\r
6598 } catch(ValueNotFoundException e) {
\r
6599 throw new DatabaseException(e);
\r
6600 } catch(ClassCastException e) {
\r
6601 throw new DatabaseException(e);
\r
6605 Function3<ReadGraph,Resource,Object,T> function = requestValueFunction(r);
\r
6606 if(function == null) throw new DoesNotContainValueException("Couldn't convert to a value function.");
\r
6608 Object value = function.apply(this, r, context);
\r
6609 if(binding.isInstance(value)) return (T)value;
\r
6610 Binding srcBinding = Bindings.OBJECT.getContentBinding(value);
\r
6611 return (T)Bindings.adapt(value, srcBinding, binding);
\r
6612 } catch(RuntimeException e) {
\r
6613 DatabaseException dte = findPossibleRootException(e);
\r
6614 if(dte != null) throw dte;
\r
6615 else throw new DatabaseException(e);
\r
6616 } catch (AdaptException e) {
\r
6617 throw new DatabaseException(e);
\r
6618 } catch (org.simantics.databoard.binding.error.BindingException e) {
\r
6619 throw new DatabaseException(e);
\r
6625 public <T> T getPossibleValue2(Resource subject, Object context, Binding binding) throws DatabaseException {
\r
6627 return getValue2(subject, context, binding);
\r
6628 } catch (DatabaseException e) {
\r
6633 private static DatabaseException findPossibleRootException(Throwable t) {
\r
6634 if(t == null) return null;
\r
6635 if(t instanceof DatabaseException) return (DatabaseException)t;
\r
6636 if(t instanceof RuntimeException || t instanceof InvocationTargetException) {
\r
6637 return findPossibleRootException(t.getCause());
\r
6643 public <T> T getRelatedValue2(Resource subject, Resource relation) throws DatabaseException {
\r
6644 return getRelatedValue2(subject, relation, subject);
\r
6648 public Variant getRelatedVariantValue2(Resource subject, Resource relation) throws DatabaseException {
\r
6649 return getRelatedVariantValue2(subject, relation, subject);
\r
6653 public <T> T getPossibleRelatedValue2(Resource subject, Resource relation) throws DatabaseException {
\r
6655 Resource object = getPossibleObject(subject, relation);
\r
6656 if(object == null) return null;
\r
6657 else return getValue2(object, subject);
\r
6658 } catch (DatabaseException e) {
\r
6664 public <T> T getRelatedValue2(Resource subject, Resource relation, Object context) throws DatabaseException {
\r
6665 if(Development.DEVELOPMENT) {
\r
6666 String error = L0Validations.checkValueType(this, subject, relation);
\r
6667 if(error != null) {
\r
6668 Logger.defaultLogError(new ValidationException(error));
\r
6669 //throw new ValidationException(error);
\r
6670 new ValidationException(error).printStackTrace();
\r
6673 return getValue2(getSingleObject(subject, relation), context);
\r
6677 public Variant getRelatedVariantValue2(Resource subject, Resource relation, Object context) throws DatabaseException {
\r
6678 if(Development.DEVELOPMENT) {
\r
6679 String error = L0Validations.checkValueType(this, subject, relation);
\r
6680 if(error != null) {
\r
6681 Logger.defaultLogError(new ValidationException(error));
\r
6682 //throw new ValidationException(error);
\r
6683 new ValidationException(error).printStackTrace();
\r
6686 return getVariantValue2(getSingleObject(subject, relation), context);
\r
6690 public <T> T getPossibleRelatedValue2(Resource subject, Resource relation, Object context) throws DatabaseException {
\r
6692 Resource object = getPossibleObject(subject, relation);
\r
6693 if(object == null) return null;
\r
6694 else return getValue2(object, context);
\r
6695 } catch (DatabaseException e) {
\r
6701 public <T> T getRelatedValue2(Resource subject, Resource relation, Binding binding) throws DatabaseException {
\r
6702 return getRelatedValue2(subject, relation, subject, binding);
\r
6706 public <T> T getPossibleRelatedValue2(Resource subject, Resource relation, Binding binding) throws DatabaseException {
\r
6708 Resource object = getPossibleObject(subject, relation);
\r
6709 if(object == null) return null;
\r
6710 return getValue2(object, subject, binding);
\r
6711 } catch (DatabaseException e) {
\r
6717 public <T> T getRelatedValue2(Resource subject, Resource relation, Object context, Binding binding) throws DatabaseException {
\r
6718 return getValue2(getSingleObject(subject, relation), context, binding);
\r
6722 public <T> T getPossibleRelatedValue2(Resource subject, Resource relation, Object context, Binding binding) throws DatabaseException {
\r
6724 Resource object = getPossibleObject(subject, relation);
\r
6725 if(object == null) return null;
\r
6726 else return getValue2(object, context, binding);
\r
6727 } catch (DatabaseException e) {
\r
6733 public Type getRelatedValueType(Resource subject, Resource relation) throws DatabaseException {
\r
6734 Layer0 L0 = processor.getL0(this);
\r
6735 Resource property = getSingleObject(subject, relation);
\r
6736 String typeText = (String)getRelatedValue(property, L0.HasValueType, Bindings.STRING);
\r
6738 return org.simantics.scl.compiler.types.Types.parseType(typeText);
\r
6739 } catch (SCLTypeParseException e) {
\r
6740 throw new DatabaseException(e);
\r
6745 public boolean setSynchronous(boolean value) {
\r
6746 boolean old = processor.synch;
\r
6747 processor.synch = value;
\r
6752 public boolean getSynchronous() {
\r
6753 return processor.synch;
\r
6756 public void ensureLoaded(int resource) {
\r
6757 processor.querySupport.ensureLoaded(this, resource);
\r
6760 public void ensureLoaded(int resource, int predicate) {
\r
6761 processor.querySupport.ensureLoaded(this, resource, predicate);
\r
6764 public byte[] getValue(int resource) {
\r
6765 return processor.querySupport.getValue(this, resource);
\r
6768 public int thread(int resource) {
\r
6769 return (resource >>> 16) & processor.THREAD_MASK;
\r
6772 public int thread(Resource resource) {
\r
6773 return (((ResourceImpl)resource).id >>> 16) & processor.THREAD_MASK;
\r
6776 public ResourceSupport getResourceSupport() {
\r
6777 return processor.getResourceSupport();
\r
6781 public Object getModificationCounter() {
\r
6782 return processor.getSession().getModificationCounter();
\r