import org.simantics.databoard.util.binary.RandomAccessBinary;
import org.simantics.db.AsyncReadGraph;
import org.simantics.db.DevelopmentKeys;
+import org.simantics.db.ExternalValue;
import org.simantics.db.ExternalValueSupport;
import org.simantics.db.ReadGraph;
import org.simantics.db.RelationContext;
import org.simantics.db.common.primitiverequest.Value;
import org.simantics.db.common.primitiverequest.ValueImplied;
import org.simantics.db.common.primitiverequest.VariantValueImplied;
+import org.simantics.db.common.procedure.BlockingAsyncProcedure;
import org.simantics.db.common.procedure.adapter.AsyncMultiProcedureAdapter;
import org.simantics.db.common.procedure.adapter.ProcedureAdapter;
import org.simantics.db.common.procedure.adapter.TransientCacheAsyncListener;
import org.simantics.db.common.procedure.wrapper.SyncToAsyncSetProcedure;
import org.simantics.db.common.request.AdaptValue;
import org.simantics.db.common.request.ResourceRead;
+import org.simantics.db.common.utils.Functions;
import org.simantics.db.common.utils.Logger;
import org.simantics.db.common.utils.NameUtils;
import org.simantics.db.common.validation.L0Validations;
import org.simantics.db.impl.internal.RandomAccessValueSupport;
import org.simantics.db.impl.internal.ResourceData;
import org.simantics.db.impl.procedure.CallWrappedSingleQueryProcedure4;
+import org.simantics.db.impl.procedure.InternalProcedure;
import org.simantics.db.impl.procedure.ResultCallWrappedQueryProcedure4;
import org.simantics.db.impl.procedure.ResultCallWrappedSingleQueryProcedure4;
import org.simantics.db.impl.query.CacheEntry;
+import org.simantics.db.impl.query.QueryCache;
+import org.simantics.db.impl.query.QueryCacheBase;
import org.simantics.db.impl.query.QueryProcessor;
import org.simantics.db.impl.query.QuerySupport;
import org.simantics.db.impl.query.TripleIntProcedure;
+import org.simantics.db.impl.query.QueryProcessor.SessionTask;
import org.simantics.db.impl.support.ResourceSupport;
import org.simantics.db.procedure.AsyncListener;
import org.simantics.db.procedure.AsyncMultiListener;
import org.simantics.scl.compiler.types.exceptions.SCLTypeParseException;
import org.simantics.scl.reflection.ReflectionUtils;
import org.simantics.scl.reflection.ValueNotFoundException;
+import org.simantics.scl.runtime.function.Function1;
import org.simantics.scl.runtime.function.Function3;
import org.simantics.utils.DataContainer;
import org.simantics.utils.Development;
try {
- return syncRequest(new org.simantics.db.common.primitiverequest.Resource(
- id));
+// assert (id != null);
+// assert (procedure != null);
+//
+// processor.forResource(this, id, procedure);
+//
+//// return syncRequest(new org.simantics.db.common.primitiverequest.Resource(
+//// id));
+
+ Integer rid = QueryCache.resultURIToResource(this, id, parent, null);
+ if(rid == 0) throw new ResourceNotFoundException(id);
+ return processor.querySupport.getResource(rid);
} catch (ResourceNotFoundException e) {
try {
- return syncRequest(new org.simantics.db.common.primitiverequest.Resource(
- id));
+ return getResource(id);
+
+// return syncRequest(new org.simantics.db.common.primitiverequest.Resource(
+// id));
} catch (ResourceNotFoundException e) {
assert (request != null);
- return processor.query(this, request, parent, null, null);
+ return QueryCache.resultReadEntry(this, request, parent, null, null);
+
+ //return processor.query(this, request, parent, null, null);
// if (parent != null) {
//
ListenerBase listener = procedure != null ? getListenerBase(procedure) : null;
- return processor.query(this, request, parent, procedure, listener);
+ return QueryCache.resultReadEntry(this, request, parent, listener, procedure);
+
+// return processor.query(this, request, parent, procedure, listener);
// if (parent != null || listener != null) {
throw (DatabaseException) exception;
else
throw new DatabaseException(
- "Unexpected exception in ReadGraph.syncRequest(AsyncMultiRead)",
+ "Unexpected exception in ReadGraph.syncRequest(AsyncRead)",
exception);
}
}
throws DatabaseException {
assert (request != null);
- AsyncReadProcedure<T> procedure = new AsyncReadProcedure<T>();
- syncRequest(request, procedure);
- procedure.checkAndThrow();
- return procedure.result;
+// AsyncReadProcedure<T> procedure = new AsyncReadProcedure<T>();
+ BlockingAsyncProcedure<T> ap = new BlockingAsyncProcedure<>(null, request);
+ syncRequest(request, ap);
+ return ap.get();
+// procedure.checkAndThrow();
+// return procedure.result;
// return syncRequest(request, new AsyncProcedureAdapter<T>());
ListenerBase listener = getListenerBase(procedure);
- final ResultCallWrappedSingleQueryProcedure4<T> wrapper = new ResultCallWrappedSingleQueryProcedure4<T>(
- procedure, request);
+ BlockingAsyncProcedure<T> ap = new BlockingAsyncProcedure<>(procedure, request);
+
+// final ResultCallWrappedSingleQueryProcedure4<T> wrapper = new ResultCallWrappedSingleQueryProcedure4<T>(
+// procedure, request);
+
+ QueryCache.runnerAsyncReadEntry(this, request, parent, listener, ap, true);
+
+ //processor.query(this, request, parent, wrapper, listener);
- processor.query(this, request, parent, wrapper, listener);
+ return ap.get();
- return wrapper.getResult();
+// return wrapper.getResult();
// if (parent != null || listener != null || ((request.getFlags() & RequestFlags.SCHEDULE) > 0)) {
//
assert (request != null);
ListenerBase listener = getListenerBase(procedure);
+ assert(listener == null);
- final ResultCallWrappedSingleQueryProcedure4<T> wrapper = new ResultCallWrappedSingleQueryProcedure4<T>(
- procedure, request);
-
- processor.query(this, request, parent, wrapper, listener);
+ BlockingAsyncProcedure<T> ap = new BlockingAsyncProcedure<>(procedure, request);
+
+// final ResultCallWrappedSingleQueryProcedure4<T> wrapper = new ResultCallWrappedSingleQueryProcedure4<T>(
+// procedure, request);
-// if (parent != null || listener != null || ((request.getFlags() & RequestFlags.SCHEDULE) > 0)) {
-//
-//
-// } else {
-//
-// try {
-//
-//// final ReadGraphImpl newGraph = newSync();
-// processor.tryQuery(this, request, procedure);
-//// newGraph.waitAsync(null);
-// waitAsyncProcedure(procedure);
-//
-// } catch (Throwable t) {
-// if(Development.DEVELOPMENT) {
-// if(Development.<Boolean>getProperty(DevelopmentKeys.WRITEGRAPH_EXCEPTION_STACKTRACES, Bindings.BOOLEAN)) {
-// t.printStackTrace();
-// }
-// }
-// procedure.exception(this, t);
-// waitAsyncProcedure(procedure);
-// }
-//
-// }
+ QueryCache.runnerAsyncReadEntry(this, request, parent, listener, ap, true);
+
+ ap.get();
}
final public <T> T syncRequest(final ExternalRead<T> request,
final Procedure<T> procedure) throws DatabaseException {
- assert (request != null);
+ assert (request != null);
- ListenerBase listener = getListenerBase(procedure);
-
- final DataContainer<Throwable> exception = new DataContainer<Throwable>();
- final DataContainer<T> result = new DataContainer<T>();
-
- processor.query(this, request, parent, new Procedure<T>() {
-
- @Override
- public void exception(Throwable throwable) {
- exception.set(throwable);
- procedure.exception(throwable);
- }
+ ListenerBase listener = procedure != null ? getListenerBase(procedure) : null;
+ return QueryCache.resultExternalReadEntry(this, request, parent, listener, procedure);
- @Override
- public void execute(T t) {
- result.set(t);
- procedure.execute(t);
- }
-
- }, listener);
+//
+// ListenerBase listener = getListenerBase(procedure);
+//
+// return QueryCache.resultExternalReadEntry(this, request, parent, listener, procedure);
+
+// assert (request != null);
+//
+// ListenerBase listener = getListenerBase(procedure);
+//
+// final DataContainer<Throwable> exception = new DataContainer<Throwable>();
+// final DataContainer<T> result = new DataContainer<T>();
+//
+// processor.query(this, request, parent, new Procedure<T>() {
+//
+// @Override
+// public void exception(Throwable throwable) {
+// exception.set(throwable);
+// procedure.exception(throwable);
+// }
+//
+// @Override
+// public void execute(T t) {
+// result.set(t);
+// procedure.execute(t);
+// }
+//
+// }, listener);
// }
//
// }
-
- Throwable t = exception.get();
- if (t != null) {
- if (t instanceof DatabaseException)
- throw (DatabaseException) t;
- else
- throw new DatabaseException(
- "Unexpected exception in ReadGraph.syncRequest(Read)",
- t);
- }
-
- return result.get();
+//
+// Throwable t = exception.get();
+// if (t != null) {
+// if (t instanceof DatabaseException)
+// throw (DatabaseException) t;
+// else
+// throw new DatabaseException(
+// "Unexpected exception in ReadGraph.syncRequest(Read)",
+// t);
+// }
+//
+// return result.get();
}
assert (request != null);
assert (procedure != null);
+
+ processor.schedule(Integer.MIN_VALUE, new SessionTask(request, processor.THREAD_MASK+1, -1) {
- final ListenerBase listener = getListenerBase(procedure);
-
- if (parent != null || listener != null) {
-
- try {
- processor.query(this, request, parent, procedure,listener);
- } catch (DatabaseException e) {
- Logger.defaultLogError(e);
- // This throwable has already been transferred to procedure at this point - do nothing about it
- //
- }
-
- } else {
-
-// final ReadGraphImpl newGraph = newSync();
-
- try {
-
- T result = request.perform(this);
-
- try {
- procedure.execute(this, result);
- } catch (Throwable t) {
- Logger.defaultLogError(t);
- }
-
- } catch (Throwable t) {
-
+ @Override
+ public void run(int thread) {
try {
- procedure.exception(this, t);
- } catch (Throwable t2) {
- Logger.defaultLogError(t2);
+ final ListenerBase listener = getListenerBase(procedure);
+ QueryCache.runnerReadEntry(ReadGraphImpl.this, request, parent, listener, procedure, false);
+ } catch (DatabaseException e) {
+ Logger.defaultLogError(e);
}
-
- } finally {
-
}
+
+ });
- }
+
+// quer
+//
+// final ListenerBase listener = getListenerBase(procedure);
+//
+// if (parent != null || listener != null) {
+//
+// try {
+// QueryCache.runnerReadEntry(this, request, parent, listener, procedure);
+// //processor.query(this, request, parent, procedure,listener);
+// } catch (DatabaseException e) {
+// Logger.defaultLogError(e);
+// // This throwable has already been transferred to procedure at this point - do nothing about it
+// //
+// }
+//
+// } else {
+//
+//// final ReadGraphImpl newGraph = newSync();
+//
+// try {
+//
+// T result = request.perform(this);
+//
+// try {
+// procedure.execute(this, result);
+// } catch (Throwable t) {
+// Logger.defaultLogError(t);
+// }
+//
+// } catch (Throwable t) {
+//
+// try {
+// procedure.exception(this, t);
+// } catch (Throwable t2) {
+// Logger.defaultLogError(t2);
+// }
+//
+// } finally {
+//
+// }
+//
+// }
}
assert (request != null);
assert (procedure != null);
- final ListenerBase listener = getListenerBase(procedure);
+ //final ListenerBase listener = getListenerBase(procedure);
- if (parent != null || listener != null) {
+ processor.schedule(Integer.MIN_VALUE, new SessionTask(request, processor.THREAD_MASK+1, -1) {
- try {
- processor.query(this, request, parent, procedure, listener);
- } catch (DatabaseException e) {
- Logger.defaultLogError(e);
+ @Override
+ public void run(int thread) {
+ try {
+ final ListenerBase listener = getListenerBase(procedure);
+ QueryCache.runnerAsyncReadEntry(ReadGraphImpl.this, request, parent, listener, procedure, false);
+ } catch (DatabaseException e) {
+ Logger.defaultLogError(e);
+ }
}
+
+ });
- } else {
-
- try {
-
- request.perform(this, new CallWrappedSingleQueryProcedure4<T>(procedure, request));
-
- } catch (Throwable t) {
-
- if (t instanceof DatabaseException)
- procedure.exception(this, t);
- else
- procedure
- .exception(
- this,
- new DatabaseException(
- "Unexpected exception in ReadGraph.asyncRequest(SingleAsyncRead, SingleProcedure)",
- t));
+
- }
- }
+// if (parent != null || listener != null) {
+//
+// try {
+// QueryCache.runnerAsyncReadEntry(this, request, parent, listener, procedure);
+// //processor.query(this, request, parent, procedure, listener);
+// } catch (DatabaseException e) {
+// Logger.defaultLogError(e);
+// }
+//
+// } else {
+//
+// try {
+//
+// request.perform(this, new CallWrappedSingleQueryProcedure4<T>(procedure, request));
+//
+// } catch (Throwable t) {
+//
+// if (t instanceof DatabaseException)
+// procedure.exception(this, t);
+// else
+// procedure
+// .exception(
+// this,
+// new DatabaseException(
+// "Unexpected exception in ReadGraph.asyncRequest(SingleAsyncRead, SingleProcedure)",
+// t));
+//
+// }
+//
+// }
}
final public <T> void asyncRequest(final ExternalRead<T> request,
final Procedure<T> procedure) {
- assert (request != null);
- assert (procedure != null);
-
- ListenerBase listener = getListenerBase(procedure);
-
- if (parent != null || listener != null) {
-
- processor.query(this, request, parent, procedure, listener);
-
- } else {
-
- try {
+
+ assert (request != null);
+ assert (procedure != null);
- request.register(this, new Listener<T>() {
+ final ListenerBase listener = getListenerBase(procedure);
- @Override
- public void execute(T result) {
- procedure.execute(result);
- }
+ if (parent != null || listener != null) {
- @Override
- public void exception(Throwable t) {
- procedure.exception(t);
- }
+ try {
+ QueryCacheBase.resultExternalReadEntry(this, request, parent, listener, procedure);
+ //processor.query(this, request, parent, procedure,listener);
+ } catch (DatabaseException e) {
+ Logger.defaultLogError(e);
+ // This throwable has already been transferred to procedure at this point - do nothing about it
+ //
+ }
+
+ } else {
- @Override
- public String toString() {
- return "asyncRequest(PrimitiveRead) -> " + request;
- }
+ request.register(this, new Listener<T>() {
+ //
+ @Override
+ public void execute(T result) {
+ procedure.execute(result);
+ }
- @Override
- public boolean isDisposed() {
- return true;
- }
+ @Override
+ public void exception(Throwable t) {
+ procedure.exception(t);
+ }
- });
+ @Override
+ public String toString() {
+ return "asyncRequest(PrimitiveRead) -> " + request;
+ }
- } catch (Throwable t) {
+ @Override
+ public boolean isDisposed() {
+ return true;
+ }
- if (t instanceof DatabaseException)
- procedure.exception(t);
- else
- procedure
- .exception(new DatabaseException(
- "Unexpected exception in ReadGraph.asyncRequest(SingleAsyncRead, SingleProcedure)",
- t));
+ });
+
+// final ReadGraphImpl newGraph = newSync();
- }
+// try {
+//
+// T result = request.perform(this);
+//
+// try {
+// procedure.execute(this, result);
+// } catch (Throwable t) {
+// Logger.defaultLogError(t);
+// }
+//
+// } catch (Throwable t) {
+//
+// try {
+// procedure.exception(this, t);
+// } catch (Throwable t2) {
+// Logger.defaultLogError(t2);
+// }
+//
+// } finally {
+//
+// }
- }
+ }
+
+// assert (request != null);
+// assert (procedure != null);
+//
+// ListenerBase listener = getListenerBase(procedure);
+//
+// if (parent != null || listener != null) {
+//
+// processor.query(this, request, parent, procedure, listener);
+//
+// } else {
+//
+// try {
+//
+// request.register(this, new Listener<T>() {
+//
+// @Override
+// public void execute(T result) {
+// procedure.execute(result);
+// }
+//
+// @Override
+// public void exception(Throwable t) {
+// procedure.exception(t);
+// }
+//
+// @Override
+// public String toString() {
+// return "asyncRequest(PrimitiveRead) -> " + request;
+// }
+//
+// @Override
+// public boolean isDisposed() {
+// return true;
+// }
+//
+// });
+//
+// } catch (Throwable t) {
+//
+// if (t instanceof DatabaseException)
+// procedure.exception(t);
+// else
+// procedure
+// .exception(new DatabaseException(
+// "Unexpected exception in ReadGraph.asyncRequest(SingleAsyncRead, SingleProcedure)",
+// t));
+//
+// }
+//
+// }
}
return getValue(r);
}
}
+ else if(types.contains(L0.Function)) {
+ return Functions.exec(this, r, this, r, context);
+ }
else if(types.contains(L0.ExternalValue)) {
return (T)syncRequest(new AdaptValue(r), TransientCacheListener.<Object>instance());
}
return getVariantValue(r);
}
}
+ else if(types.contains(L0.Function)) {
+ Object value = Functions.exec(this, r, this, r, context);
+ try {
+ return new Variant(Bindings.OBJECT.getContentBinding(value), value);
+ } catch ( org.simantics.databoard.binding.error.BindingException e ) {
+ throw new BindingException( "No binding found for class " + value.getClass().getName(), e );
+ }
+ }
else if(types.contains(L0.ExternalValue)) {
Object value = syncRequest(new AdaptValue(r), TransientCacheListener.<Object>instance());
try {
for(Resource converter : graph.getObjects(resource, L0.ConvertsToValueWith)) {
try {
if(L0.Functions_functionApplication.equals(converter)) {
- return (Function3<ReadGraph,Resource,Object,T>)graph.syncRequest(new AdaptValue(resource));
+ return AdaptValue.functionApplication;
+ //return (Function3<ReadGraph,Resource,Object,T>)graph.syncRequest(new AdaptValue(resource));
} else {
return graph.getValue2(converter, resource);
}
} else {
return getValue(r, binding);
}
+ } else if(types.contains(L0.Function)) {
+ Object value = Functions.exec(this, r, this, r, context);
+ if(binding.isInstance(value)) return (T)value;
+ try {
+ Binding srcBinding = Bindings.OBJECT.getContentBinding(value);
+ return (T)Bindings.adapt(value, srcBinding, binding);
+ } catch(RuntimeException e) {
+ DatabaseException dte = findPossibleRootException(e);
+ if(dte != null) throw dte;
+ else throw new DatabaseException(e);
+ } catch (AdaptException e) {
+ throw new DatabaseException(e);
+ } catch (org.simantics.databoard.binding.error.BindingException e) {
+ throw new DatabaseException(e);
+ }
} else if(types.contains(L0.ExternalValue)) {
try {
- return (T)ReflectionUtils.getValue(getURI(r)).getValue();
- } catch(ValueNotFoundException e) {
- throw new DatabaseException(e);
+ ExternalValue ev = adapt(r, ExternalValue.class);
+ return ev.getValue(this, r);
+ //return (T)ReflectionUtils.getValue(getURI(r)).getValue();
+// } catch(ValueNotFoundException e) {
+// throw new DatabaseException(e);
} catch(ClassCastException e) {
throw new DatabaseException(e);
}
}
}
+ private static ThreadLocal<Boolean> syncGraph = new ThreadLocal<Boolean>() {
+ protected Boolean initialValue() {
+ return true;
+ }
+ };
+
@Override
public boolean setSynchronous(boolean value) {
- boolean old = processor.synch;
- processor.synch = value;
+ boolean old = getSynchronous();
+ syncGraph.set(value);
return old;
}
@Override
public boolean getSynchronous() {
- return processor.synch;
+ return syncGraph.get();
}
public void ensureLoaded(int resource) {
Code Review / simantics / platform.git / blobdiff