import org.simantics.db.impl.TableHeader;
import org.simantics.db.impl.graph.ReadGraphImpl;
import org.simantics.db.impl.query.QueryProcessor;
-import org.simantics.db.procedure.AsyncContextMultiProcedure;
-import org.simantics.db.procedure.AsyncMultiProcedure;
+import org.simantics.db.procedure.SyncContextMultiProcedure;
+import org.simantics.db.procedure.SyncMultiProcedure;
import org.simantics.db.procore.cluster.ClusterMap;
import org.simantics.db.procore.cluster.ClusterPrintDebugInfo;
import org.simantics.db.procore.cluster.ClusterTraits;
import org.simantics.db.procore.cluster.ValueTable;
import org.simantics.db.service.ClusterUID;
+import fi.vtt.simantics.procore.internal.SessionImplSocket;
+
final public class ClusterBig extends ClusterImpl {
private static final int TABLE_HEADER_SIZE = TableHeader.HEADER_SIZE + TableHeader.EXTRA_SIZE;
private static final int RESOURCE_TABLE_OFFSET = 0;
return objectTable.getSingleObject(objectIndex, support, this);
}
- public void forObjects(int resourceKey, int predicateKey, int objectIndex, QueryProcessor processor, ReadGraphImpl graph, AsyncMultiProcedure<Resource> procedure,
+ public void forObjects(int resourceKey, int predicateKey, int objectIndex, QueryProcessor processor, ReadGraphImpl graph, SyncMultiProcedure<Resource> procedure,
ClusterSupport support) throws DatabaseException {
if (DEBUG)
System.out.println("Cluster.forObjects1: rk=" + resourceKey + " pk=" + predicateKey);
}
objectTable.foreachObject(graph, objectIndex, procedure, this);
}
- public <C> void forObjects(int resourceKey, int predicateKey, int objectIndex, QueryProcessor processor, ReadGraphImpl graph, C context, AsyncContextMultiProcedure<C, Resource> procedure,
+ public <C> void forObjects(int resourceKey, int predicateKey, int objectIndex, QueryProcessor processor, ReadGraphImpl graph, C context, SyncContextMultiProcedure<C, Resource> procedure,
ClusterSupport support) throws DatabaseException {
if (DEBUG)
System.out.println("Cluster.forObjects1: rk=" + resourceKey + " pk=" + predicateKey);
@Override
public void forObjects(ReadGraphImpl graph, int resourceKey,
- int predicateKey, AsyncMultiProcedure<Resource> procedure)
+ int predicateKey, SyncMultiProcedure<Resource> procedure)
throws DatabaseException {
- throw new UnsupportedOperationException();
-
-// SessionImplSocket session = (SessionImplSocket)graph.getSession();
-// ClusterSupport support = session.clusterTranslator;
-//
-// if (DEBUG)
-// System.out.println("Cluster.forObjects3: rk=" + resourceKey + " pk=" + predicateKey);
-// final int resourceIndex = getLocalReference(resourceKey);
-// final int pRef = getInternalReferenceOrZero(predicateKey, support);
-// final ClusterI.CompleteTypeEnum pCompleteType = ClusterTraitsBase.getCompleteTypeFromResourceKey(predicateKey);
-// if (ClusterI.CompleteTypeEnum.NotComplete != pCompleteType) {
-// resourceTable.foreachObject(resourceIndex, graph, procedure, support, pRef, pCompleteType, completeTable, this);
-// return;
-// }
-// final int predicateIndex = resourceTable.getPredicateIndex(resourceIndex);
-// if (0 == predicateIndex) {
-// resourceTable.foreachObject(resourceIndex, graph, procedure, support, pRef, pCompleteType, completeTable, this);
-// return;
-// }
-// int objectIndex = predicateTable.getObjectIndex(predicateIndex, pRef);
-// forObjects(resourceKey, predicateKey, objectIndex, graph.processor, graph, procedure, support);
+ SessionImplSocket session = (SessionImplSocket)graph.getSession();
+ ClusterSupport support = session.clusterTranslator;
+
+ if (DEBUG)
+ System.out.println("Cluster.forObjects3: rk=" + resourceKey + " pk=" + predicateKey);
+ final int resourceIndex = getLocalReference(resourceKey);
+ final int pRef = getInternalReferenceOrZero(predicateKey, support);
+ final ClusterI.CompleteTypeEnum pCompleteType = ClusterTraitsBase.getCompleteTypeFromResourceKey(predicateKey);
+ if (ClusterI.CompleteTypeEnum.NotComplete != pCompleteType) {
+ resourceTable.foreachObject(resourceIndex, graph, procedure, support, pRef, pCompleteType, completeTable, this);
+ return;
+ }
+ final int predicateIndex = resourceTable.getPredicateIndex(resourceIndex);
+ if (0 == predicateIndex) {
+ resourceTable.foreachObject(resourceIndex, graph, procedure, support, pRef, pCompleteType, completeTable, this);
+ return;
+ }
+ int objectIndex = predicateTable.getObjectIndex(predicateIndex, pRef);
+ forObjects(resourceKey, predicateKey, objectIndex, graph.processor, graph, procedure, support);
}
@Override
public void forObjects(ReadGraphImpl graph, int resourceKey, ForEachObjectProcedure procedure) throws DatabaseException {
- throw new UnsupportedOperationException();
-
-// SessionImplSocket session = (SessionImplSocket)graph.getSession();
-// ClusterSupport support = session.clusterTranslator;
-// final int predicateKey = procedure.predicateKey;
-// if (DEBUG)
-// System.out.println("Cluster.forObjects3: rk=" + resourceKey + " pk=" + predicateKey);
-// final int resourceIndex = getLocalReference(resourceKey);
-// final int pRef = getInternalReferenceOrZero(predicateKey, support);
-// final ClusterI.CompleteTypeEnum pCompleteType = ClusterTraitsBase.getCompleteTypeFromResourceKey(predicateKey);
-// if (ClusterI.CompleteTypeEnum.NotComplete != pCompleteType) {
-// resourceTable.foreachObject(resourceIndex, graph, procedure, support, pRef, pCompleteType, completeTable, this);
-// return;
-// }
-// final int predicateIndex = resourceTable.getPredicateIndex(resourceIndex);
-// if (0 == predicateIndex) {
-// resourceTable.foreachObject(resourceIndex, graph, procedure, support, pRef, pCompleteType, completeTable, this);
-// return;
-// }
-// int objectIndex = predicateTable.getObjectIndex(predicateIndex, pRef);
-// forObjects(resourceKey, predicateKey, objectIndex, graph.processor, graph, procedure, support);
+ SessionImplSocket session = (SessionImplSocket)graph.getSession();
+ ClusterSupport support = session.clusterTranslator;
+ final int predicateKey = procedure.predicateKey;
+ if (DEBUG)
+ System.out.println("Cluster.forObjects3: rk=" + resourceKey + " pk=" + predicateKey);
+ final int resourceIndex = getLocalReference(resourceKey);
+ final int pRef = getInternalReferenceOrZero(predicateKey, support);
+ final ClusterI.CompleteTypeEnum pCompleteType = ClusterTraitsBase.getCompleteTypeFromResourceKey(predicateKey);
+ if (ClusterI.CompleteTypeEnum.NotComplete != pCompleteType) {
+ resourceTable.foreachObject(resourceIndex, graph, procedure, support, pRef, pCompleteType, completeTable, this);
+ return;
+ }
+ final int predicateIndex = resourceTable.getPredicateIndex(resourceIndex);
+ if (0 == predicateIndex) {
+ resourceTable.foreachObject(resourceIndex, graph, procedure, support, pRef, pCompleteType, completeTable, this);
+ return;
+ }
+ int objectIndex = predicateTable.getObjectIndex(predicateIndex, pRef);
+ forObjects(resourceKey, predicateKey, objectIndex, graph.processor, graph, procedure, support);
}
@Override
import org.simantics.db.impl.Table;
import org.simantics.db.impl.TableHeader;
import org.simantics.db.impl.graph.ReadGraphImpl;
-import org.simantics.db.procedure.AsyncContextMultiProcedure;
-import org.simantics.db.procedure.AsyncMultiProcedure;
+import org.simantics.db.procedure.SyncContextMultiProcedure;
+import org.simantics.db.procedure.SyncMultiProcedure;
import org.simantics.db.procore.cluster.ClusterMapSmall;
import org.simantics.db.procore.cluster.ClusterTraits;
import org.simantics.db.procore.cluster.ClusterTraitsSmall;
import org.simantics.db.service.ClusterUID;
import org.simantics.db.service.ResourceUID;
+import fi.vtt.simantics.procore.internal.SessionImplSocket;
import gnu.trove.map.hash.TIntShortHashMap;
import gnu.trove.procedure.TIntProcedure;
import gnu.trove.set.hash.TIntHashSet;
return objectTable.getSingleObject(objectIndex, support, this);
}
- public void forObjects(ReadGraphImpl graph, int resourceKey, int predicateKey, int objectIndex, AsyncMultiProcedure<Resource> procedure,
+ public void forObjects(ReadGraphImpl graph, int resourceKey, int predicateKey, int objectIndex, SyncMultiProcedure<Resource> procedure,
ClusterSupport support) throws DatabaseException {
if (DEBUG)
System.out.println("ClusterSmall.forObjects1: rk=" + resourceKey + " pk=" + predicateKey);
objectTable.foreachObject(graph, objectIndex, procedure, this);
}
- public <C> void forObjects(ReadGraphImpl graph, int resourceKey, int predicateKey, int objectIndex, C context, AsyncContextMultiProcedure<C, Resource> procedure,
+ public <C> void forObjects(ReadGraphImpl graph, int resourceKey, int predicateKey, int objectIndex, C context, SyncContextMultiProcedure<C, Resource> procedure,
ClusterSupport support) throws DatabaseException {
if (DEBUG)
System.out.println("ClusterSmall.forObjects1: rk=" + resourceKey + " pk=" + predicateKey);
@Override
public void forObjects(ReadGraphImpl graph, int resourceKey,
- int predicateKey, AsyncMultiProcedure<Resource> procedure) throws DatabaseException {
+ int predicateKey, SyncMultiProcedure<Resource> procedure) throws DatabaseException {
- throw new UnsupportedOperationException();
-
-// SessionImplSocket session = (SessionImplSocket)graph.getSession();
-// ClusterSupport support = session.clusterTranslator;
-// if (DEBUG)
-// System.out.println("ClusterSmall.forObjects3: rk=" + resourceKey + " pk=" + predicateKey);
-// final int resourceIndex = ClusterTraitsBase.getResourceIndexFromResourceKey(resourceKey);
-// final int pRef = getInternalReferenceOrZero2(predicateKey, support);
-// final int completeType = ClusterTraitsBase.getCompleteTypeIntFromResourceKey(predicateKey);
-// final ClusterI.CompleteTypeEnum pCompleteType = CompleteTypeEnum.make(completeType);
-// if (completeType > 0) {
-// resourceTable.foreachObject(resourceIndex, graph, procedure, support, pRef, pCompleteType, completeTable, this);
-// return;
-// }
-// final int predicateIndex = (int)resourceTable.table[(resourceIndex<<1) - 1 + resourceTable.offset] & 0xFFFFFF;
-// if (0 == predicateIndex) {
-// resourceTable.foreachObject(resourceIndex, graph, procedure, support, pRef, pCompleteType, completeTable, this);
-// return;
-// }
-// int objectIndex = predicateTable.getObjectIndex(predicateIndex, pRef & 0xFFFF);
-// forObjects(graph, resourceKey, predicateKey, objectIndex, procedure, support);
+ SessionImplSocket session = (SessionImplSocket)graph.getSession();
+ ClusterSupport support = session.clusterTranslator;
+ if (DEBUG)
+ System.out.println("ClusterSmall.forObjects3: rk=" + resourceKey + " pk=" + predicateKey);
+ final int resourceIndex = ClusterTraitsBase.getResourceIndexFromResourceKey(resourceKey);
+ final int pRef = getInternalReferenceOrZero2(predicateKey, support);
+ final int completeType = ClusterTraitsBase.getCompleteTypeIntFromResourceKey(predicateKey);
+ final ClusterI.CompleteTypeEnum pCompleteType = CompleteTypeEnum.make(completeType);
+ if (completeType > 0) {
+ resourceTable.foreachObject(resourceIndex, graph, procedure, support, pRef, pCompleteType, completeTable, this);
+ return;
+ }
+ final int predicateIndex = (int)resourceTable.table[(resourceIndex<<1) - 1 + resourceTable.offset] & 0xFFFFFF;
+ if (0 == predicateIndex) {
+ resourceTable.foreachObject(resourceIndex, graph, procedure, support, pRef, pCompleteType, completeTable, this);
+ return;
+ }
+ int objectIndex = predicateTable.getObjectIndex(predicateIndex, pRef & 0xFFFF);
+ forObjects(graph, resourceKey, predicateKey, objectIndex, procedure, support);
+
}
public void forObjects(ReadGraphImpl graph, int resourceKey, ForEachObjectProcedure procedure) throws DatabaseException {
import org.simantics.browsing.ui.common.labelers.LabelerContent;
import org.simantics.browsing.ui.common.labelers.LabelerStub;
import org.simantics.browsing.ui.graph.impl.request.ResourceQuery;
+import org.simantics.db.AsyncReadGraph;
import org.simantics.db.ReadGraph;
import org.simantics.db.exception.DatabaseException;
import org.simantics.db.procedure.Listener;
if (content == LabelerContent.NO_CONTENT) {
- final DataSource<ReadGraph> source = updater.getDataSource(ReadGraph.class);
+ final DataSource<AsyncReadGraph> source = updater.getDataSource(AsyncReadGraph.class);
assert(source != null);
source.schedule(graph -> graph.asyncRequest(labelQuery, procedure));
*******************************************************************************/
package org.simantics.browsing.ui.graph.impl;
-import java.util.function.Consumer;
-
import org.simantics.browsing.ui.BuiltinKeys;
import org.simantics.browsing.ui.DataSource;
import org.simantics.browsing.ui.NodeContext;
import org.simantics.browsing.ui.common.viewpoints.ViewpointStub;
import org.simantics.browsing.ui.content.Viewpoint;
import org.simantics.browsing.ui.graph.impl.request.ParametrizedResourceQuery;
+import org.simantics.db.AsyncReadGraph;
import org.simantics.db.ReadGraph;
import org.simantics.db.exception.DatabaseException;
import org.simantics.db.procedure.Listener;
@Override
public NodeContext[] getChildren() {
if (children == Viewpoint.PENDING_CHILDREN) {
- DataSource<ReadGraph> source = updater.getDataSource(ReadGraph.class);
+ DataSource<AsyncReadGraph> source = updater.getDataSource(AsyncReadGraph.class);
if (source != null) {
source.schedule(graph -> graph.asyncRequest(childQuery, childQueryProcedure));
}
@Override
public Boolean getHasChildren() {
if (hasChildren == Viewpoint.PENDING_HAS_CHILDREN) {
- DataSource<ReadGraph> source = updater.getDataSource(ReadGraph.class);
+ DataSource<AsyncReadGraph> source = updater.getDataSource(AsyncReadGraph.class);
if (source != null) {
- source.schedule(new Consumer<ReadGraph>() {
- @Override
- public void accept(ReadGraph source) {
- source.asyncRequest(hasChildQuery, hasChildQueryProcedure);
- }
- });
+ source.schedule(graph -> graph.asyncRequest(hasChildQuery, hasChildQueryProcedure));
}
}
-
return hasChildren;
}
*******************************************************************************/
package org.simantics.browsing.ui.graph.impl;
-import java.util.function.Consumer;
-
import org.simantics.browsing.ui.DataSource;
import org.simantics.browsing.ui.NodeContext;
import org.simantics.browsing.ui.NodeContext.PrimitiveQueryKey;
import org.simantics.browsing.ui.PrimitiveQueryProcessor;
import org.simantics.browsing.ui.PrimitiveQueryUpdater;
import org.simantics.browsing.ui.graph.impl.request.ResourceQuery;
+import org.simantics.db.AsyncReadGraph;
import org.simantics.db.ReadGraph;
import org.simantics.db.exception.DatabaseException;
import org.simantics.db.procedure.Listener;
if (!computed) {
- final DataSource<ReadGraph> source = updater.getDataSource(ReadGraph.class);
+ final DataSource<AsyncReadGraph> source = updater.getDataSource(AsyncReadGraph.class);
assert(source != null);
- source.schedule(new Consumer<ReadGraph>() {
-
- @Override
- public void accept(ReadGraph source) {
-
- source.asyncRequest(query, procedure);
-
- }
-
- });
+ source.schedule(graph -> graph.asyncRequest(query, procedure));
}
*******************************************************************************/
package org.simantics.browsing.ui.graph.impl;
-import java.util.function.Consumer;
-
import org.simantics.browsing.ui.BuiltinKeys;
import org.simantics.browsing.ui.DataSource;
import org.simantics.browsing.ui.NodeContext;
import org.simantics.browsing.ui.common.viewpoints.ViewpointStub;
import org.simantics.browsing.ui.content.Viewpoint;
import org.simantics.browsing.ui.graph.impl.request.ResourceQuery;
+import org.simantics.db.AsyncReadGraph;
import org.simantics.db.ReadGraph;
import org.simantics.db.exception.DatabaseException;
import org.simantics.db.procedure.Listener;
public NodeContext[] getChildren() {
if (children == Viewpoint.PENDING_CHILDREN) {
- DataSource<ReadGraph> source = updater.getDataSource(ReadGraph.class);
+ DataSource<AsyncReadGraph> source = updater.getDataSource(AsyncReadGraph.class);
final Listener<NodeContext[]> childProcedure = createListener();
- source.schedule(new Consumer<ReadGraph>() {
- @Override
- public void accept(ReadGraph source) {
- source.asyncRequest(childQuery, childProcedure);
- }
- });
+ source.schedule(graph -> graph.asyncRequest(childQuery, childProcedure));
}
return children;
//System.out.println("LazyViewpoint2@" + System.identityHashCode(this) + " getChildren() = " + children.length);
if (children == org.simantics.browsing.ui.content.ViewpointContribution.PENDING_CONTRIBUTION) {
- DataSource<ReadGraph> source = updater.getDataSource(ReadGraph.class);
+ DataSource<AsyncReadGraph> source = updater.getDataSource(AsyncReadGraph.class);
if (source != null) {
source.schedule(graph -> {
ReadRequest childQuery = new ReadRequest() {
import org.simantics.browsing.ui.NodeContext;
import org.simantics.browsing.ui.PrimitiveQueryUpdater;
import org.simantics.browsing.ui.graph.impl.request.ResourceQuery;
+import org.simantics.db.AsyncReadGraph;
import org.simantics.db.ReadGraph;
import org.simantics.db.exception.DatabaseException;
import org.simantics.db.procedure.Listener;
if (state == null) {
- final DataSource<ReadGraph> source = updater.getDataSource(ReadGraph.class);
+ final DataSource<AsyncReadGraph> source = updater.getDataSource(AsyncReadGraph.class);
assert(source != null);
source.schedule(graph -> {
import org.simantics.browsing.ui.PrimitiveQueryUpdater;
import org.simantics.browsing.ui.content.ImageDecorator;
import org.simantics.browsing.ui.graph.impl.request.ResourceQuery;
+import org.simantics.db.AsyncReadGraph;
import org.simantics.db.ReadGraph;
import org.simantics.db.exception.DatabaseException;
import org.simantics.db.layer0.exception.PendingVariableException;
private void request() {
- final DataSource<ReadGraph> source = updater.getDataSource(ReadGraph.class);
+ final DataSource<AsyncReadGraph> source = updater.getDataSource(AsyncReadGraph.class);
assert(source != null);
final Procedure<ImageDecorator> procedure = createProcedure();
import org.simantics.browsing.ui.PrimitiveQueryUpdater;
import org.simantics.browsing.ui.content.Imager;
import org.simantics.browsing.ui.graph.impl.request.ResourceQuery;
+import org.simantics.db.AsyncReadGraph;
import org.simantics.db.ReadGraph;
import org.simantics.db.exception.DatabaseException;
import org.simantics.db.layer0.exception.PendingVariableException;
content = PENDING;
- final DataSource<ReadGraph> source = updater.getDataSource(ReadGraph.class);
+ final DataSource<AsyncReadGraph> source = updater.getDataSource(AsyncReadGraph.class);
assert(source != null);
final Procedure<Map<String, ImageDescriptor>> procedure = createProcedure();
import org.simantics.browsing.ui.PrimitiveQueryUpdater;
import org.simantics.browsing.ui.content.LabelDecorator;
import org.simantics.browsing.ui.graph.impl.request.ResourceQuery;
+import org.simantics.db.AsyncReadGraph;
import org.simantics.db.ReadGraph;
import org.simantics.db.exception.DatabaseException;
import org.simantics.db.procedure.Listener;
private void request() {
- final DataSource<ReadGraph> source = updater.getDataSource(ReadGraph.class);
+ final DataSource<AsyncReadGraph> source = updater.getDataSource(AsyncReadGraph.class);
assert(source != null);
final Procedure<LabelDecorator> procedure = createProcedure();
import org.simantics.browsing.ui.common.labelers.LabelerStub;
import org.simantics.browsing.ui.common.node.IModifiableNode;
import org.simantics.browsing.ui.graph.impl.request.ResourceQuery;
+import org.simantics.db.AsyncReadGraph;
import org.simantics.db.ReadGraph;
import org.simantics.db.UndoContext;
import org.simantics.db.common.utils.Logger;
if (content == LabelerContent.NO_CONTENT) {
- final DataSource<ReadGraph> source = updater.getDataSource(ReadGraph.class);
+ final DataSource<AsyncReadGraph> source = updater.getDataSource(AsyncReadGraph.class);
assert(source != null);
final Procedure<LabelerContent> procedure = createProcedure();
//System.out.println("LazyViewpoint2@" + System.identityHashCode(this) + " getChildren() = " + children.length);
if (children == org.simantics.browsing.ui.content.ViewpointContribution.PENDING_CONTRIBUTION) {
- DataSource<ReadGraph> source = updater.getDataSource(ReadGraph.class);
+ DataSource<AsyncReadGraph> source = updater.getDataSource(AsyncReadGraph.class);
if (source != null) {
source.schedule(graph -> {
if(childProcedure instanceof Listener<?>)
@Override
public void perform(AsyncReadGraph graph, AsyncMultiProcedure<Resource> procedure) {
- graph.forEachAssertedObject(resource, resource2, procedure);
+ graph.forEachAssertedObject(resource, resource2, procedure);
}
}
/*******************************************************************************
- * Copyright (c) 2007, 2010 Association for Decentralized Information Management
+ * Copyright (c) 2007, 2018 Association for Decentralized Information Management
* in Industry THTH ry.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
*******************************************************************************/
package org.simantics.db.common.primitiverequest;
-import org.simantics.db.AsyncReadGraph;
+import org.simantics.db.ReadGraph;
import org.simantics.db.Resource;
-import org.simantics.db.common.request.ResourceAsyncRead2;
-import org.simantics.db.procedure.AsyncProcedure;
+import org.simantics.db.common.request.ResourceRead2;
+import org.simantics.db.exception.DatabaseException;
-final public class IsInstanceOf extends ResourceAsyncRead2<Boolean> {
+public final class IsInstanceOf extends ResourceRead2<Boolean> {
public IsInstanceOf(Resource resource, Resource resource2) {
super(resource, resource2);
}
@Override
- public void perform(AsyncReadGraph graph, AsyncProcedure<Boolean> procedure) {
- graph.forIsInstanceOf(resource, resource2, procedure);
+ public Boolean perform(ReadGraph graph) throws DatabaseException {
+ return graph.isInstanceOf(resource, resource2);
}
}
/*******************************************************************************
- * Copyright (c) 2007, 2010 Association for Decentralized Information Management
+ * Copyright (c) 2007, 2018 Association for Decentralized Information Management
* in Industry THTH ry.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
*******************************************************************************/
package org.simantics.db.common.primitiverequest;
-import org.simantics.db.AsyncReadGraph;
+import org.simantics.db.ReadGraph;
import org.simantics.db.Resource;
-import org.simantics.db.procedure.AsyncProcedure;
-import org.simantics.db.request.AsyncRead;
+import org.simantics.db.adaption.AdaptionService;
+import org.simantics.db.common.request.BinaryRead;
+import org.simantics.db.exception.DatabaseException;
-final public class PossibleAdapter<T> implements AsyncRead<T> {
+public final class PossibleAdapter<T> extends BinaryRead<Resource,Class<T>, T> {
- final private Resource resource;
- final private Class<T> clazz;
-
- @Override
- public int hashCode() {
- return resource.hashCode() + 31 * clazz.hashCode();
- }
-
- @Override
- public boolean equals(Object object) {
- if (this == object)
- return true;
- else if (object == null)
- return false;
- else if (getClass() != object.getClass())
- return false;
- PossibleAdapter<?> r = (PossibleAdapter<?>)object;
- return resource.equals(r.resource) && clazz.equals(r.clazz);
- }
-
- @Override
- public int threadHash() {
- return hashCode();
- }
-
- @Override
- public int getFlags() {
- return 0;
- }
-
public PossibleAdapter(Resource resource, Class<T> clazz) {
- this.resource = resource;
- this.clazz = clazz;
+ super(resource, clazz);
}
@Override
- public void perform(AsyncReadGraph graph, AsyncProcedure<T> procedure) {
-
- graph.forPossibleAdapted(resource, clazz, procedure);
-
+ public T perform(ReadGraph graph) throws DatabaseException {
+ final AdaptionService service = graph.peekService(AdaptionService.class);
+ return service.adapt(graph, parameter, parameter, Resource.class, parameter2, true);
}
}
/*******************************************************************************
- * Copyright (c) 2007, 2010 Association for Decentralized Information Management
+ * Copyright (c) 2007, 2018 Association for Decentralized Information Management
* in Industry THTH ry.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
import org.simantics.db.RelationInfo;
import org.simantics.db.Resource;
import org.simantics.db.common.request.ResourceAsyncRead;
+import org.simantics.db.exception.DatabaseException;
import org.simantics.db.procedure.AsyncProcedure;
import org.simantics.db.service.DirectQuerySupport;
-final public class RelationInfoRequest extends ResourceAsyncRead<RelationInfo> {
+public final class RelationInfoRequest extends ResourceAsyncRead<RelationInfo> {
public RelationInfoRequest(Resource resource) {
super(resource);
}
- @Override
- public void perform(AsyncReadGraph graph, AsyncProcedure<RelationInfo> procedure) {
- DirectQuerySupport dqs = graph.getService(DirectQuerySupport.class);
- dqs.forRelationInfo(graph, resource, procedure);
- }
-
-}
-
\ No newline at end of file
+ @Override
+ public void perform(AsyncReadGraph graph, AsyncProcedure<RelationInfo> procedure) {
+ DirectQuerySupport dqs = graph.getService(DirectQuerySupport.class);
+ try {
+ procedure.execute(graph, dqs.getRelationInfo(graph, resource));
+ } catch (DatabaseException e) {
+ procedure.exception(graph, e);
+ }
+ }
+
+}
\ No newline at end of file
/*******************************************************************************
- * Copyright (c) 2007, 2010 Association for Decentralized Information Management
+ * Copyright (c) 2007, 2018 Association for Decentralized Information Management
* in Industry THTH ry.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
package org.simantics.db.common.procedure.single;
import org.simantics.db.ReadGraph;
-import org.simantics.db.common.procedure.adapter.AsyncListenerSupport;
+import org.simantics.db.common.procedure.adapter.SyncListenerSupport;
-abstract public class SingleSetSyncListenerDelegate<T> extends SingleSetSyncListener<T> {
+public abstract class SingleSetSyncListenerDelegate<T> extends SingleSetSyncListener<T> {
- final private AsyncListenerSupport support;
+ private final SyncListenerSupport support;
- public SingleSetSyncListenerDelegate(AsyncListenerSupport support) {
+ public SingleSetSyncListenerDelegate(SyncListenerSupport support) {
this.support = support;
}
--- /dev/null
+/*******************************************************************************
+ * Copyright (c) 2007, 2018 Association for Decentralized Information Management
+ * in Industry THTH ry.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ * VTT Technical Research Centre of Finland - initial API and implementation
+ *******************************************************************************/
+package org.simantics.db.common.procedure.wrapper;
+
+import org.simantics.db.ReadGraph;
+import org.simantics.db.procedure.MultiListener;
+import org.simantics.db.procedure.SyncMultiListener;
+
+public class NoneToSyncMultiListener<T> implements SyncMultiListener<T> {
+
+ private final MultiListener<T> procedure;
+
+ public NoneToSyncMultiListener(MultiListener<T> procedure) {
+ this.procedure = procedure;
+ }
+
+ @Override
+ public void execute(ReadGraph graph, final T result) {
+ procedure.execute(result);
+ }
+
+ @Override
+ public void finished(ReadGraph graph) {
+ procedure.finished();
+ }
+
+ @Override
+ public void exception(ReadGraph graph, Throwable t) {
+ procedure.exception(t);
+ }
+
+ @Override
+ public boolean isDisposed() {
+ return procedure.isDisposed();
+ }
+
+ @Override
+ public String toString() {
+ return "NoneToAsyncMultiListener -> " + procedure;
+ }
+
+}
--- /dev/null
+/*******************************************************************************
+ * Copyright (c) 2007, 2018 Association for Decentralized Information Management
+ * in Industry THTH ry.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ * VTT Technical Research Centre of Finland - initial API and implementation
+ *******************************************************************************/
+package org.simantics.db.common.procedure.wrapper;
+
+import org.simantics.db.ReadGraph;
+import org.simantics.db.procedure.MultiProcedure;
+import org.simantics.db.procedure.SyncMultiProcedure;
+
+public class NoneToSyncMultiProcedure<T> implements SyncMultiProcedure<T> {
+
+ private final MultiProcedure<T> procedure;
+
+ public NoneToSyncMultiProcedure(MultiProcedure<T> procedure) {
+ this.procedure = procedure;
+ }
+
+ @Override
+ public void execute(ReadGraph graph, final T result) {
+ procedure.execute(result);
+ }
+
+ @Override
+ public void finished(ReadGraph graph) {
+ procedure.finished();
+ }
+
+ @Override
+ public void exception(ReadGraph graph, Throwable t) {
+ procedure.exception(t);
+ }
+
+ @Override
+ public String toString() {
+ return "NoneToAsyncMultiProcedure -> " + procedure;
+ }
+
+}
/*******************************************************************************
- * Copyright (c) 2007, 2010 Association for Decentralized Information Management
+ * Copyright (c) 2007, 2018 Association for Decentralized Information Management
* in Industry THTH ry.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
import org.simantics.db.AsyncReadGraph;
import org.simantics.db.AsyncRequestProcessor;
import org.simantics.db.ReadGraph;
-import org.simantics.db.RequestProcessor;
import org.simantics.db.Resource;
import org.simantics.db.Session;
import org.simantics.db.WriteGraph;
import org.simantics.db.common.procedure.adapter.AsyncMultiProcedureAdapter;
import org.simantics.db.common.procedure.adapter.ProcedureAdapter;
+import org.simantics.db.common.procedure.adapter.SyncMultiProcedureAdapter;
import org.simantics.db.common.procedure.wrapper.NoneToAsyncProcedure;
import org.simantics.db.common.request.ReadRequest;
import org.simantics.db.common.request.WriteRequest;
import org.simantics.utils.DataContainer;
import org.simantics.utils.datastructures.Pair;
-public class MergingGraphRequestProcessor implements RequestProcessor {
+public class MergingGraphRequestProcessor implements AsyncRequestProcessor {
private static class SyncWriteRequestAdapter implements Write {
Logger.defaultLogError(t);
- if(currentRequest.second instanceof AsyncProcedure<?>) {
- ((AsyncProcedure<?>)currentRequest.second).exception(graph, t);
- } else {
- ((AsyncMultiProcedure<?>)currentRequest.second).exception(graph, t);
- }
+// if(currentRequest.second instanceof AsyncProcedure<?>) {
+// ((AsyncProcedure<?>)currentRequest.second).exception(graph, t);
+// } else {
+// ((AsyncMultiProcedure<?>)currentRequest.second).exception(graph, t);
+// }
}
if(currentRequest.second instanceof AsyncProcedure<?>) {
if(currentRequest.first instanceof AsyncRead) {
AsyncRead req = (AsyncRead)currentRequest.first;
- graph.asyncRequest(req, (AsyncProcedure<?>)currentRequest.second);
+ graph.syncRequest(req, (AsyncProcedure<?>)currentRequest.second);
} else {
Read req = (Read)currentRequest.first;
- graph.asyncRequest(req, (AsyncProcedure<?>)currentRequest.second);
+ graph.syncRequest(req, (AsyncProcedure<?>)currentRequest.second);
}
} else {
AsyncMultiRead req = (AsyncMultiRead)currentRequest.first;
- graph.asyncRequest(req, (AsyncMultiProcedure<?>)currentRequest.second);
+ graph.syncRequest(req, (AsyncMultiProcedure<?>)currentRequest.second);
}
} catch(Throwable t) {
Logger.defaultLogError(t);
- if(currentRequest.second instanceof AsyncProcedure<?>) {
- ((AsyncProcedure<?>)currentRequest.second).exception(graph, t);
- } else {
- ((AsyncMultiProcedure<?>)currentRequest.second).exception(graph, t);
- }
+// if(currentRequest.second instanceof AsyncProcedure<?>) {
+// ((AsyncProcedure<?>)currentRequest.second).exception(graph, t);
+// } else {
+// ((AsyncMultiProcedure<?>)currentRequest.second).exception(graph, t);
+// }
}
}
// System.out.println(this + " asyncRequest(ReadGraphRequest<QueryProcedure4<T>> request, QueryProcedure4<T> procedure)");
- if (requestSet.contains(request))
+ Pair<Object, Object> pair = Pair.make(request, procedure);
+ if (requestSet.contains(pair))
return;
- Pair<Object, Object> pair = new Pair<Object, Object>(request, procedure);
requestQueue.add(pair);
requestSet.add(pair);
// System.out.println(this + " asyncRequest(ReadGraphRequest<SingleQueryProcedure4<T>> request, SingleQueryProcedure4<T> procedure) " + this);
- if (requestSet.contains(request))
+ Pair<Object, Object> pair = Pair.make(request, procedure);
+ if (requestSet.contains(pair))
return;
- Pair<Object, Object> pair = new Pair<Object, Object>(request, procedure);
requestQueue.add(pair);
requestSet.add(pair);
// System.out.println(this + " asyncRequest(WriteGraphRequest request)");
- if (requestSet.contains(request))
+ Pair<Object, Object> pair = Pair.make(request, callback);
+ if (requestSet.contains(pair))
return;
- Pair<Object, Object> pair = new Pair<Object, Object>(request, callback);
requestQueue.add(pair);
requestSet.add(pair);
// System.out.println(this + " asyncRequest(WriteGraphRequest request)");
- if (requestSet.contains(request))
+ Pair<Object, Object> pair = Pair.make(request, callback);
+ if (requestSet.contains(pair))
return;
- Pair<Object, Object> pair = new Pair<Object, Object>(request, callback);
requestQueue.add(pair);
requestSet.add(pair);
// System.out.println(this + " asyncRequest(WriteGraphRequest request)");
- if (requestSet.contains(request))
+ Pair<Object, Object> pair = Pair.make(request, callback);
+ if (requestSet.contains(pair))
return;
- Pair<Object, Object> pair = new Pair<Object, Object>(request, callback);
requestQueue.add(pair);
requestSet.add(pair);
public synchronized <T> void asyncRequest(Read<T> request,
AsyncProcedure<T> procedure) {
- if (requestSet.contains(request))
+ Pair<Object, Object> pair = Pair.make(request, procedure);
+ if (requestSet.contains(pair))
return;
- Pair<Object, Object> pair = new Pair<Object, Object>(request, procedure);
requestQueue.add(pair);
requestSet.add(pair);
final ArrayList<T> result = new ArrayList<T>();
final DataContainer<Throwable> exception = new DataContainer<Throwable>();
- syncRequest(request, new AsyncMultiProcedureAdapter<T>() {
+ syncRequest(request, new SyncMultiProcedureAdapter<T>() {
@Override
- public void execute(AsyncReadGraph graph, T t) {
+ public void execute(ReadGraph graph, T t) {
synchronized(result) {
result.add(t);
}
}
@Override
- public void exception(AsyncReadGraph graph, Throwable t) {
+ public void exception(ReadGraph graph, Throwable t) {
exception.set(t);
}
return result;
}
- @Override
- public <T> Collection<T> syncRequest(MultiRead<T> request, AsyncMultiProcedure<T> procedure) {
- throw new UnsupportedOperationException("Not implemented");
- }
-
@Override
public <T> Collection<T> syncRequest(MultiRead<T> request, MultiProcedure<T> procedure) {
throw new UnsupportedOperationException("Not implemented");
throw new UnsupportedOperationException("Not implemented");
}
- @Override
- public <T> void asyncRequest(MultiRead<T> request, AsyncMultiProcedure<T> procedure) {
- throw new UnsupportedOperationException("Not implemented");
- }
-
@Override
public <T> void asyncRequest(MultiRead<T> request, MultiProcedure<T> procedure) {
throw new UnsupportedOperationException("Not implemented");
}
- @Override
- public <T> Collection<T> syncRequest(MultiRead<T> arg0, AsyncMultiListener<T> arg1) {
- throw new UnsupportedOperationException("Not implemented.");
-
- }
-
@Override
public <T> Collection<T> syncRequest(MultiRead<T> arg0, SyncMultiListener<T> arg1) {
throw new UnsupportedOperationException("Not implemented.");
}
- @Override
- public <T> void asyncRequest(MultiRead<T> arg0, AsyncMultiListener<T> arg1) {
- throw new UnsupportedOperationException("Not implemented.");
-
- }
-
@Override
public <T> void asyncRequest(MultiRead<T> arg0, SyncMultiListener<T> arg1) {
throw new UnsupportedOperationException("Not implemented.");
/*******************************************************************************
- * Copyright (c) 2007, 2010 Association for Decentralized Information Management
+ * Copyright (c) 2007, 2018 Association for Decentralized Information Management
* in Industry THTH ry.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
import java.util.Collection;
import java.util.function.Consumer;
-import org.simantics.db.RequestProcessor;
+import org.simantics.db.AsyncRequestProcessor;
import org.simantics.db.Resource;
import org.simantics.db.Session;
import org.simantics.db.exception.DatabaseException;
import org.simantics.db.request.WriteOnlyResult;
import org.simantics.db.request.WriteResult;
-public class ProcessorBase implements RequestProcessor {
+public class ProcessorBase implements AsyncRequestProcessor {
@Override
public <T> void asyncRequest(AsyncMultiRead<T> request, AsyncMultiProcedure<T> procedure) {
throw new UnsupportedOperationException();
}
- @Override
- public <T> Collection<T> syncRequest(MultiRead<T> request, AsyncMultiProcedure<T> procedure) {
- throw new UnsupportedOperationException();
- }
-
@Override
public <T> Collection<T> syncRequest(MultiRead<T> request, MultiProcedure<T> procedure) {
throw new UnsupportedOperationException();
throw new UnsupportedOperationException();
}
- @Override
- public <T> void asyncRequest(MultiRead<T> request, AsyncMultiProcedure<T> procedure) {
- throw new UnsupportedOperationException();
- }
-
@Override
public <T> void asyncRequest(MultiRead<T> request, MultiProcedure<T> procedure) {
throw new UnsupportedOperationException();
throw new UnsupportedOperationException();
}
- @Override
- public <T> Collection<T> syncRequest(MultiRead<T> arg0, AsyncMultiListener<T> arg1) {
- throw new UnsupportedOperationException();
- }
-
@Override
public <T> Collection<T> syncRequest(MultiRead<T> arg0, SyncMultiListener<T> arg1) {
throw new UnsupportedOperationException();
throw new UnsupportedOperationException();
}
- @Override
- public <T> void asyncRequest(MultiRead<T> arg0, AsyncMultiListener<T> arg1) {
- throw new UnsupportedOperationException();
- }
-
@Override
public <T> void asyncRequest(MultiRead<T> arg0, SyncMultiListener<T> arg1) {
throw new UnsupportedOperationException();
/*******************************************************************************
- * Copyright (c) 2007, 2010 Association for Decentralized Information Management
+ * Copyright (c) 2007, 2018 Association for Decentralized Information Management
* in Industry THTH ry.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
*******************************************************************************/
package org.simantics.db.common.request;
-import org.simantics.db.AsyncReadGraph;
+import org.simantics.db.ReadGraph;
import org.simantics.db.Resource;
-import org.simantics.db.procedure.AsyncProcedure;
+import org.simantics.db.exception.DatabaseException;
import org.simantics.layer0.Layer0;
-public class PossibleTypedParent extends ResourceAsyncRead2<Resource> {
+public class PossibleTypedParent extends ResourceRead2<Resource> {
public PossibleTypedParent(Resource resource, Resource type) {
super(resource, type);
}
@Override
- public void perform(AsyncReadGraph graph, final AsyncProcedure<Resource> procedure) {
-
- final Layer0 l0 = graph.getService(Layer0.class);
-
- graph.forIsInstanceOf(resource, resource2, new AsyncProcedure<Boolean>() {
-
- @Override
- public void execute(AsyncReadGraph graph, Boolean isInstance) {
- if(isInstance) {
- procedure.execute(graph, resource);
- } else {
-
- graph.forPossibleObject(resource, l0.PartOf, new AsyncProcedure<Resource>() {
-
- @Override
- public void execute(AsyncReadGraph graph, final Resource parent) {
-
- if(parent == null) {
- procedure.execute(graph, null);
- } else {
- graph.asyncRequest(new PossibleTypedParent(parent, resource2), procedure);
- }
-
- }
-
- @Override
- public void exception(AsyncReadGraph graph, Throwable throwable) {
- procedure.exception(graph, throwable);
- }
-
- });
-
- }
- }
-
- @Override
- public void exception(AsyncReadGraph graph, Throwable throwable) {
- procedure.exception(graph, throwable);
+ public Resource perform(ReadGraph graph) throws DatabaseException {
+ if (graph.isInstanceOf(resource, resource2)) {
+ return resource;
+ } else {
+ Layer0 L0 = Layer0.getInstance(graph);
+ Resource possibleParent = graph.getPossibleObject(resource, L0.PartOf);
+ if (possibleParent != null) {
+ return graph.syncRequest(new PossibleTypedParent(possibleParent, resource2));
+ } else {
+ return null;
}
- });
-
-
+ }
}
}
public int hashCode() {
return resource.hashCode();
}
-
- @Override
- final public int threadHash() {
- return resource.getThreadHash();
- }
@Override
public boolean equals(Object object) {
import org.simantics.db.procedure.SyncProcedure;
import org.simantics.db.request.AsyncRead;
import org.simantics.db.request.ReadInterface;
-import org.simantics.db.request.Request;
-public abstract class ResourceAsyncRead2<T> implements AsyncRead<T>, Request, ReadInterface<T> {
+public abstract class ResourceAsyncRead2<T> implements AsyncRead<T>, ReadInterface<T> {
final protected Resource resource;
final protected Resource resource2;
/*******************************************************************************
- * Copyright (c) 2007, 2010 Association for Decentralized Information Management
+ * Copyright (c) 2007, 2018 Association for Decentralized Information Management
* in Industry THTH ry.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
*******************************************************************************/
package org.simantics.db.common.uri;
-import java.util.Collection;
import java.util.Map;
-import org.simantics.databoard.Bindings;
import org.simantics.db.ReadGraph;
import org.simantics.db.Resource;
import org.simantics.db.common.request.ResourceRead;
import org.simantics.db.exception.DatabaseException;
-import org.simantics.db.service.CollectionSupport;
-import org.simantics.layer0.Layer0;
-import org.simantics.utils.Development;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
public class UnescapedChildMapOfResource extends ResourceRead<Map<String, Resource>> {
- private static final Logger LOGGER = LoggerFactory.getLogger(UnescapedChildMapOfResource.class);
-
public UnescapedChildMapOfResource(Resource resource) {
- super(resource);
+ super(resource);
}
-
+
@Override
public Map<String, Resource> perform(ReadGraph graph) throws DatabaseException {
- Layer0 L0 = Layer0.getInstance(graph);
- Collection<Resource> objects = graph.getObjects(resource, L0.ConsistsOf);
- CollectionSupport cs = graph.getService(CollectionSupport.class);
- Map<String,Resource> result = cs.createObjectResourceMap(String.class, objects.size());
- for(Resource r : objects) {
- String name = graph.getPossibleRelatedValue(r, L0.HasName, Bindings.STRING);
- if(name != null) {
- Resource old = result.put(name, r);
- if (old != null)
- LOGGER.error("The database contains siblings with the same name " + name + " (resource=$" + resource.getResourceId() + ", child=$" + r.getResourceId() + ", previous child=$" + old.getResourceId() + ").");
- } else {
- if(Development.DEVELOPMENT)
- LOGGER.error("The database contains a child with no unique name (resource=$" + resource.getResourceId() + ", child=$" + r.getResourceId() + ").");
- }
- }
- return result;
- }
-
+ return graph.getChildren(resource);
+ }
+
}
DirectStatementProcedure proc = new DirectStatementProcedure();
if (ignoreVirtual) {
- dqs.forEachDirectPersistentStatement(graph, resource, proc);
+ return dqs.getDirectPersistentStatements(graph, resource);
} else {
- dqs.forEachDirectStatement(graph, resource, proc);
+ return dqs.getDirectStatements(graph, resource);
}
-
- return proc.getOrThrow();
}
/*******************************************************************************
- * Copyright (c) 2007, 2010 Association for Decentralized Information Management
+ * Copyright (c) 2007, 2018 Association for Decentralized Information Management
* in Industry THTH ry.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
import org.simantics.db.Resource;
import org.simantics.db.WriteGraph;
import org.simantics.db.WriteOnlyGraph;
-import org.simantics.db.common.request.ReadRequest;
import org.simantics.db.exception.DatabaseException;
import org.simantics.db.exception.RuntimeDatabaseException;
import org.simantics.db.exception.ValidationException;
}
}
- /**
- * Converts ordered set into a list.
- */
- public static void forEach(AsyncReadGraph g, final Resource l, final AsyncMultiProcedure<Resource> procedure) {
- g.asyncRequest(new ReadRequest() {
-
- @Override
- public void run(ReadGraph graph) throws DatabaseException {
- for(Resource r : toList(graph, l))
- procedure.execute(graph, r);
- }
-
- });
- }
-
/**
* Creates an empty ordered set.
*/
import org.simantics.databoard.accessor.Accessor;
import org.simantics.databoard.binding.Binding;
import org.simantics.databoard.type.Datatype;
+import org.simantics.db.AsyncRequestProcessor;
import org.simantics.db.ReadGraph;
import org.simantics.db.RequestProcessor;
import org.simantics.db.Resource;
}
}
- public static void startTransaction(RequestProcessor processor, boolean write) throws DatabaseException {
+ public static void startTransaction(AsyncRequestProcessor processor, boolean write) throws DatabaseException {
startTransaction(processor, write ? Type.WRITE : Type.READ);
}
- public static void startTransaction(RequestProcessor processor, Type type) throws DatabaseException {
+ public static void startTransaction(AsyncRequestProcessor processor, Type type) throws DatabaseException {
switch (type) {
case READ:
{
--- /dev/null
+/*******************************************************************************
+ * Copyright (c) 2018 Association for Decentralized Information Management
+ * in Industry THTH ry.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ * Semantum Oy - initial API and implementation
+ *******************************************************************************/
+package org.simantics.db.impl;
+
+import org.simantics.db.AsyncReadGraph;
+import org.simantics.db.common.utils.Logger;
+import org.simantics.db.exception.DatabaseException;
+import org.simantics.db.impl.graph.ReadGraphImpl;
+import org.simantics.db.procedure.AsyncMultiProcedure;
+
+public class BlockingAsyncMultiProcedure<Result> implements AsyncMultiProcedure<Result> {
+
+ private static final Object NO_RESULT = new Object();
+
+ private final Object key;
+ private final ReadGraphImpl graph;
+ private final AsyncMultiProcedure<Result> procedure;
+
+ private Object result = NO_RESULT;
+ private Throwable exception = null;
+
+ public BlockingAsyncMultiProcedure(ReadGraphImpl graph, AsyncMultiProcedure<Result> procedure, Object key) {
+ this.procedure = procedure;
+ this.key = key;
+ this.graph = ReadGraphImpl.newAsync(graph);
+ this.graph.asyncBarrier.inc();
+ }
+
+ @Override
+ public void execute(AsyncReadGraph graph, Result result) {
+ this.result = result;
+ try {
+ if(procedure != null) procedure.execute(graph, result);
+ } catch (Throwable throwable) {
+ Logger.defaultLogError("AsyncProcedure.execute threw for " + procedure, throwable);
+ }
+ }
+
+ @Override
+ public void finished(AsyncReadGraph graph) {
+ this.graph.asyncBarrier.dec();
+ try {
+ if(procedure != null) procedure.finished(graph);
+ } catch (Throwable throwable) {
+ Logger.defaultLogError("AsyncProcedure.finish threw for " + procedure, throwable);
+ }
+ }
+
+ @Override
+ public void exception(AsyncReadGraph graph, Throwable t) {
+ this.exception = t;
+ try {
+ if (procedure != null) procedure.exception(graph, t);
+ } catch (Throwable throwable) {
+ Logger.defaultLogError("AsyncProcedure.exception threw for " + procedure, throwable);
+ } finally {
+ this.graph.asyncBarrier.dec();
+ }
+ }
+
+ @SuppressWarnings("unchecked")
+ public Result get() throws DatabaseException {
+ graph.asyncBarrier.waitBarrier(key, graph);
+ if (exception != null) {
+ if (exception instanceof DatabaseException) throw (DatabaseException) exception;
+ throw new DatabaseException(exception);
+ } else {
+ return (Result) result;
+ }
+ }
+
+ @SuppressWarnings("unchecked")
+ public Result getResult() {
+ return (Result) result;
+ }
+
+ public Throwable getException() {
+ return exception;
+ }
+
+ @Override
+ public String toString() {
+ return "." + procedure;
+ }
+
+}
--- /dev/null
+/*******************************************************************************
+ * Copyright (c) 2018 Association for Decentralized Information Management
+ * in Industry THTH ry.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ * Semantum Oy - initial API and implementation
+ *******************************************************************************/
+package org.simantics.db.impl;
+
+import org.simantics.db.AsyncReadGraph;
+import org.simantics.db.common.utils.Logger;
+import org.simantics.db.exception.DatabaseException;
+import org.simantics.db.impl.graph.ReadGraphImpl;
+import org.simantics.db.procedure.AsyncProcedure;
+
+public class BlockingAsyncProcedure<Result> implements AsyncProcedure<Result> {
+
+ private static final Object NO_RESULT = new Object();
+
+ private final Object key;
+ private final ReadGraphImpl graph;
+ private final AsyncProcedure<Result> procedure;
+
+ private Object result = NO_RESULT;
+ private Throwable exception = null;
+
+ public BlockingAsyncProcedure(ReadGraphImpl graph, AsyncProcedure<Result> procedure, Object key) {
+ this.procedure = procedure;
+ this.key = key;
+ this.graph = ReadGraphImpl.newAsync(graph);
+ this.graph.asyncBarrier.inc();
+ }
+
+ @Override
+ public void execute(AsyncReadGraph graph, Result result) {
+ this.result = result;
+ this.graph.asyncBarrier.dec();
+ try {
+ if(procedure != null) procedure.execute(graph, result);
+ } catch (Throwable throwable) {
+ Logger.defaultLogError("AsyncProcedure.execute threw for " + procedure, throwable);
+ }
+ }
+
+ @Override
+ public void exception(AsyncReadGraph graph, Throwable t) {
+ this.exception = t;
+ try {
+ if(procedure != null) procedure.exception(graph, t);
+ } catch (Throwable throwable) {
+ Logger.defaultLogError("AsyncProcedure.exception threw for " + procedure, throwable);
+ } finally {
+ this.graph.asyncBarrier.dec();
+ }
+ }
+
+ @SuppressWarnings("unchecked")
+ public Result get() throws DatabaseException {
+
+ graph.asyncBarrier.waitBarrier(key, graph);
+
+ if(exception != null) {
+ if(exception instanceof DatabaseException) throw (DatabaseException)exception;
+ throw new DatabaseException(exception);
+ } else {
+ return (Result)result;
+ }
+
+ }
+
+ @SuppressWarnings("unchecked")
+ public Result getResult() {
+ return (Result)result;
+ }
+
+ public Throwable getException() {
+ return exception;
+ }
+
+ @Override
+ public String toString() {
+ return "." + procedure;
+ }
+
+}
import org.simantics.db.Resource;
import org.simantics.db.exception.DatabaseException;
import org.simantics.db.impl.graph.ReadGraphImpl;
-import org.simantics.db.procedure.AsyncMultiProcedure;
+import org.simantics.db.procedure.SyncMultiProcedure;
import org.simantics.db.service.ClusterUID;
public interface ClusterI {
public <C, T> int getSingleObject(int resourceKey, ForPossibleRelatedValueContextProcedure<C, T> procedure, ClusterSupport support)
throws DatabaseException;
- public void forObjects(ReadGraphImpl graph, int resourceKey, int predicateKey, AsyncMultiProcedure<Resource> procedure)
+ public void forObjects(ReadGraphImpl graph, int resourceKey, int predicateKey, SyncMultiProcedure<Resource> procedure)
throws DatabaseException;
public void forObjects(ReadGraphImpl graph, int resourceKey, ForEachObjectProcedure procedure)
package org.simantics.db.impl;
-import org.simantics.db.AsyncReadGraph;
+import org.simantics.db.ReadGraph;
import org.simantics.db.RelationInfo;
import org.simantics.db.Resource;
+import org.simantics.db.exception.DatabaseException;
import org.simantics.db.impl.query.QueryProcessor;
-import org.simantics.db.procedure.AsyncContextMultiProcedure;
+import org.simantics.db.procedure.SyncContextMultiProcedure;
-public final class ForEachObjectContextProcedure<C> implements AsyncContextMultiProcedure<C, Resource> {
+public final class ForEachObjectContextProcedure<C> implements SyncContextMultiProcedure<C, Resource> {
public final int predicateKey;
public final int[] clusterKey;
public final RelationInfo info;
public final QueryProcessor processor;
public final ClusterI.CompleteTypeEnum completeType;
- private final AsyncContextMultiProcedure<C, Resource> user;
+ private final SyncContextMultiProcedure<C, Resource> user;
- public ForEachObjectContextProcedure(int predicateKey, RelationInfo info, QueryProcessor processor, AsyncContextMultiProcedure<C, Resource> user) {
+ public ForEachObjectContextProcedure(int predicateKey, RelationInfo info, QueryProcessor processor, SyncContextMultiProcedure<C, Resource> user) {
this.predicateKey = predicateKey;
this.completeType = ClusterTraitsBase.getCompleteTypeFromResourceKey(predicateKey);
this.info = info;
}
@Override
- public void execute(AsyncReadGraph graph, C context, Resource result) {
+ public void execute(ReadGraph graph, C context, Resource result) throws DatabaseException {
user.execute(graph, context, result);
}
@Override
- public void finished(AsyncReadGraph graph, C context) {
+ public void finished(ReadGraph graph, C context) throws DatabaseException {
user.finished(graph, context);
}
@Override
- public void exception(AsyncReadGraph graph, Throwable throwable) {
+ public void exception(ReadGraph graph, Throwable throwable) throws DatabaseException {
user.exception(graph, throwable);
}
package org.simantics.db.impl;
-import org.simantics.db.AsyncReadGraph;
+import org.simantics.db.ReadGraph;
import org.simantics.db.RelationInfo;
import org.simantics.db.Resource;
+import org.simantics.db.exception.DatabaseException;
import org.simantics.db.impl.query.QueryProcessor;
-import org.simantics.db.procedure.AsyncMultiProcedure;
+import org.simantics.db.procedure.SyncMultiProcedure;
-public final class ForEachObjectProcedure implements AsyncMultiProcedure<Resource> {
+public final class ForEachObjectProcedure implements SyncMultiProcedure<Resource> {
public final int predicateKey;
public final int[] clusterKey;
public final RelationInfo info;
public final QueryProcessor processor;
public final ClusterI.CompleteTypeEnum completeType;
- private final AsyncMultiProcedure<Resource> user;
+ private final SyncMultiProcedure<Resource> user;
- public ForEachObjectProcedure(int predicateKey, RelationInfo info, QueryProcessor processor, AsyncMultiProcedure<Resource> user) {
+ public ForEachObjectProcedure(int predicateKey, RelationInfo info, QueryProcessor processor, SyncMultiProcedure<Resource> user) {
this.predicateKey = predicateKey;
this.completeType = ClusterTraitsBase.getCompleteTypeFromResourceKey(predicateKey);
this.info = info;
}
@Override
- public void execute(AsyncReadGraph graph, Resource result) {
+ public void execute(ReadGraph graph, Resource result) throws DatabaseException {
user.execute(graph, result);
}
@Override
- public void finished(AsyncReadGraph graph) {
+ public void finished(ReadGraph graph) throws DatabaseException {
user.finished(graph);
}
@Override
- public void exception(AsyncReadGraph graph, Throwable throwable) {
+ public void exception(ReadGraph graph, Throwable throwable) throws DatabaseException {
user.exception(graph, throwable);
}
package org.simantics.db.impl;
-import org.simantics.db.AsyncReadGraph;
+import org.simantics.db.ReadGraph;
import org.simantics.db.RelationInfo;
-import org.simantics.db.procedure.AsyncContextProcedure;
+import org.simantics.db.procedure.SyncContextProcedure;
-public final class ForPossibleRelatedValueContextProcedure<C, T> implements AsyncContextProcedure<C, T> {
+public final class ForPossibleRelatedValueContextProcedure<C, T> implements SyncContextProcedure<C, T> {
public final int predicateKey;
public final int[] clusterKey;
public final int[] predicateReference;
public final RelationInfo info;
public final ClusterI.CompleteTypeEnum completeType;
- private final AsyncContextProcedure<C, T> user;
+ private final SyncContextProcedure<C, T> user;
- public ForPossibleRelatedValueContextProcedure(int predicateKey, RelationInfo info, AsyncContextProcedure<C, T> user) {
+ public ForPossibleRelatedValueContextProcedure(int predicateKey, RelationInfo info, SyncContextProcedure<C, T> user) {
this.predicateKey = predicateKey;
this.completeType = ClusterTraitsBase.getCompleteTypeFromResourceKey(predicateKey);
this.info = info;
}
@Override
- public void execute(AsyncReadGraph graph, C context, T result) {
+ public void execute(ReadGraph graph, C context, T result) {
user.execute(graph, context, result);
}
@Override
- public void exception(AsyncReadGraph graph, Throwable throwable) {
+ public void exception(ReadGraph graph, Throwable throwable) {
user.exception(graph, throwable);
}
package org.simantics.db.impl;
-import org.simantics.db.AsyncReadGraph;
+import org.simantics.db.ReadGraph;
import org.simantics.db.RelationInfo;
-import org.simantics.db.procedure.AsyncProcedure;
+import org.simantics.db.exception.DatabaseException;
+import org.simantics.db.procedure.SyncProcedure;
-public final class ForPossibleRelatedValueProcedure<T> implements AsyncProcedure<T> {
+public final class ForPossibleRelatedValueProcedure<T> implements SyncProcedure<T> {
public final int predicateKey;
public final int[] clusterKey;
public final int[] predicateReference;
public final RelationInfo info;
public final ClusterI.CompleteTypeEnum completeType;
- private final AsyncProcedure<T> user;
+ private final SyncProcedure<T> user;
- public ForPossibleRelatedValueProcedure(int predicateKey, RelationInfo info, AsyncProcedure<T> user) {
+ public ForPossibleRelatedValueProcedure(int predicateKey, RelationInfo info, SyncProcedure<T> user) {
this.predicateKey = predicateKey;
this.completeType = ClusterTraitsBase.getCompleteTypeFromResourceKey(predicateKey);
this.info = info;
}
@Override
- public void execute(AsyncReadGraph graph, T result) {
+ public void execute(ReadGraph graph, T result) throws DatabaseException {
user.execute(graph, result);
}
@Override
- public void exception(AsyncReadGraph graph, Throwable throwable) {
+ public void exception(ReadGraph graph, Throwable throwable) throws DatabaseException {
user.exception(graph, throwable);
}
import org.simantics.databoard.serialization.SerializerConstructionException;
import org.simantics.db.AsyncReadGraph;
import org.simantics.db.AsyncRequestProcessor;
-import org.simantics.db.RequestProcessor;
import org.simantics.db.Resource;
import org.simantics.db.Statement;
import org.simantics.db.VirtualGraphContext;
final private SerialisationSupport serialization;
final private ResourceSupport resourceSupport;
final private VirtualGraphServerSupport virtualGraphServerSupport;
- final private RequestProcessor sessionRequestProcessor;
+ final private AsyncRequestProcessor sessionRequestProcessor;
/*
* Cluster array by index.
int[] EMPTY = new int[0];
- public static TransientGraph workspacePersistent(SerialisationSupport ss, VirtualGraphServerSupport vgss, ResourceSupport rs, RequestProcessor srp, String databaseId, String identifier) throws DatabaseException {
+ public static TransientGraph workspacePersistent(SerialisationSupport ss, VirtualGraphServerSupport vgss, ResourceSupport rs, AsyncRequestProcessor srp, String databaseId, String identifier) throws DatabaseException {
TransientGraph graph = new TransientGraph(ss, vgss, rs, srp, databaseId, identifier, Persistency.WORKSPACE);
graph.load();
return graph;
}
- public static TransientGraph memoryPersistent(SerialisationSupport ss, VirtualGraphServerSupport vgss, ResourceSupport rs, RequestProcessor srp, String databaseId, String identifier) {
+ public static TransientGraph memoryPersistent(SerialisationSupport ss, VirtualGraphServerSupport vgss, ResourceSupport rs, AsyncRequestProcessor srp, String databaseId, String identifier) {
return new TransientGraph(ss, vgss, rs, srp, databaseId, identifier, Persistency.MEMORY);
}
- private TransientGraph(SerialisationSupport ss, VirtualGraphServerSupport vgss, ResourceSupport rs, RequestProcessor srp, String databaseId, String identifier, Persistency persistency) {
+ private TransientGraph(SerialisationSupport ss, VirtualGraphServerSupport vgss, ResourceSupport rs, AsyncRequestProcessor srp, String databaseId, String identifier, Persistency persistency) {
this.serialization = ss;
this.virtualGraphServerSupport = vgss;
this.sessionRequestProcessor = srp;
/*******************************************************************************
- * Copyright (c) 2007, 2010 Association for Decentralized Information Management
+ * Copyright (c) 2007, 2018 Association for Decentralized Information Management
* in Industry THTH ry.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
import org.simantics.db.common.utils.Logger;
import org.simantics.db.exception.RuntimeDatabaseException;
import org.simantics.db.impl.query.QueryProcessor.AsyncBarrier;
-import org.simantics.db.impl.query.QueryProcessor.SessionTask;
-import org.simantics.utils.Development;
final public class AsyncBarrierImpl extends AtomicInteger implements AsyncBarrier {
final private AsyncBarrierImpl caller;
+ //private final Semaphore sema = new Semaphore(0);
+
public AsyncBarrierImpl(AsyncBarrierImpl caller) {
super(0);
if (BOOKKEEPING) {
while (get() != 0) {
- boolean executed = impl.processor.resume(impl);
+ boolean executed = impl.performPending();
if(executed) waitCount = 0;
++waitCount;
}
- if(Development.DEVELOPMENT) {
-
- impl.processor.threadLocks[0].lock();
- System.err.println("-queues=" + impl.processor.queues[0].size());
- impl.processor.threadLocks[0].unlock();
- System.err.println("-own=" + impl.processor.ownTasks[0].size());
- System.err.println("-ownSync=" + impl.processor.ownSyncTasks[0].size());
- for(SessionTask task : impl.processor.ownSyncTasks[0]) {
- System.err.println("--" + task);
- }
-
- }
+// if(Development.DEVELOPMENT) {
+// impl.processor.threadLocks[0].lock();
+// System.err.println("-queues=" + impl.processor.queues[0].size());
+// impl.processor.threadLocks[0].unlock();
+// System.err.println("-own=" + impl.processor.ownTasks[0].size());
+// System.err.println("-ownSync=" + impl.processor.ownSyncTasks[0].size());
+// for(SessionTask task : impl.processor.ownSyncTasks[0]) {
+// System.err.println("--" + task);
+// }
+// }
throw new RuntimeDatabaseException("Request timed out.");
//waitCount = 0;
import org.simantics.db.common.utils.Logger;
import org.simantics.db.impl.query.IntProcedure;
import org.simantics.db.impl.query.QuerySupport;
-import org.simantics.db.procedure.AsyncMultiProcedure;
+import org.simantics.db.procedure.SyncMultiProcedure;
public class MultiIntProcedure implements IntProcedure {
- final private AsyncMultiProcedure<Resource> procedure;
+ final private SyncMultiProcedure<Resource> procedure;
final private ReadGraphImpl impl;
final private QuerySupport support;
- public MultiIntProcedure(AsyncMultiProcedure<Resource> procedure, ReadGraphImpl impl, QuerySupport support) {
+ public MultiIntProcedure(SyncMultiProcedure<Resource> procedure, ReadGraphImpl impl, QuerySupport support) {
this.procedure = procedure;
this.impl = impl;
this.support = support;
/*******************************************************************************
- * Copyright (c) 2007, 2010 Association for Decentralized Information Management
+ * Copyright (c) 2007, 2018 Association for Decentralized Information Management
* in Industry THTH ry.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
+import java.util.Map;
import java.util.Set;
import java.util.function.Consumer;
import org.simantics.db.common.primitiverequest.VariantValueImplied;
import org.simantics.db.common.procedure.adapter.AsyncMultiProcedureAdapter;
import org.simantics.db.common.procedure.adapter.ProcedureAdapter;
+import org.simantics.db.common.procedure.adapter.SyncMultiProcedureAdapter;
import org.simantics.db.common.procedure.adapter.TransientCacheAsyncListener;
import org.simantics.db.common.procedure.adapter.TransientCacheListener;
import org.simantics.db.common.procedure.single.SyncReadProcedure;
import org.simantics.db.common.procedure.wrapper.NoneToAsyncMultiProcedure;
import org.simantics.db.common.procedure.wrapper.NoneToAsyncProcedure;
import org.simantics.db.common.procedure.wrapper.NoneToAsyncSetProcedure;
+import org.simantics.db.common.procedure.wrapper.NoneToSyncMultiListener;
+import org.simantics.db.common.procedure.wrapper.NoneToSyncMultiProcedure;
import org.simantics.db.common.procedure.wrapper.SyncToAsyncListener;
import org.simantics.db.common.procedure.wrapper.SyncToAsyncMultiListener;
import org.simantics.db.common.procedure.wrapper.SyncToAsyncMultiProcedure;
import org.simantics.db.exception.ResourceNotFoundException;
import org.simantics.db.exception.ServiceException;
import org.simantics.db.exception.ValidationException;
+import org.simantics.db.impl.BlockingAsyncProcedure;
import org.simantics.db.impl.RelationContextImpl;
import org.simantics.db.impl.ResourceImpl;
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.ResultCallWrappedQueryProcedure4;
-import org.simantics.db.impl.procedure.ResultCallWrappedSingleQueryProcedure4;
+import org.simantics.db.impl.procedure.ResultCallWrappedSyncQueryProcedure;
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.QueryProcessor.SessionTask;
import org.simantics.db.impl.query.QuerySupport;
import org.simantics.db.impl.query.TripleIntProcedure;
import org.simantics.db.impl.support.ResourceSupport;
import org.simantics.db.request.MultiRead;
import org.simantics.db.request.Read;
import org.simantics.db.request.ReadInterface;
-import org.simantics.db.request.RequestFlags;
import org.simantics.db.request.Write;
import org.simantics.db.request.WriteInterface;
import org.simantics.db.request.WriteOnly;
import org.simantics.utils.Development;
import org.simantics.utils.datastructures.Pair;
import org.simantics.utils.datastructures.collections.CollectionUtils;
+import org.slf4j.LoggerFactory;
import gnu.trove.map.hash.TObjectIntHashMap;
-public class ReadGraphImpl implements ReadGraph {
+public class ReadGraphImpl implements AsyncReadGraph {
+
+ private static final org.slf4j.Logger LOGGER = LoggerFactory.getLogger(ReadGraphImpl.class);
final static boolean EMPTY_RESOURCE_CHECK = false;
final public CacheEntry parent;
final public QueryProcessor processor;
+ public AsyncBarrierImpl asyncBarrier = null;
+
final static Binding DATA_TYPE_BINDING_INTERNAL = Bindings.getBindingUnchecked(Datatype.class);
final static Serializer DATA_TYPE_SERIALIZER = Bindings.getSerializerUnchecked(DATA_TYPE_BINDING_INTERNAL);
try {
- return syncRequest(new org.simantics.db.common.primitiverequest.Resource(
- id));
+ Integer rid = QueryCache.resultURIToResource(this, id, parent, null);
+ // FIXME: stupid to throw this here and catch and wrap it right away
+ 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);
} catch (ResourceNotFoundException e) {
}
}
+
+ @Override
+ public Map<String, Resource> getChildren(Resource resource) throws ValidationException, ServiceException {
+
+ assert (resource != null);
+
+ try {
+
+ int rId = processor.querySupport.getId(resource);
+ return QueryCache.resultChildMap(this, rId, parent, null);
+
+ } catch (ValidationException e) {
+
+ throw new ValidationException(e);
+
+ } catch (ServiceException e) {
+
+ throw new ServiceException(e);
+
+ } catch (DatabaseException e) {
+
+ throw new ServiceException(INTERNAL_ERROR_STRING, e);
+
+ }
+
+ }
final public Resource getRootLibrary() {
return processor.getRootLibraryResource();
assert (request != null);
- if (parent != null) {
-
- try {
- return processor.queryRead(this, request, parent, null, null);
- } catch (Throwable e) {
- if(e instanceof DatabaseException) throw (DatabaseException)e;
- else throw new DatabaseException(e);
- }
-
- } else {
-
- try {
-
- return processor.tryQuery(this, request);
+ return QueryCache.resultReadEntry(this, request, parent, null, null);
- } catch (Throwable throwable) {
-
- //Logger.defaultLogError("Internal read request failure", throwable);
-
- if (throwable instanceof DatabaseException)
- throw (DatabaseException) throwable;
- else
- throw new DatabaseException(
- "Unexpected exception in ReadGraph.syncRequest(Read,Procedure)",
- throwable);
-
- }
-
- }
-
}
@Override
ListenerBase listener = procedure != null ? getListenerBase(procedure) : null;
- if (parent != null || listener != null) {
-
- try {
- return processor.queryRead(this, request, parent, procedure, listener);
- } catch (Throwable e) {
- if(e instanceof DatabaseException) throw (DatabaseException)e;
- else throw new DatabaseException(e);
- }
-
- } else {
-
- try {
-
- T t = processor.tryQuery(this, request);
- if(procedure != null)
- procedure.execute(this, t);
-
- return t;
-
- } catch (Throwable throwable) {
-
- Logger.defaultLogError("Internal read request failure", throwable);
-
- if(procedure != null)
- procedure.exception(this, throwable);
-
- if (throwable instanceof DatabaseException)
- throw (DatabaseException) throwable;
- else
- throw new DatabaseException(
- "Unexpected exception in ReadGraph.syncRequest(Read,Procedure)",
- throwable);
-
- }
-
- }
+ return QueryCache.resultReadEntry(this, request, parent, listener, procedure);
}
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;
-
-// return syncRequest(request, new AsyncProcedureAdapter<T>());
+ asyncBarrier = new AsyncBarrierImpl(null);
+ BlockingAsyncProcedure<T> ap = new BlockingAsyncProcedure<>(this, null, request);
+ syncRequest(request, ap);
+ return ap.get();
}
assert (request != null);
- // System.out.println("syncRequest " + request + " syncParent=" +
- // syncParent);
-
ListenerBase listener = getListenerBase(procedure);
- if (parent != null || listener != null || ((request.getFlags() & RequestFlags.SCHEDULE) > 0)) {
-
-// Object syncParent = request;
-
-// final ReadGraphImpl newGraph = newSync();
-
- final ResultCallWrappedSingleQueryProcedure4<T> wrapper = new ResultCallWrappedSingleQueryProcedure4<T>(
- procedure, request);
-
- processor.query(this, request, parent, wrapper, listener);
-
-// newGraph.waitAsync(syncParent);
-
- Throwable e = wrapper.getException();
- if (e != null) {
- // The request was async - produce meaningful stack trace by
- // wrapping
- if (e instanceof DatabaseException)
- throw (DatabaseException) e;
- else
- throw new DatabaseException(e);
- }
-
- return wrapper.getResult();
-
- } else {
-
- // System.out.println("direct call " + request );
-
- // Do not set the sync state.parent for external threads
-// Object syncParent = request;
-
-// final ReadGraphImpl newGraph = newSync();
-
- final ResultCallWrappedSingleQueryProcedure4<T> wrapper = new ResultCallWrappedSingleQueryProcedure4<T>(
- procedure, request);
-
- try {
-
- processor.tryQuery(this, request, wrapper);
-
- } catch (Throwable t) {
-
- wrapper.exception(this, t);
-
- }
+ BlockingAsyncProcedure<T> ap = new BlockingAsyncProcedure<>(this, procedure, request);
- Throwable e = wrapper.getException();
- if (e != null) {
- // The request was async - produce meaningful stack trace by
- // wrapping
- if (e instanceof DatabaseException)
- throw (DatabaseException) e;
- else
- throw new DatabaseException(e);
- }
-
- return wrapper.getResult();
+ QueryCache.runnerAsyncReadEntry(this, request, parent, listener, ap, true);
- }
+ return ap.get();
}
assert (request != null);
- // System.out.println("syncRequest " + request + " syncParent=" +
- // syncParent);
-
ListenerBase listener = getListenerBase(procedure);
+ assert(listener == null);
- if (parent != null || listener != null || ((request.getFlags() & RequestFlags.SCHEDULE) > 0)) {
+ BlockingAsyncProcedure<T> ap = new BlockingAsyncProcedure<>(this, procedure, request);
-// final ReadGraphImpl newGraph = newSync();
-
- final ResultCallWrappedSingleQueryProcedure4<T> wrapper = new ResultCallWrappedSingleQueryProcedure4<T>(
- procedure, request);
+ QueryCache.runnerAsyncReadEntry(this, request, parent, listener, ap, true);
- processor.query(this, request, parent, wrapper, listener);
-
- } 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);
- }
-
- }
+ ap.get();
}
final ArrayList<T> result = new ArrayList<T>();
final DataContainer<Throwable> exception = new DataContainer<Throwable>();
- syncRequest(request, new AsyncMultiProcedure<T>() {
+ syncRequest(request, new SyncMultiProcedure<T>() {
@Override
- public void execute(AsyncReadGraph graph, T t) {
+ public void execute(ReadGraph graph, T t) {
synchronized (result) {
result.add(t);
}
}
@Override
- public void finished(AsyncReadGraph graph) {
+ public void finished(ReadGraph graph) {
}
@Override
- public void exception(AsyncReadGraph graph, Throwable t) {
+ public void exception(ReadGraph graph, Throwable t) {
exception.set(t);
}
}
- @Override
- public <T> Collection<T> syncRequest(MultiRead<T> request,
- AsyncMultiListener<T> procedure) {
- return syncRequest(request, (AsyncMultiProcedure<T>) procedure);
- }
-
@Override
public <T> Collection<T> syncRequest(MultiRead<T> request,
SyncMultiListener<T> procedure) {
- return syncRequest(request, new SyncToAsyncMultiListener<T>(procedure));
+ return syncRequest(request, (SyncMultiProcedure<T>)procedure);
}
@Override
public <T> Collection<T> syncRequest(MultiRead<T> request,
MultiListener<T> procedure) {
- return syncRequest(request, new NoneToAsyncMultiListener<T>(procedure));
+ return syncRequest(request, new NoneToSyncMultiListener<T>(procedure));
}
@Override
public <T> Collection<T> syncRequest(MultiRead<T> request,
- AsyncMultiProcedure<T> procedure) {
+ SyncMultiProcedure<T> procedure) {
assert (request != null);
ListenerBase listener = getListenerBase(procedure);
+ final ResultCallWrappedSyncQueryProcedure<T> wrapper = new ResultCallWrappedSyncQueryProcedure<T>(procedure);
+
if (parent != null || listener != null) {
// Object syncParent = request;
// final ReadGraphImpl newGraph = newSync();
- processor.query(this, request, parent, procedure, listener);
+ processor.query(this, request, parent, wrapper, listener);
// newGraph.waitAsync(syncParent);
// final ReadGraphImpl newGraph = newSync();
- final ResultCallWrappedQueryProcedure4<T> wrapper = new ResultCallWrappedQueryProcedure4<T>(procedure);
-
try {
-
request.perform(this, wrapper);
-
} catch (Throwable t) {
-
wrapper.exception(this, t);
-// newGraph.waitAsync(syncParent);
-
}
}
- // TODO
- return null;
-
- }
+ return wrapper.get();
- @Override
- public <T> Collection<T> syncRequest(MultiRead<T> request,
- SyncMultiProcedure<T> procedure) {
- return syncRequest(request, new SyncToAsyncMultiProcedure<T>(procedure));
}
@Override
public <T> Collection<T> syncRequest(MultiRead<T> request,
MultiProcedure<T> procedure) {
- return syncRequest(request, new NoneToAsyncMultiProcedure<T>(procedure));
+ return syncRequest(request, new NoneToSyncMultiProcedure<T>(procedure));
}
static class AsyncMultiReadProcedure<T> extends ArrayList<T> implements AsyncMultiProcedure<T> {
final public <T> T syncRequest(final ExternalRead<T> request,
final Procedure<T> procedure) throws DatabaseException {
- assert (request != null);
-
- ListenerBase listener = getListenerBase(procedure);
-
- final DataContainer<Throwable> exception = new DataContainer<Throwable>();
- final DataContainer<T> result = new DataContainer<T>();
-
- if (parent != null || listener != null) {
-
-// final ReadGraphImpl newGraph = newSync();
-
- 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);
-
-// newGraph.waitAsync(request);
-
- } else {
-
- try {
-
- T t = processor.tryQuery(this, request);
- result.set(t);
- procedure.execute(t);
-
- } catch (Throwable t) {
-
- if (t instanceof DatabaseException) {
- exception.set((DatabaseException)t);
- procedure.exception(exception.get());
- } else {
- exception.set(new DatabaseException(
- "Unexpected exception in ReadGraph.syncRequest(Read)",
- t));
- procedure.exception(exception.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);
- }
+ assert (request != null);
- return result.get();
+ ListenerBase listener = procedure != null ? getListenerBase(procedure) : null;
+ return QueryCache.resultExternalReadEntry(this, request, parent, listener, procedure);
}
}
-// @Override
-// final public void forEachDirectObject(final Resource subject,
-// final Resource relation,
-// final AsyncMultiProcedure<Resource> procedure) {
-//
-// processor.forEachDirectObject(this, subject, relation, procedure);
-//
-// }
-//
-// @Override
-// public void forEachDirectObject(Resource subject, Resource relation,
-// SyncMultiProcedure<Resource> procedure) {
-// forEachDirectObject(subject, relation,
-// new SyncToAsyncMultiProcedure<Resource>(procedure));
-// }
-//
-// @Override
-// public void forEachDirectObject(Resource subject, Resource relation,
-// MultiProcedure<Resource> procedure) {
-// forEachDirectObject(subject, relation,
-// new NoneToAsyncMultiProcedure<Resource>(procedure));
-// }
-
@Override
- final public void forEachDirectPredicate(final Resource subject, final AsyncMultiProcedure<Resource> procedure) {
+ final public void forEachDirectPredicate(final Resource subject, final AsyncProcedure<Set<Resource>> procedure) {
processor.forEachDirectPredicate(this, subject, procedure);
}
@Override
- public void forEachDirectPredicate(Resource subject, SyncMultiProcedure<Resource> procedure) {
- forEachDirectPredicate(subject, new SyncToAsyncMultiProcedure<Resource>(procedure));
+ final public void forEachDirectPredicate(final Resource subject, final SyncProcedure<Set<Resource>> procedure) {
+ forEachDirectPredicate(subject, new SyncToAsyncProcedure<Set<Resource>>(procedure));
}
@Override
- public void forEachDirectPredicate(Resource subject, MultiProcedure<Resource> procedure) {
- forEachDirectPredicate(subject, new NoneToAsyncMultiProcedure<Resource>(procedure));
+ public void forEachDirectPredicate(Resource subject, Procedure<Set<Resource>> procedure) {
+ forEachDirectPredicate(subject, new NoneToAsyncProcedure<Set<Resource>>(procedure));
}
@Override
listener);
}
-// @Override
-// final public <T> void forPossibleRelatedValue(final Resource subject, final Resource relation, final Binding binding,
-// final AsyncProcedure<T> procedure) {
-//
-// forPossibleRelatedValue(subject, relation, binding, procedure, false);
-//
-// }
-
final public <T> void forPossibleRelatedValue(final Resource subject, final Resource relation, final Binding binding,
final AsyncProcedure<T> procedure) {
return processor.getSession();
}
-// @Override
-// final public Builtins getBuiltins() {
-// return processor.getSession().getBuiltins();
-// }
-
@Override
public <T> void asyncRequest(final Read<T> request) {
assert (request != null);
assert (procedure != null);
+
+ processor.schedule(new SessionTask(false) {
- final ListenerBase listener = getListenerBase(procedure);
-
- if (parent != null || listener != null) {
-
- try {
- processor.queryRead(this, request, parent, procedure,
- listener);
- } catch (Throwable e) {
- // This throwable has already been transferred to procedure at this point - do nothing about it
- //Logger.defaultLogError("Internal error ", e);
- }
-
- } 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 {
-
}
-
- }
+
+ });
}
return new ReadGraphImpl(null, support);
}
- public static ReadGraphImpl forRecompute(CacheEntry entry, QueryProcessor support) {
- return new ReadGraphImpl(entry, support);
- }
-
@Override
public <T> void asyncRequest(Read<T> request, SyncProcedure<T> procedure) {
asyncRequest(request, new SyncToAsyncProcedure<T>(procedure));
assert (request != null);
assert (procedure != null);
- final ListenerBase listener = getListenerBase(procedure);
-
- if (parent != null || listener != null) {
-
- processor.query(this, request, parent, procedure, listener);
-
- } 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));
+ processor.schedule(new SessionTask(false) {
+ @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);
+ }
}
-
- }
+
+ });
}
assert (request != null);
- asyncRequest(request, new AsyncMultiProcedureAdapter<T>() {
+ asyncRequest(request, new SyncMultiProcedureAdapter<T>() {
@Override
- public void exception(AsyncReadGraph graph, Throwable t) {
+ public void exception(ReadGraph graph, Throwable t) {
Logger.defaultLogError(t);
}
}
- @Override
- public <T> void asyncRequest(MultiRead<T> request,
- AsyncMultiListener<T> procedure) {
- asyncRequest(request, (AsyncMultiProcedure<T>) procedure);
- }
-
@Override
public <T> void asyncRequest(MultiRead<T> request,
SyncMultiListener<T> procedure) {
- asyncRequest(request, new SyncToAsyncMultiListener<T>(procedure));
+ asyncRequest(request, (SyncMultiProcedure<T>)procedure);
}
@Override
public <T> void asyncRequest(MultiRead<T> request,
MultiListener<T> procedure) {
- asyncRequest(request, new NoneToAsyncMultiListener<T>(procedure));
+ asyncRequest(request, new NoneToSyncMultiListener<T>(procedure));
}
+
@Override
public <T> void asyncRequest(final MultiRead<T> request,
- final AsyncMultiProcedure<T> procedure) {
+ final SyncMultiProcedure<T> procedure) {
assert (request != null);
assert (procedure != null);
} catch (Throwable t) {
- procedure.exception(this, t);
+ try {
+ procedure.exception(this, t);
+ } catch (DatabaseException e) {
+ LOGGER.error("Unexpected exception while handling exception", e);
+ }
}
}
- @Override
- public <T> void asyncRequest(MultiRead<T> request,
- SyncMultiProcedure<T> procedure) {
- asyncRequest(request, new SyncToAsyncMultiProcedure<T>(procedure));
- }
-
@Override
public <T> void asyncRequest(MultiRead<T> request,
MultiProcedure<T> procedure) {
- asyncRequest(request, new NoneToAsyncMultiProcedure<T>(procedure));
+ asyncRequest(request, new NoneToSyncMultiProcedure<T>(procedure));
}
@Override
assert (request != null);
assert (procedure != null);
- ListenerBase listener = getListenerBase(procedure);
+ final ListenerBase listener = getListenerBase(procedure);
if (parent != null || listener != null) {
- processor.query(this, request, parent, procedure, listener);
-
- } else {
-
try {
+ QueryCacheBase.resultExternalReadEntry(this, request, parent, listener, procedure);
+ } catch (DatabaseException e) {
+ Logger.defaultLogError(e);
+ // This throwable has already been transferred to procedure at this point - do nothing about it
+ }
- 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;
- }
+ } else {
- @Override
- public boolean isDisposed() {
- return true;
- }
+ request.register(this, new Listener<T>() {
+ @Override
+ public void execute(T result) {
+ procedure.execute(result);
+ }
- });
+ @Override
+ public void exception(Throwable t) {
+ procedure.exception(t);
+ }
- } catch (Throwable t) {
+ @Override
+ public String toString() {
+ return "asyncRequest(PrimitiveRead) -> " + request;
+ }
- if (t instanceof DatabaseException)
- procedure.exception(t);
- else
- procedure
- .exception(new DatabaseException(
- "Unexpected exception in ReadGraph.asyncRequest(SingleAsyncRead, SingleProcedure)",
- t));
+ @Override
+ public boolean isDisposed() {
+ return true;
+ }
- }
+ });
}
return thread == Integer.MIN_VALUE;
}
-// final private boolean isSync(int thread) {
-// return thread < -1 && thread > Integer.MIN_VALUE;
-// }
-
ReadGraphImpl(ReadGraphImpl graph) {
this(graph.parent, graph.processor);
}
ReadGraphImpl(CacheEntry parent, QueryProcessor support) {
-// this.state = new ReadGraphState(barrier, support);
this.parent = parent;
this.processor = support;
}
-
- ReadGraphImpl(final QueryProcessor support) {
-
-// this.state = state;
- this.processor = support;
- this.parent = null;
-
- }
-
-// public static ReadGraphImpl createSync(int syncThread, Object syncParent,
-// ReadGraphSupportImpl support) {
-// return new ReadGraphImpl(syncThread, syncThread, syncParent, null,
-// support, new AsyncBarrierImpl(null));
-// }
public static ReadGraphImpl create(QueryProcessor support) {
- return new ReadGraphImpl(support);
+ return new ReadGraphImpl(null, support);
}
-// public ReadGraphImpl newAsync() {
-// return this;
-//// if(!state.synchronizedExecution) {
-//// return this;
-//// } else {
-//// return new ReadGraphImpl(false, parent, state.support, state.barrier);
-//// }
-// }
-
-// public ReadGraphImpl newSync() {
-// return new ReadGraphImpl(parent, processor);
-// }
-
- public ReadGraphImpl newSync(CacheEntry parentEntry) {
- return new ReadGraphImpl(parentEntry, processor);
+ public static ReadGraphImpl newAsync(ReadGraphImpl parent) {
+ ReadGraphImpl result = new ReadGraphImpl(parent);
+ result.asyncBarrier = new AsyncBarrierImpl(parent.asyncBarrier);
+ return result;
}
public ReadGraphImpl newRestart(ReadGraphImpl impl) {
WriteGraphImpl write = processor.getSession().getService(
WriteGraphImpl.class);
-// if (write.callerThread != impl.callerThread)
-// return new WriteGraphImpl(impl.callerThread, parent, state.support, write.writeSupport, write.provider, write.state.barrier);
return write;
}
-// public ReadGraphImpl newSync(Object parentRequest) {
-// return new ReadGraphImpl(callerThread, state.parent, state.support, new AsyncBarrierImpl(state.barrier));
-// }
-
-// public ReadGraphImpl newSync(final int callerThread, Object parentRequest) {
-// assert (state.syncThread == callerThread || (state.syncThread == Integer.MIN_VALUE && callerThread != Integer.MIN_VALUE));
-// return new ReadGraphImpl(callerThread, callerThread, parentRequest,
-// state.parent, state.support, new AsyncBarrierImpl(state.barrier));
-// }
-//
-// public ReadGraphImpl newSyncAsync(Object parentRequest) {
-//// assert (callerThread < 0);
-// return new ReadGraphImpl(callerThread, state.syncThread, parentRequest,
-// state.parent, state.support, new AsyncBarrierImpl(state.barrier));
-// }
-//
-// public ReadGraphImpl newSyncAsync(final int callerThread,
-// Object parentRequest) {
-//// assert (callerThread < 0);
-// // assert(state.syncThread == callerThread || (state.syncThread == Integer.MIN_VALUE
-// // && callerThread != Integer.MIN_VALUE) );
-// return new ReadGraphImpl(callerThread, callerThread, parentRequest,
-// state.parent, state.support, new AsyncBarrierImpl(state.barrier));
-// }
-
- public ReadGraphImpl withAsyncParent(CacheEntry parent) {
- return new ReadGraphImpl(parent, processor);
- }
-
public ReadGraphImpl withParent(CacheEntry parent) {
if(parent == this.parent) return this;
else return new ReadGraphImpl(parent, processor);
assert(procedure.done());
-// while (!procedure.done()) {
-//
-// boolean executed = processor.resumeTasks(callerThread, null, null);
-// if (!executed) {
-// try {
-// Thread.sleep(1);
-// // sema.tryAcquire(1, TimeUnit.MILLISECONDS);
-// } catch (InterruptedException e) {
-// e.printStackTrace();
-// }
-// }
-//
-// }
-
}
public <T> void waitAsyncProcedure(AsyncReadProcedure<T> procedure) {
assert(procedure.done());
-// while (!procedure.done()) {
-//
-// boolean executed = processor.processor.resume(this);
-// if (!executed) {
-// try {
-// Thread.sleep(1);
-// // sema.tryAcquire(1, TimeUnit.MILLISECONDS);
-// } catch (InterruptedException e) {
-// e.printStackTrace();
-// }
-// }
-//
-// }
-
}
-
-// public void waitAsync(Object request) {
-// try {
-// state.barrier.waitBarrier(request, this);
-// } catch (Throwable t) {
-// t.printStackTrace();
-// processor.scanPending();
-// processor.querySupport.checkTasks();
-// throw new RuntimeDatabaseException(t);
-// }
-// }
-
-// public void restart() {
-// state.barrier.restart();
-// }
public boolean resumeTasks() {
return processor.resumeTasks(this);
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) {
public Object getModificationCounter() {
return processor.getSession().getModificationCounter();
}
-
+
+ @Override
+ public boolean performPending() {
+ return processor.performPending(processor.thread.get());
+ }
+
}
/*******************************************************************************
- * Copyright (c) 2007, 2010 Association for Decentralized Information Management
+ * Copyright (c) 2007, 2018 Association for Decentralized Information Management
* in Industry THTH ry.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
import java.util.Set;
-import org.simantics.db.DirectStatements;
import org.simantics.db.RelationInfo;
import org.simantics.db.Resource;
import org.simantics.db.Session;
import org.simantics.db.procedure.AsyncSetListener;
import org.simantics.db.procedure.ListenerBase;
import org.simantics.db.procedure.MultiProcedure;
-import org.simantics.db.procedure.Procedure;
import org.simantics.db.procedure.StatementProcedure;
+import org.simantics.db.procedure.SyncMultiProcedure;
import org.simantics.db.request.AsyncMultiRead;
-import org.simantics.db.request.AsyncRead;
-import org.simantics.db.request.ExternalRead;
import org.simantics.db.request.MultiRead;
-import org.simantics.db.request.Read;
public interface ReadGraphSupport {
void forEachAssertedStatement(ReadGraphImpl graph, Resource subject, Resource predicate, AsyncMultiProcedure<Statement> procedure);
void forEachObject(ReadGraphImpl graph, Resource subject, Resource predicate, MultiProcedure<Resource> procedure);
void forEachObject(ReadGraphImpl graph, Resource subject, Resource predicate, AsyncMultiProcedure<Resource> procedure);
- void forEachDirectPredicate(ReadGraphImpl graph, Resource subject, AsyncMultiProcedure<Resource> procedure);
- void forEachDirectStatement(ReadGraphImpl graph, Resource subject, Procedure<DirectStatements> procedure);
- void forEachDirectStatement(ReadGraphImpl graph, Resource subject, AsyncProcedure<DirectStatements> procedure, boolean ignoreVirtual);
+ void forEachDirectPredicate(ReadGraphImpl graph, Resource subject, AsyncProcedure<Set<Resource>> procedure);
void forObjectSet(ReadGraphImpl graph, Resource subject, Resource predicate, AsyncSetListener<Resource> procedure);
void forPredicateSet(ReadGraphImpl graph, Resource subject, AsyncSetListener<Resource> procedure);
void forPrincipalTypeSet(ReadGraphImpl graph, Resource subject, AsyncSetListener<Resource> procedure);
void forEachPrincipalType(ReadGraphImpl graph, Resource subject, AsyncMultiProcedure<Resource> procedure);
void forEachPrincipalType(ReadGraphImpl graph, Resource subject, MultiProcedure<Resource> procedure);
- void forRelationInfo(ReadGraphImpl graph, Resource subject, AsyncProcedure<RelationInfo> procedure);
+ RelationInfo getRelationInfo(ReadGraphImpl graph, Resource subject) throws DatabaseException;
+
void forTypes(ReadGraphImpl graph, Resource subject, AsyncProcedure<Set<Resource>> procedure);
IntSet getTypes(ReadGraphImpl graph, Resource subject) throws Throwable;
void forSupertypes(ReadGraphImpl graph, Resource subject, AsyncProcedure<Set<Resource>> procedure);
void forPossibleSuperrelation(ReadGraphImpl graph, Resource subject, AsyncProcedure<Resource> procedure);
void forSuperrelations(ReadGraphImpl graph, Resource subject, AsyncProcedure<Set<Resource>> procedure);
byte[] getValue(ReadGraphImpl graph, Resource subject) throws DatabaseException;
- byte[] forValue(ReadGraphImpl graph, Resource subject, AsyncProcedure<byte[]> procedure);
+ void forValue(ReadGraphImpl graph, Resource subject, AsyncProcedure<byte[]> procedure);
void forPossibleValue(ReadGraphImpl graph, Resource subject, AsyncProcedure<byte[]> procedure);
void forInverse(ReadGraphImpl graph, Resource relation, AsyncProcedure<Resource> procedure);
void forResource(ReadGraphImpl graph, String id, AsyncProcedure<Resource> procedure);
void forHasValue(ReadGraphImpl graph, Resource subject, AsyncProcedure<Boolean> procedure);
void forOrderedSet(ReadGraphImpl graph, Resource subject, AsyncMultiProcedure<Resource> procedure);
- <T> T queryRead(ReadGraphImpl graph, Read<T> request, CacheEntry parent, AsyncProcedure<T> procedure, ListenerBase listener) throws Throwable;
- <T> void query(ReadGraphImpl graph, MultiRead<T> request, CacheEntry parent, AsyncMultiProcedure<T> procedure, ListenerBase listener);
- <T> void query(ReadGraphImpl graph, AsyncRead<T> request, CacheEntry parent, AsyncProcedure<T> procedure, ListenerBase listener);
+ <T> void query(ReadGraphImpl graph, MultiRead<T> request, CacheEntry parent, SyncMultiProcedure<T> procedure, ListenerBase listener);
<T> void query(ReadGraphImpl graph, AsyncMultiRead<T> request, CacheEntry parent, AsyncMultiProcedure<T> procedure, ListenerBase listener);
- <T> void query(ReadGraphImpl graph, ExternalRead<T> request, CacheEntry parent, Procedure<T> procedure, ListenerBase listener);
-
- <T> T tryQuery(final ReadGraphImpl graph, final Read<T> request) throws DatabaseException;
- <T> void tryQuery(final ReadGraphImpl graph, final AsyncRead<T> request, final AsyncProcedure<T> procedure);
-
+
VirtualGraph getProvider(Resource subject, Resource predicate, Resource object);
VirtualGraph getProvider(Resource subject, Resource predicate);
VirtualGraph getValueProvider(Resource subject);
/*******************************************************************************
- * Copyright (c) 2007, 2010 Association for Decentralized Information Management
+ * Copyright (c) 2007, 2018 Association for Decentralized Information Management
* in Industry THTH ry.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
return new WriteGraphImpl(parent, processor, writeSupport, provider);
}
- @Override
- final public ReadGraphImpl withAsyncParent(CacheEntry parent2) {
- return new WriteGraphImpl(parent2, processor, writeSupport, provider);
- }
-
@Override
public ReadGraphImpl newRestart(ReadGraphImpl impl) {
Layer0 b = getBuiltins();
initBuiltinValues(b);
-
+
Statement literalStatement = getPossibleStatement(resource, predicate);
if(literalStatement != null && resource.equals(literalStatement.getSubject())) {
*******************************************************************************/
package org.simantics.db.impl.procedure;
+import org.simantics.db.exception.DatabaseException;
import org.simantics.db.impl.graph.ReadGraphImpl;
public interface InternalProcedure<Result> {
- void execute(ReadGraphImpl graph, Result result);
- void exception(ReadGraphImpl graph, Throwable throwable);
+ void execute(ReadGraphImpl graph, Result result) throws DatabaseException;
+ void exception(ReadGraphImpl graph, Throwable throwable) throws DatabaseException;
}
--- /dev/null
+/*******************************************************************************
+ * Copyright (c) 2018 Association for Decentralized Information Management
+ * in Industry THTH ry.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ * Semantum Oy - initial API and implementation
+ *******************************************************************************/
+package org.simantics.db.impl.procedure;
+
+import java.util.ArrayList;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+import org.simantics.db.ReadGraph;
+import org.simantics.db.common.utils.Logger;
+import org.simantics.db.procedure.SyncMultiProcedure;
+
+public class ResultCallWrappedSyncQueryProcedure<Result> implements SyncMultiProcedure<Result> {
+
+ private final ArrayList<Result> result;
+ private Throwable exception = null;
+ private final SyncMultiProcedure<Result> procedure;
+ private final AtomicBoolean latch;
+
+ public ResultCallWrappedSyncQueryProcedure(SyncMultiProcedure<Result> procedure) {
+ this.procedure = procedure;
+ latch = new AtomicBoolean(false);
+ result = new ArrayList<Result>();
+ }
+
+ @Override
+ public void execute(ReadGraph graph, Result result) {
+ try {
+ synchronized(this.result) {
+ this.result.add(result);
+ }
+ procedure.execute(graph, result);
+ } catch (Throwable t) {
+ Logger.defaultLogError("AsyncMultiProcedure.execute failed for " + procedure, t);
+ }
+ }
+
+ @Override
+ public void finished(ReadGraph graph) {
+ if(latch.compareAndSet(false, true)) {
+ try {
+ procedure.finished(graph);
+ } catch (Throwable t) {
+ Logger.defaultLogError("AsyncMultiProcedure.exception failed for " + procedure, t);
+ } finally {
+ }
+ } else {
+ Logger.defaultLogError("Finished or exception was called many times (this time is finished)");
+ }
+ }
+
+ @Override
+ public void exception(ReadGraph graph, Throwable t) {
+ if(latch.compareAndSet(false, true)) {
+ try {
+ this.exception = t;
+ procedure.exception(graph, t);
+ } catch (Throwable throwable) {
+ Logger.defaultLogError("AsyncMultiProcedure.exception failed for " + procedure, throwable);
+ } finally {
+ }
+ } else {
+ Logger.defaultLogError("Finished or exception was called many times (this time is exception)");
+ }
+ }
+
+ public ArrayList<Result> get() {
+ return result;
+ }
+
+ public Throwable getException() {
+ return exception;
+ }
+
+ @Override
+ public String toString() {
+ return "ResultCallWrappedQueryProcedure4[" + procedure + "]";
+ }
+
+}
*******************************************************************************/
package org.simantics.db.impl.procedure;
+import org.simantics.db.exception.DatabaseException;
import org.simantics.db.impl.graph.ReadGraphImpl;
import org.simantics.db.impl.query.TripleIntProcedure;
public TripleIntProcedureAdapter() {
}
@Override
- public void execute(ReadGraphImpl graph, int s, int p, int o) {
+ public void execute(ReadGraphImpl graph, int s, int p, int o) throws DatabaseException {
}
@Override
- public void finished(ReadGraphImpl graph) {
+ public void finished(ReadGraphImpl graph) throws DatabaseException {
}
}
*******************************************************************************/
package org.simantics.db.impl.query;
-import java.util.concurrent.Semaphore;
-
import org.simantics.db.RelationInfo;
+import org.simantics.db.exception.DatabaseException;
import org.simantics.db.impl.graph.ReadGraphImpl;
import org.simantics.db.impl.procedure.IntProcedureAdapter;
-import org.simantics.db.impl.procedure.InternalProcedure;
-import org.simantics.db.procedure.ListenerBase;
-final public class AssertedPredicates extends CollectionUnaryQuery<IntProcedure> {
-
-// public ArrayList<IntProcedure> procs = null;
+final public class AssertedPredicates extends UnaryQuery<IntProcedure> {
- public AssertedPredicates(final int r) {
+ AssertedPredicates(final int r) {
super(r);
}
public static AssertedPredicates newInstance(final int r) {
return new AssertedPredicates(r);
}
-
- final static void runner(ReadGraphImpl graph, final int r, final QueryProcessor provider, final CacheEntry parent, final ListenerBase listener, final IntProcedure procedure) {
-
- AssertedPredicates entry = (AssertedPredicates)provider.assertedPredicatesMap.get(r);
- if(entry == null) {
-
- entry = new AssertedPredicates(r);
- entry.setPending();
- entry.clearResult(provider.querySupport);
- entry.putEntry(provider);
-
- provider.performForEach(graph, entry, parent, listener, procedure);
-
- } else {
-
- if(!entry.isReady()) {
- synchronized(entry) {
- if(!entry.isReady()) {
- throw new IllegalStateException();
-// if(entry.procs == null) entry.procs = new ArrayList<IntProcedure>();
-// entry.procs.add(procedure);
-// return;
- }
- }
- }
- provider.performForEach(graph, entry, parent, listener, procedure);
- }
+ @Override
+ final public void clearResult(QuerySupport support) {
+ setResult(new IntArray());
}
- final public static void queryEach(ReadGraphImpl graph, final int r, final QueryProcessor provider, final CacheEntry parent, final ListenerBase listener, final IntProcedure procedure) {
-
- if(parent == null && listener == null) {
- AssertedPredicates entry = (AssertedPredicates)provider.assertedPredicatesMap.get(r);
- if(entry != null && entry.isReady()) {
- entry.performFromCache(graph, provider, procedure);
- return;
- }
- }
-
- runner(graph, r, provider, parent, listener, procedure);
-
- }
-
@Override
- public UnaryQuery<IntProcedure> getEntry(QueryProcessor provider) {
- return provider.assertedPredicatesMap.get(id);
+ final public void setReady() {
+ super.setReady();
+ IntArray v = (IntArray)getResult();
+ int size = v.size();
+ if(size == 0) setResult(IntArray.EMPTY);
+ else v.trim();
}
-
- @Override
- public void putEntry(QueryProcessor provider) {
- provider.assertedPredicatesMap.put(id, this);
- }
-
+
@Override
final public void removeEntry(QueryProcessor provider) {
- provider.assertedPredicatesMap.remove(id);
+ provider.cache.remove(this);
}
- void computeInheritedAssertions(ReadGraphImpl graph, int type, final QueryProcessor queryProvider, final IntProcedure proc, final boolean store) {
+ void computeInheritedAssertions(ReadGraphImpl graph, int type, final IntProcedure proc) throws DatabaseException {
+
+ QueryProcessor processor = graph.processor;
- DirectObjects.queryEach(graph, type, queryProvider.getInherits(), queryProvider, this, null, new SyncIntProcedure() {
+ QueryCache.runnerDirectObjects(graph, type, processor.getInherits(), this, null, new SyncIntProcedure() {
@Override
public void run(ReadGraphImpl graph) {
-
-// finish(graph, queryProvider);
-// proc.finished(graph);
-
}
@Override
- public void execute(ReadGraphImpl graph,int inh) {
+ public void execute(ReadGraphImpl graph,int inh) throws DatabaseException {
inc();
- AssertedPredicates.queryEach(graph, inh, queryProvider, AssertedPredicates.this, null, new IntProcedure() {
+ QueryCache.runnerAssertedPredicates(graph, inh, AssertedPredicates.this, null, new IntProcedure() {
@Override
public void execute(ReadGraphImpl graph, int ass) {
-
addOrSet(ass);
-// proc.execute(graph, ass);
-
}
@Override
- public void finished(ReadGraphImpl graph) {
+ public void finished(ReadGraphImpl graph) throws DatabaseException {
dec(graph);
}
@Override
public void exception(ReadGraphImpl graph, Throwable t) {
-// proc.exception(graph, t);
}
});
}
@Override
- public void finished(ReadGraphImpl graph) {
-
+ public void finished(ReadGraphImpl graph) throws DatabaseException {
dec(graph);
-
}
});
}
- @Override
- public Object computeForEach(ReadGraphImpl graph, final QueryProcessor queryProvider, final IntProcedure proc, final boolean store) {
+ //@Override
+ public Object compute(ReadGraphImpl graph, final IntProcedure proc) throws DatabaseException {
- computeInheritedAssertions(graph, id, queryProvider, proc, store);
+ QueryProcessor processor = graph.processor;
+
+ computeInheritedAssertions(graph, id, proc);
- DirectObjects.queryEach(graph, id, queryProvider.getAsserts(), queryProvider, this, null, new IntProcedure() {
+ QueryCache.runnerDirectObjects(graph, id, processor.getAsserts(), this, null, new IntProcedure() {
@Override
- public void execute(ReadGraphImpl graph, final int ass) {
+ public void execute(ReadGraphImpl graph, final int ass) throws DatabaseException {
- DirectObjects.queryEach(graph, ass, queryProvider.getHasPredicate(), queryProvider, AssertedPredicates.this, null, new IntProcedure() {
+ QueryCache.runnerDirectObjects(graph, ass, processor.getHasPredicate(), AssertedPredicates.this, null, new IntProcedure() {
@Override
- public void execute(ReadGraphImpl graph, final int pred) {
+ public void execute(ReadGraphImpl graph, final int pred) throws DatabaseException {
addOrSetHiding(graph, pred, AssertedPredicates.this);
-// proc.execute(graph, pred);
return;
}
});
- finish(graph, queryProvider);
+ finish(graph, processor);
- performFromCache(graph, queryProvider, proc);
+ performFromCache(graph, proc);
return getResult();
assert(!isReady());
-// ArrayList<IntProcedure> p = null;
-
synchronized(this) {
-
setReady();
-// p = procs;
-// procs = null;
-
}
-// if(p != null) {
-// IntArray v = (IntArray)getResult();
-// if(v.data == null) {
-// if(v.sizeOrData != IntArray.NO_DATA) {
-// for(IntProcedure proc : p) proc.execute(graph, v.sizeOrData);
-// }
-// } else {
-// for(IntProcedure proc : p) {
-// for(int i = 0;i < v.sizeOrData ; i++) proc.execute(graph, v.data[i]);
-// }
-// }
-//
-// for(IntProcedure proc : p) proc.finished(graph);
-// }
-
}
synchronized private void addOrSet(int add) {
}
- final static InternalProcedure<RelationInfo> ip = new InternalProcedure<RelationInfo>() {
-
- @Override
- public void execute(ReadGraphImpl graph, RelationInfo result) {
- }
-
- @Override
- public void exception(ReadGraphImpl graph, Throwable throwable) {
- }
-
- };
-
- final static InternalProcedure<IntSet> ip2 = new InternalProcedure<IntSet>() {
-
- @Override
- public void execute(ReadGraphImpl graph, IntSet result) {
- }
-
- @Override
- public void exception(ReadGraphImpl graph, Throwable throwable) {
- }
-
- };
-
- synchronized private void addOrSetHiding(ReadGraphImpl graph, int add, CacheEntry parent) {
+ synchronized private void addOrSetHiding(ReadGraphImpl graph, int add, CacheEntry parent) throws DatabaseException {
assert(isPending());
IntArray value = (IntArray)getResult();
- RelationInfo ri = RelationInfoQuery.queryEach(graph, add, graph.processor, parent, null, ip);
+ RelationInfo ri = QueryCacheBase.resultRelationInfoQuery(graph, add, parent, null);
if(ri.isFunctional) {
// Replace existing functional predicate if found
try {
- IntSet supers = SuperRelations.queryEach2(graph, add, graph.processor, parent, null, ip2);
+ IntSet supers = QueryCache.resultSuperRelations(graph, add, parent, null);
if(value.data == null) {
if(value.sizeOrData != IntArray.NO_DATA) {
if(supers.contains(value.sizeOrData)) {
}
@Override
- public Object performFromCache(ReadGraphImpl graph, QueryProcessor provider, final IntProcedure procedure) {
+ public Object performFromCache(ReadGraphImpl graph, final IntProcedure procedure) throws DatabaseException {
assert(isReady());
}
@Override
- public void recompute(ReadGraphImpl graph, QueryProcessor provider) {
-
- final Semaphore s = new Semaphore(0);
+ public void recompute(ReadGraphImpl graph) throws DatabaseException {
- computeForEach(graph, provider, new IntProcedureAdapter() {
+ compute(graph, new IntProcedureAdapter() {
@Override
public void finished(ReadGraphImpl graph) {
- s.release();
}
@Override
public void exception(ReadGraphImpl graph, Throwable t) {
- s.release();
new Error("Error in recompute.", t).printStackTrace();
}
- }, true);
-
- while(!s.tryAcquire()) {
- provider.resume(graph);
- }
+ });
}
-
}
/*******************************************************************************
- * Copyright (c) 2007, 2010 Association for Decentralized Information Management
+ * Copyright (c) 2007, 2018 Association for Decentralized Information Management
* in Industry THTH ry.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
*******************************************************************************/
package org.simantics.db.impl.query;
-import java.util.concurrent.Semaphore;
import java.util.concurrent.atomic.AtomicInteger;
import org.simantics.db.RelationInfo;
+import org.simantics.db.exception.DatabaseException;
import org.simantics.db.exception.ManyObjectsForFunctionalRelationException;
import org.simantics.db.impl.graph.ReadGraphImpl;
import org.simantics.db.impl.procedure.InternalProcedure;
import org.simantics.db.impl.procedure.TripleIntProcedureAdapter;
-import org.simantics.db.procedure.ListenerBase;
import org.simantics.db.request.RequestFlags;
final public class AssertedStatements extends CollectionBinaryQuery<TripleIntProcedure> {
-// public ArrayList<TripleIntProcedure> procs;
-
public AssertedStatements(final int r1, final int r2) {
super(r1, r2);
}
public static AssertedStatements newInstance(final int r1, final int r2) {
return new AssertedStatements(r1, r2);
}
-
- final static AssertedStatements runner(ReadGraphImpl graph, final int r1, final int r2, final QueryProcessor provider, final AssertedStatements cached, final CacheEntry parent, final ListenerBase listener, final TripleIntProcedure procedure) {
-
- AssertedStatements entry = cached != null ? cached : (AssertedStatements)provider.assertedStatementsMap.get(id(r1,r2));
- if(entry == null) {
-
- entry = new AssertedStatements(r1, r2);
- entry.setPending();
- entry.clearResult(provider.querySupport);
- entry.putEntry(provider);
-
- provider.performForEach(graph, entry, parent, listener, procedure);
-
- return entry;
-
- } else {
-
- if(entry.isPending()) {
- synchronized(entry) {
- if(entry.isPending()) {
- throw new IllegalStateException();
-// if(entry.procs == null) entry.procs = new ArrayList<TripleIntProcedure>();
-// entry.procs.add(procedure);
-// provider.registerDependencies(graph, entry, parent, listener, procedure, false);
-// return entry;
- }
- }
- }
- provider.performForEach(graph, entry, parent, listener, procedure);
- }
-
- return entry;
-
- }
-
- final public static AssertedStatements queryEach(ReadGraphImpl graph, final int r1, final int r2, final QueryProcessor provider, final CacheEntry parent, final ListenerBase listener, final TripleIntProcedure procedure) {
-
- assert(r1 != 0);
- assert(r2 != 0);
-
- final AssertedStatements entry = (AssertedStatements)provider.assertedStatementsMap.get(id(r1,r2));
-
- if(parent == null && !(listener != null)) {
- if(entry != null && entry.isReady()) {
- entry.performFromCache(graph, provider, procedure);
- return entry;
- }
- }
-
- return runner(graph, r1, r2, provider, entry, parent, listener, procedure);
-
- }
-
- @Override
- public BinaryQuery<TripleIntProcedure> getEntry(QueryProcessor provider) {
- return provider.assertedStatementsMap.get(id);
- }
-
- @Override
- public void putEntry(QueryProcessor provider) {
- provider.assertedStatementsMap.put(id, this);
- }
@Override
final public void removeEntry(QueryProcessor provider) {
- provider.assertedStatementsMap.remove(id);
+ provider.cache.remove(this);
}
- void computeInheritedAssertions(ReadGraphImpl graph, int type, final int predicate, final RelationInfo ri, final QueryProcessor queryProvider, final TripleIntProcedure proc) {
+ static void computeInheritedAssertions(ReadGraphImpl graph, int type, final int predicate, final RelationInfo ri, final AssertedStatements entry, final TripleIntProcedure proc) throws DatabaseException {
-// final AtomicBoolean found = new AtomicBoolean(0);
+ QueryProcessor processor = graph.processor;
- DirectObjects.queryEach(graph, type, queryProvider.getInherits(), queryProvider, this, null, new SyncIntProcedure() {
+ QueryCache.runnerDirectObjects(graph, type, processor.getInherits(), entry, null, new SyncIntProcedure() {
@Override
- public void run(ReadGraphImpl graph) {
+ public void run(ReadGraphImpl graph) throws DatabaseException {
// if(ri.isFunctional && found.get() == 1) {
//
//
// }
- finish(graph, queryProvider);
+ finish(graph, entry);
proc.finished(graph);
}
@Override
- public void execute(ReadGraphImpl graph, int inh) {
+ public void execute(ReadGraphImpl graph, int inh) throws DatabaseException {
// if(ri.isFunctional && found.get() == 1) return;
inc();
- AssertedStatements.queryEach(graph, inh, predicate, queryProvider, AssertedStatements.this, null, new TripleIntProcedureAdapter() {
+ QueryCache.runnerAssertedStatements(graph, inh, predicate, entry, null, new TripleIntProcedureAdapter() {
@Override
- public void execute(ReadGraphImpl graph, int s, int p, int o) {
+ public void execute(ReadGraphImpl graph, int s, int p, int o) throws DatabaseException {
// if(ri.isFunctional) {
//
//// if(found.get() == 1) return;
//
// if(found.compareAndSet(0, o)) {
- if(addOrSet(s,p,o))
+ if(addOrSet(s,p,o, entry))
proc.execute(graph, s, p, o);
// }
// // If this was a duplicate, we can ignore this
}
@Override
- public void finished(ReadGraphImpl graph) {
+ public void finished(ReadGraphImpl graph) throws DatabaseException {
dec(graph);
}
@Override
- public void exception(ReadGraphImpl graph, Throwable t) {
+ public void exception(ReadGraphImpl graph, Throwable t) throws DatabaseException {
proc.exception(graph, t);
dec(graph);
}
}
@Override
- public void finished(ReadGraphImpl graph) {
+ public void finished(ReadGraphImpl graph) throws DatabaseException {
dec(graph);
}
}
- void computeLocalAssertions(ReadGraphImpl graph, final int type, final int predicate, final RelationInfo ri, final QueryProcessor queryProvider, final TripleIntProcedure proc) {
+ static void computeLocalAssertions(ReadGraphImpl graph, final int type, final int predicate, final RelationInfo ri, final AssertedStatements entry, final TripleIntProcedure proc) throws DatabaseException {
+
+ }
+
+ //@Override
+ public Object compute(ReadGraphImpl graph, final TripleIntProcedure procedure) throws DatabaseException {
+ computeForEach(graph, r1(), r2(), this, procedure);
+ return getResult();
+ }
+
+ public static void computeForEach(ReadGraphImpl graph, final int type, final int predicate, final AssertedStatements entry, final TripleIntProcedure procedure) throws DatabaseException {
+
+ RelationInfo ri = QueryCache.resultRelationInfoQuery(graph, predicate, entry, null);
+
final AtomicInteger found = new AtomicInteger(0);
- DirectObjects.queryEach(graph, type, queryProvider.getAsserts(), queryProvider, this, null, new SyncIntProcedure() {
+ QueryProcessor processor = graph.processor;
+
+ QueryCache.runnerDirectObjects(graph, type, processor.getAsserts(), entry, null, new SyncIntProcedure() {
@Override
- public void run(ReadGraphImpl graph) {
+ public void run(ReadGraphImpl graph) throws DatabaseException {
if(ri.isFunctional && found.get() > 1) {
ManyObjectsForFunctionalRelationException exception = new ManyObjectsForFunctionalRelationException("Functional relation has more than one asserted statement.");
- except(exception);
- proc.exception(graph, exception);
+ except(exception, entry);
+ procedure.exception(graph, exception);
return;
}
if(ri.isFunctional && found.get() == 1) {
- finish(graph, queryProvider);
- proc.finished(graph);
+ finish(graph, entry);
+ procedure.finished(graph);
return;
}
- computeInheritedAssertions(graph, type, predicate, ri, queryProvider, proc);
+ computeInheritedAssertions(graph, type, predicate, ri, entry, procedure);
}
@Override
- public void execute(ReadGraphImpl graph, final int ass) {
+ public void execute(ReadGraphImpl graph, final int ass) throws DatabaseException {
if(ri.isFunctional && found.get() > 1) return;
inc();
- DirectObjects.queryEach(graph, ass, queryProvider.getHasPredicate(), queryProvider, AssertedStatements.this, null, new IntProcedure() {
+ QueryCache.runnerDirectObjects(graph, ass, processor.getHasPredicate(), entry, null, new IntProcedure() {
@Override
- public void execute(ReadGraphImpl graph, final int pred) {
+ public void execute(ReadGraphImpl graph, final int pred) throws DatabaseException {
if(ri.isFunctional) {
inc();
- DirectObjects.queryEach(graph, ass, queryProvider.getHasObject(), queryProvider, AssertedStatements.this, null, new IntProcedure() {
+ QueryCache.runnerDirectObjects(graph, ass, processor.getHasObject(), entry, null, new IntProcedure() {
@Override
- public void execute(ReadGraphImpl graph, final int object) {
+ public void execute(ReadGraphImpl graph, final int object) throws DatabaseException {
if(found.get() > 1) return;
if(pred == predicate) {
if(found.getAndIncrement() == 0) {
- if(addOrSet(type, pred, object))
- proc.execute(graph, type, pred, object);
+ if(addOrSet(type, pred, object, entry))
+ procedure.execute(graph, type, pred, object);
}
return;
inc();
- SuperRelations.queryEach(graph, pred, queryProvider, AssertedStatements.this, null, new InternalProcedure<IntSet>() {
+ QueryCache.runnerSuperRelations(graph, pred, entry, null, new InternalProcedure<IntSet>() {
@Override
- public void execute(ReadGraphImpl graph, IntSet result) {
+ public void execute(ReadGraphImpl graph, IntSet result) throws DatabaseException {
if(found.get() > 1) {
dec(graph);
if(result.contains(predicate)) {
if(found.getAndIncrement() == 0) {
- if(addOrSet(type, pred, object))
- proc.execute(graph, type, pred, object);
+ if(addOrSet(type, pred, object, entry))
+ procedure.execute(graph, type, pred, object);
}
}
}
@Override
- public void exception(ReadGraphImpl graph, Throwable t) {
+ public void exception(ReadGraphImpl graph, Throwable t) throws DatabaseException {
- proc.exception(graph, t);
+ procedure.exception(graph, t);
dec(graph);
}
}
@Override
- public void finished(ReadGraphImpl graph) {
+ public void finished(ReadGraphImpl graph) throws DatabaseException {
dec(graph);
}
@Override
- public void exception(ReadGraphImpl graph, Throwable t) {
- proc.exception(graph, t);
+ public void exception(ReadGraphImpl graph, Throwable t) throws DatabaseException {
+ procedure.exception(graph, t);
dec(graph);
}
inc();
- DirectObjects.queryEach(graph, ass, queryProvider.getHasObject(), queryProvider, AssertedStatements.this, null, new IntProcedure() {
+ QueryCache.runnerDirectObjects(graph, ass, processor.getHasObject(), entry, null, new IntProcedure() {
@Override
- public void execute(ReadGraphImpl graph, final int object) {
+ public void execute(ReadGraphImpl graph, final int object) throws DatabaseException {
if(pred == predicate) {
- addOrSet(type, pred, object);
- proc.execute(graph, type, pred, object);
+ addOrSet(type, pred, object, entry);
+ procedure.execute(graph, type, pred, object);
return;
}
inc();
- SuperRelations.queryEach(graph, pred, queryProvider, AssertedStatements.this, null, new InternalProcedure<IntSet>() {
+ QueryCache.runnerSuperRelations(graph, pred, entry, null, new InternalProcedure<IntSet>() {
@Override
- public void execute(ReadGraphImpl graph, IntSet result) {
+ public void execute(ReadGraphImpl graph, IntSet result) throws DatabaseException {
if(result.contains(predicate)) {
- addOrSet(type, pred, object);
- proc.execute(graph, type, pred, object);
+ addOrSet(type, pred, object, entry);
+ procedure.execute(graph, type, pred, object);
}
}
@Override
- public void exception(ReadGraphImpl graph, Throwable t) {
- proc.exception(graph, t);
+ public void exception(ReadGraphImpl graph, Throwable t) throws DatabaseException {
+ procedure.exception(graph, t);
dec(graph);
}
}
@Override
- public void finished(ReadGraphImpl graph) {
+ public void finished(ReadGraphImpl graph) throws DatabaseException {
dec(graph);
}
@Override
- public void exception(ReadGraphImpl graph, Throwable t) {
- proc.exception(graph, t);
+ public void exception(ReadGraphImpl graph, Throwable t) throws DatabaseException {
+ procedure.exception(graph, t);
dec(graph);
}
}
@Override
- public void finished(ReadGraphImpl graph) {
+ public void finished(ReadGraphImpl graph) throws DatabaseException {
dec(graph);
}
@Override
- public void exception(ReadGraphImpl graph, Throwable t) {
- proc.exception(graph, t);
+ public void exception(ReadGraphImpl graph, Throwable t) throws DatabaseException {
+ procedure.exception(graph, t);
dec(graph);
}
}
@Override
- public void finished(ReadGraphImpl graph) {
+ public void finished(ReadGraphImpl graph) throws DatabaseException {
dec(graph);
}
});
- }
-
- @Override
- public void computeForEach(ReadGraphImpl graph, final QueryProcessor provider, final TripleIntProcedure procedure, boolean store) {
-
- RelationInfoQuery.queryEach(graph, r2(), provider, this, null, new InternalProcedure<RelationInfo>() {
-
- @Override
- public void execute(ReadGraphImpl graph, RelationInfo ri) {
-
- computeLocalAssertions(graph, r1(), r2(), ri, provider, procedure);
-
- }
-
- @Override
- public void exception(ReadGraphImpl graph, Throwable t) {
- procedure.exception(graph, t);
- }
-
- });
-
}
@Override
public String toString() {
- return "AssertedStatements2[" + r1() + " - " + r2() + "]";
+ return "AssertedStatements[" + r1() + " - " + r2() + "]";
}
private boolean addOrSet(int s, int p, int o) {
-
+
assert(isPending());
IntArray value = (IntArray)getResult();
}
- final private void finish(ReadGraphImpl graph, QueryProcessor provider) {
+ static boolean addOrSet(int s, int p, int o, AssertedStatements entry) {
+ if(entry != null) {
+ return entry.addOrSet(s, p, o);
+ } else {
+ return true;
+ }
+ }
+
+ static void finish(ReadGraphImpl graph, AssertedStatements entry) {
- assert(isPending());
-
-// ArrayList<TripleIntProcedure> p = null;
-
- synchronized(this) {
-
- setReady();
-// p = procs;
-// procs = null;
-
- }
-
-// if(p != null) {
-// final IntArray value = (IntArray)getResult();
-// for(TripleIntProcedure proc : p) {
-// for(int i=0;i<value.size();i+=3) {
-// proc.execute(graph, value.data[i], value.data[i+1], value.data[i+2]);
-// }
-// }
-//
-// for(TripleIntProcedure proc : p) proc.finished(graph);
-// }
+ assert(entry.isPending());
+ if(entry != null) {
+ synchronized(entry) {
+ entry.setReady();
+ }
+ }
}
+
+ static void except(Throwable t, AssertedStatements entry) {
+ if(entry != null) {
+ synchronized(entry) {
+ entry.except(t);
+ }
+ }
+ }
@Override
- public void performFromCache(ReadGraphImpl graph, QueryProcessor provider, final TripleIntProcedure procedure) {
+ public Object performFromCache(ReadGraphImpl graph, final TripleIntProcedure procedure) throws DatabaseException {
assert(isReady());
- if(handleException(graph, procedure)) return;
+ if(handleException(graph, procedure)) return getResult();
final IntArray value = (IntArray)getResult();
for(int i=0;i<value.size();i+=3) {
procedure.finished(graph);
+ return value;
+
}
@Override
- public void recompute(ReadGraphImpl graph, QueryProcessor provider) {
+ public void recompute(ReadGraphImpl graph) throws DatabaseException {
- final Semaphore s = new Semaphore(0);
-
- computeForEach(graph, provider, new TripleIntProcedureAdapter() {
+ compute(graph, new TripleIntProcedureAdapter() {
@Override
public void finished(ReadGraphImpl graph) {
- s.release();
}
@Override
throw new Error("Error in recompute", t);
}
- }, true);
-
- try {
- s.acquire();
- } catch (InterruptedException e) {
- throw new Error(e);
- }
+ });
}
/*******************************************************************************
- * Copyright (c) 2007, 2010 Association for Decentralized Information Management
+ * Copyright (c) 2007, 2018 Association for Decentralized Information Management
* in Industry THTH ry.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
import java.util.ArrayList;
import org.simantics.db.AsyncReadGraph;
-import org.simantics.db.common.exception.DebugException;
+import org.simantics.db.exception.DatabaseException;
+import org.simantics.db.impl.BlockingAsyncMultiProcedure;
import org.simantics.db.impl.graph.ReadGraphImpl;
import org.simantics.db.procedure.AsyncMultiProcedure;
import org.simantics.db.request.AsyncMultiRead;
import org.simantics.db.request.RequestFlags;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
-final public class AsyncMultiReadEntry<T> extends CacheEntryBase {
+final public class AsyncMultiReadEntry<T> extends CacheEntryBase<AsyncMultiProcedure<T>> {
-// public ArrayList<AsyncMultiProcedure<T>> procs = null;
+ private static final Logger LOGGER = LoggerFactory.getLogger(AsyncMultiReadEntry.class);
protected AsyncMultiRead<T> request;
- public AsyncMultiReadEntry(AsyncMultiRead<T> request) {
+ AsyncMultiReadEntry(AsyncMultiRead<T> request) {
this.request = request;
}
final synchronized public void finish(AsyncReadGraph graph) {
-// new Exception("finish " + this).printStackTrace();
-
- if(!isPending()) {
- System.err.println("aff");
- }
-
assert(isPending());
-// ArrayList<AsyncMultiProcedure<T>> p = null;
-
synchronized(this) {
-
setReady();
-// p = procs;
-// procs = null;
-
}
-// if(p != null) {
-// ArrayList<T> v = (ArrayList<T>)getResult();
-// if(v != null) {
-// for(AsyncMultiProcedure<T> proc : p) {
-// for(T t : v) proc.execute(graph, t);
-// }
-// }
-//
-// for(AsyncMultiProcedure<T> proc : p) proc.finished(graph);
-// }
-
}
final synchronized public void except(AsyncReadGraph graph, Throwable t) {
assert(isPending());
-// ArrayList<AsyncMultiProcedure<T>> p = null;
-
synchronized(this) {
-
except(t);
-// p = procs;
-// procs = null;
-
}
-// if(p != null) {
-// for(AsyncMultiProcedure<T> proc : p) proc.exception(graph, t);
-// }
-
}
@SuppressWarnings("unchecked")
return new Query() {
@Override
- public void recompute(ReadGraphImpl graph, Object provider, CacheEntry entry) {
-
- QueryProcessor qp = (QueryProcessor)provider;
-
- final ReadGraphImpl parentGraph = ReadGraphImpl.forRecompute(entry, qp);
+ public void recompute(ReadGraphImpl graph) {
try {
- request.perform(parentGraph , new AsyncMultiProcedure<T>() {
+ BlockingAsyncMultiProcedure<T> proc = new BlockingAsyncMultiProcedure<>(graph, new AsyncMultiProcedure<T>() {
- @Override
- public void execute(AsyncReadGraph graph, T result) {
- addOrSet(result);
- }
-
- public void finished(AsyncReadGraph graph) {
- finish(graph);
- };
-
- @Override
- public void exception(AsyncReadGraph graph, Throwable t) {
- except(t);
- }
+ @Override
+ public void execute(AsyncReadGraph graph, T result) {
+ addOrSet(result);
+ }
- });
+ public void finished(AsyncReadGraph graph) {
+ finish(graph);
+ };
+
+ @Override
+ public void exception(AsyncReadGraph graph, Throwable t) {
+ except(t);
+ }
+
+ }, request);
+
+ request.perform(graph , proc);
+
+ proc.get();
} catch (Throwable t) {
- except(t);
- if(DebugException.DEBUG) new DebugException(t).printStackTrace();
- }
+
+ except(t);
+
+ }
}
@Override
public void removeEntry(QueryProcessor processor) {
- processor.asyncMultiReadMap.remove(request);
+ processor.cache.remove(AsyncMultiReadEntry.this);
}
@Override
@SuppressWarnings("unchecked")
@Override
- public void performFromCache(ReadGraphImpl graph, Object provider, Object procedure) {
-
- final AsyncMultiProcedure<T> proc = (AsyncMultiProcedure<T>)procedure;
+ public Object performFromCache(ReadGraphImpl graph, AsyncMultiProcedure<T> proc) {
if(isExcepted()) {
try {
proc.exception(graph, (Throwable)getResult());
} catch (Throwable t) {
- t.printStackTrace();
+ LOGGER.error("performFromCache proc.exception failed", t);
}
-
-
+
} else {
-
+
final ArrayList<T> values = (ArrayList<T>)getResult();
for(T value : values) {
try {
proc.execute(graph, value);
} catch (Throwable t) {
- t.printStackTrace();
+ LOGGER.error("performFromCache proc.execute failed", t);
}
}
try {
proc.finished(graph);
} catch (Throwable t) {
- t.printStackTrace();
+ LOGGER.error("performFromCache proc.finished failed", t);
}
}
-
+ return getResult();
}
-
-// @Override
-// public void performFromCache(int callerThread, Object provider,
-// Object procedure) {
-//
-// QueryProvider2 queryProvider = (QueryProvider2)provider;
-// ReadGraphImpl graph = ReadGraphImpl.forFromCache(callerThread, null, new ReadGraphSupportImpl(null, queryProvider, null));
-// performFromCache(graph, provider, procedure);
-//
-// }
@Override
public String toString() {
else return request.toString() + statusOrException;
}
+ public Object compute(ReadGraphImpl graph, AsyncMultiProcedure<T> procedure) throws DatabaseException {
+ return graph.processor.cache.performQuery(graph, request, this, procedure);
+ }
+
}
/*******************************************************************************
- * Copyright (c) 2007, 2010 Association for Decentralized Information Management
+ * Copyright (c) 2007, 2018 Association for Decentralized Information Management
* in Industry THTH ry.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
package org.simantics.db.impl.query;
import org.simantics.db.AsyncReadGraph;
+import org.simantics.db.exception.DatabaseException;
+import org.simantics.db.exception.RuntimeDatabaseException;
+import org.simantics.db.impl.BlockingAsyncProcedure;
import org.simantics.db.impl.DebugPolicy;
import org.simantics.db.impl.graph.ReadGraphImpl;
import org.simantics.db.procedure.AsyncProcedure;
import org.simantics.db.request.AsyncRead;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
-final public class AsyncReadEntry<T> extends CacheEntryBase {
+final public class AsyncReadEntry<T> extends CacheEntryBase<AsyncProcedure<T>> implements AsyncProcedure<T> {
+
+ private static final Logger LOGGER = LoggerFactory.getLogger(AsyncReadEntry.class);
protected AsyncRead<T> request;
- public AsyncReadEntry(AsyncRead<T> request) {
- this.request = request;
- if(DebugPolicy.QUERY_STATE) System.out.println("[QUERY STATE]: created " + this);
+ AsyncReadEntry(AsyncRead<T> request) {
+ this.request = request;
+ if (DebugPolicy.QUERY_STATE)
+ System.out.println("[QUERY STATE]: created " + this);
}
@Override
int makeHash() {
- return request.hashCode();
+ return request.hashCode();
}
-
+
@Override
public Object getOriginalRequest() {
return request;
}
-
+
@Override
public void discard() {
- super.discard();
- //request = null;
- setResult(null);
+ super.discard();
+ setResult(null);
}
-
- final public void addOrSet(AsyncReadGraph graph, Object item) {
-
- assert(isPending());
-
-// ArrayList<AsyncProcedure<T>> p = null;
-
- synchronized(this) {
-
- setResult(item);
- setReady();
-// p = procs;
-// procs = null;
-
- }
-// if(p != null)
-// for(AsyncProcedure<T> proc : p) {
-// proc.execute(graph, (T)item);
-//// proc.first.execute(graph, (T)item);
-//// proc.second.dec();
-// }
-
- }
-
-
public void except(AsyncReadGraph graph, Throwable t) {
-
- assert(isPending());
-
-// ArrayList<AsyncProcedure<T>> p = null;
- synchronized(this) {
-
+ assert (isPending());
+
+ synchronized (this) {
except(t);
-//// p = procs;
-// procs = null;
-
}
-// if(p != null)
-// for(AsyncProcedure<T> proc : p) {
-// proc.exception(graph, t);
-// }
-
}
-
-
+
@Override
final public Query getQuery() {
-
- return new Query() {
- @Override
- public void recompute(ReadGraphImpl graph, Object provider, CacheEntry entry) {
-
- QueryProcessor qp = (QueryProcessor)provider;
+ return new Query() {
- final ReadGraphImpl parentGraph = ReadGraphImpl.forRecompute(entry, qp);
+ @Override
+ public void recompute(ReadGraphImpl graph) {
- try {
+ try {
- request.perform(parentGraph , new AsyncProcedure<T>() {
+ BlockingAsyncProcedure<T> proc = new BlockingAsyncProcedure<>(graph, new AsyncProcedure<T>() {
@Override
public void execute(AsyncReadGraph graph, T result) {
- addOrSet(graph, result);
+ setResult(result);
+ setReady();
}
-
- @Override
- public void exception(AsyncReadGraph graph, Throwable t) {
- except(t);
+
+ @Override
+ public void exception(AsyncReadGraph graph, Throwable t) {
+ except(t);
}
- });
+ }, request);
+
+ request.perform(graph, proc);
- } catch (Throwable t) {
- except(t);
+ proc.get();
+
+ } catch (Throwable t) {
+ except(t);
}
-
- }
-
- @Override
- public void removeEntry(QueryProcessor qp) {
- qp.asyncReadMap.remove(request);
- }
-
- @Override
- public int type() {
- return request.getFlags();
- }
-
- @Override
- public String toString() {
- if(request == null) return "DISCARDED";
- else if(isExcepted()) return request.toString() + " " + getResult();
- else return request.toString() + " " + statusOrException;
- }
-
+
+ }
+
+ @Override
+ public void removeEntry(QueryProcessor qp) {
+ qp.cache.remove(AsyncReadEntry.this);
+ }
+
+ @Override
+ public int type() {
+ return request.getFlags();
+ }
+
+ @Override
+ public String toString() {
+ if (request == null)
+ return "DISCARDED";
+ else if (isExcepted())
+ return request.toString() + " " + getResult();
+ else
+ return request.toString() + " " + statusOrException;
+ }
+
};
-
+
}
- @SuppressWarnings("unchecked")
- public void performFromCache(ReadGraphImpl graph, Object provider, Object procedure) {
-
- AsyncProcedure<T> proc = (AsyncProcedure<T>)procedure;
+ @Override
+ public Object performFromCache(ReadGraphImpl graph, AsyncProcedure<T> proc) {
+
+ if (isExcepted()) {
- if(isExcepted()) {
-
try {
- proc.exception(graph, (Throwable)getResult());
+ proc.exception(graph, (Throwable) getResult());
} catch (Throwable t) {
- t.printStackTrace();
+ LOGGER.error("performFromCache proc.exception failed", t);
}
-
+
} else {
-
+
try {
- proc.execute(graph, (T)getResult());
+ proc.execute(graph, (T) getResult());
} catch (Throwable t) {
- t.printStackTrace();
+ LOGGER.error("performFromCache proc.execute failed", t);
}
-
+
}
-
- }
-
- @Override
- public String toString() {
- if(isDiscarded()) return "DISCARDED " + request.toString();
- else if(isExcepted()) return request.toString() + " " + getResult();
- else return request.toString() + " " + statusOrException;
- }
+
+ return getResult();
+
+ }
+
+ public static <T> void computeForEach(ReadGraphImpl parentGraph, AsyncRead<T> request, AsyncReadEntry<T> entry,
+ AsyncProcedure<T> procedure_) throws DatabaseException {
+
+ AsyncProcedure<T> procedure = entry != null ? entry : procedure_;
+
+ ReadGraphImpl queryGraph = parentGraph.withParent(entry);
+
+ BlockingAsyncProcedure<T> proc = new BlockingAsyncProcedure<>(queryGraph, new AsyncProcedure<T>() {
+
+ @Override
+ public void execute(AsyncReadGraph returnGraph, T result) {
+ try {
+ procedure.execute(parentGraph, result);
+ } catch (Throwable t) {
+ LOGGER.error("computeForEach procedure.execute failed", t);
+ }
+ }
+
+ @Override
+ public void exception(AsyncReadGraph returnGraph, Throwable t) {
+ try {
+ procedure.exception(parentGraph, t);
+ } catch (Throwable t2) {
+ LOGGER.error("computeForEach procedure.exception failed", t2);
+ }
+ }
+
+ @Override
+ public String toString() {
+ return procedure.toString();
+ }
+
+ }, request);
+
+ request.perform(queryGraph, proc);
+
+ proc.get();
+
+ if (entry != null)
+ entry.performFromCache(parentGraph, procedure_);
+
+ }
+
+ @Override
+ public String toString() {
+ if (isDiscarded())
+ return "DISCARDED " + request.toString();
+ else if (isExcepted())
+ return request.toString() + " " + getResult();
+ else
+ return request.toString() + " " + statusOrException;
+ }
+
+ @Override
+ public void execute(AsyncReadGraph graph, T result) {
+ setResult(result);
+ setReady();
+ }
+
+ @Override
+ public void exception(AsyncReadGraph graph, Throwable throwable) {
+ except(throwable);
+ }
}
/*******************************************************************************
- * Copyright (c) 2007, 2010 Association for Decentralized Information Management
+ * Copyright (c) 2007, 2018 Association for Decentralized Information Management
* in Industry THTH ry.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
*******************************************************************************/
package org.simantics.db.impl.query;
-import org.simantics.db.impl.graph.ReadGraphImpl;
import org.simantics.db.request.RequestFlags;
-
-abstract public class BinaryQuery<Procedure> extends CacheEntryBase implements Query {
+public abstract class BinaryQuery<Procedure> extends CacheEntryBase<Procedure> implements Query {
final public long id;
final public Query getQuery() {
return this;
}
-
- @Override
- public void recompute(ReadGraphImpl graph, Object provider, CacheEntry entry) {
- recompute(graph, (QueryProcessor)provider);
- }
-
- @SuppressWarnings("unchecked")
- @Override
- public void performFromCache(ReadGraphImpl graph, Object provider, Object procedure) {
- performFromCache(graph, (QueryProcessor)provider, (Procedure)procedure);
- }
- abstract public void recompute(ReadGraphImpl graph, QueryProcessor provider);
- abstract public void computeForEach(ReadGraphImpl graph, QueryProcessor provider, Procedure procedure, boolean store);
- abstract public void performFromCache(ReadGraphImpl graph, QueryProcessor provider, Procedure procedure);
- abstract public void putEntry(QueryProcessor provider);
abstract public void removeEntry(QueryProcessor provider);
- abstract public BinaryQuery<Procedure> getEntry(QueryProcessor provider);
}
import java.lang.reflect.Array;
+import org.simantics.db.exception.DatabaseException;
import org.simantics.db.impl.graph.ReadGraphImpl;
protected final BinaryQuery<Procedure> REMOVED = new BinaryQuery<Procedure>(-1, -1) {
- @Override
- public void computeForEach(ReadGraphImpl graph, QueryProcessor provider, Object procedure, boolean store) {
- throw new Error("Not possible!");
- }
-
- @Override
- public void putEntry(QueryProcessor provider) {
- throw new Error("Not possible!");
- }
-
- @Override
- public BinaryQuery<Procedure> getEntry(QueryProcessor provider) {
- throw new Error("Not possible!");
- }
-
- @Override
- public void recompute(ReadGraphImpl graph, QueryProcessor provider) {
- throw new Error("Not possible!");
- }
-
@Override
public void removeEntry(QueryProcessor provider) {
throw new Error("Not possible!");
}
-// @Override
-// public ICacheEntry2 cachedEntry(Object provider) {
-// throw new Error("Not possible!");
-// }
-//
-// @Override
-// public void computeForEach(int callerThread, Object provider, ICacheEntry2 parent, Object procedure) {
-// throw new Error("Not possible!");
-// }
-
@Override
public int type() {
throw new Error("Not possible!");
}
-// @Override
-// public void reset() {
-// throw new Error("Not possible!");
-// }
-
@Override
- public void performFromCache(ReadGraphImpl graph, QueryProcessor provider,
- Procedure procedure) {
+ Object performFromCache(ReadGraphImpl graph, Procedure procedure) throws DatabaseException {
throw new Error("Not possible!");
}
-// @Override
-// public void performFromCache(int callerThread, Object provider,
-// Object procedure) {
-// throw new Error("Not possible!");
-// }
-
@Override
- public void performFromCache(ReadGraphImpl graph, Object provider,
- Object procedure) {
+ public void recompute(ReadGraphImpl graph) throws DatabaseException {
throw new Error("Not possible!");
}
-public abstract class CacheEntry {
+public abstract class CacheEntry<Procedure> {
final public static int HAS_BEEN_BOUND = 1;
abstract void setPending();
abstract void discard();
abstract void except(Throwable t);
- abstract void setResult(Object result);
abstract void clearResult(QuerySupport support);
abstract void prepareRecompute(QuerySupport querySupport);
abstract public Object getOriginalRequest();
abstract Query getQuery();
- abstract <T> T getResult();
abstract CacheEntry pruneFirstParents();
abstract void removeParent(CacheEntry entry);
abstract void addParent(CacheEntry entry);
abstract boolean hasParents();
- abstract Iterable<CacheEntry> getParents(QueryProcessor processor);
+ abstract Iterable<CacheEntry<?>> getParents(QueryProcessor processor);
abstract CacheEntry getFirstParent(QueryProcessor processor);
abstract boolean moreThanOneParent(QueryProcessor processor);
abstract int parentCount(QueryProcessor processor);
- abstract void performFromCache(ReadGraphImpl graph, Object provider, Object procedure);
+ abstract <T> T getResult();
+ abstract void setResult(Object result);
+
+ abstract Object performFromCache(ReadGraphImpl graph, Procedure procedure) throws DatabaseException;
abstract boolean isImmutable(ReadGraphImpl graph) throws DatabaseException;
/*******************************************************************************
- * Copyright (c) 2007, 2010 Association for Decentralized Information Management
+ * Copyright (c) 2007, 2018 Association for Decentralized Information Management
* in Industry THTH ry.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-abstract public class CacheEntryBase extends CacheEntry {
+public abstract class CacheEntryBase<Procedure> extends CacheEntry<Procedure> {
private static final Logger LOGGER = LoggerFactory.getLogger(CacheEntryBase.class);
final public static CacheEntryBase[] NONE = new CacheEntryBase[0];
- static private Object NO_RESULT = new Object();
+ static Object NO_RESULT = new Object();
static protected Object INVALID_RESULT = new Object();
- // Just created
- static protected Object FRESH = new Object() { public String toString() { return "CREATED"; }};
+// // Just created
+// static protected Object FRESH = new Object() { public String toString() { return "CREATED"; }};
// Result is computed - no exception
static protected Object READY = new Object() { public String toString() { return "READY"; }};
// Computation is under way
// Entry is discarded and is waiting for garbage collect
static protected Object DISCARDED = new Object() { public String toString() { return "DISCARDED"; }};
// The result has been invalidated
- static protected Object REFUTED = new Object() { public String toString() { return "REFUTED"; }};
+ static protected Object REQUIRES_COMPUTATION = new Object() { public String toString() { return "REFUTED"; }};
// The computation has excepted - the exception is in the result
static protected Object EXCEPTED = new Object() { public String toString() { return "EXCEPTED"; }};
// This indicates the status of the entry
- public Object statusOrException = FRESH;
+ public Object statusOrException = REQUIRES_COMPUTATION;
private CacheEntry p1 = null;
private Object p2OrParents = null;
abstract int makeHash();
// This can be tested to see if the result is finished
- private Object result = NO_RESULT;
+ Object result = NO_RESULT;
final public boolean isFresh() {
- return FRESH == statusOrException;
+ return REQUIRES_COMPUTATION == statusOrException;
}
public void setReady() {
@Override
final public void refute() {
if(DebugPolicy.QUERY_STATE) System.out.println("[QUERY STATE]: refuted " + this);
- statusOrException = REFUTED;
+ statusOrException = REQUIRES_COMPUTATION;
}
@Override
final public boolean isRefuted() {
- return REFUTED == statusOrException;
+ return REQUIRES_COMPUTATION == statusOrException;
}
@Override
- final public void except(Throwable t) {
+ public void except(Throwable throwable) {
if(DebugPolicy.QUERY_STATE) System.out.println("[QUERY STATE]: excepted " + this);
if(statusOrException != DISCARDED) {
statusOrException = EXCEPTED;
- result = t;
+ result = throwable;
} else {
- LOGGER.warn("Cache entry got excepted status after being discarded: " + getClass().getSimpleName(), t);
- result = t;
+ LOGGER.warn("Cache entry got excepted status after being discarded: " + getClass().getSimpleName(), throwable);
+ result = throwable;
}
}
}
@Override
- final public void setPending() {
+ public void setPending() {
statusOrException = PENDING;
}
return PENDING == statusOrException;
}
+ final public boolean requiresComputation() {
+ return REQUIRES_COMPUTATION == statusOrException;
+ }
+
final public boolean assertPending() {
boolean result = isPending();
if(!result) {
}
@Override
- final public Iterable<CacheEntry> getParents(QueryProcessor processor) {
+ final public Iterable<CacheEntry<?>> getParents(QueryProcessor processor) {
- ArrayList<CacheEntry> result = new ArrayList<CacheEntry>();
+ ArrayList<CacheEntry<?>> result = new ArrayList<CacheEntry<?>>();
if(p1 != null) result.add(p1);
if(p2OrParents != null) {
if(p2OrParents instanceof QueryIdentityHashSet) {
}
- protected void fillImpliedParents(QueryProcessor processor, ArrayList<CacheEntry> result) {
-
+ protected void fillImpliedParents(QueryProcessor processor, ArrayList<CacheEntry<?>> result) {
}
protected String internalError() {
}
- protected boolean handleException(ReadGraphImpl graph, IntProcedure procedure) {
+ protected boolean handleException(ReadGraphImpl graph, IntProcedure procedure) throws DatabaseException {
if(isExcepted()) {
procedure.exception(graph, (Throwable)getResult());
return true;
}
}
- protected boolean handleException(ReadGraphImpl graph, TripleIntProcedure procedure) {
+ protected boolean handleException(ReadGraphImpl graph, TripleIntProcedure procedure) throws DatabaseException {
if(isExcepted()) {
procedure.exception(graph, (Throwable)getResult());
return true;
}
}
- protected <T> boolean handleException(ReadGraphImpl graph, InternalProcedure<T> procedure) {
+ protected <T> boolean handleException(ReadGraphImpl graph, InternalProcedure<T> procedure) throws DatabaseException {
if(isExcepted()) {
procedure.exception(graph, (Throwable)getResult());
return true;
clearResult(querySupport);
}
- /*
- *
- *
- */
@Override
int getGCStatus() {
return GCStatus;
// This is the original request for all built-in queries
return getQuery();
}
-
+
+ public CacheEntryBase() {
+ }
+
}
--- /dev/null
+/*******************************************************************************
+ * Copyright (c) 2018 Association for Decentralized Information Management
+ * in Industry THTH ry.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ * Semantum Oy - initial API and implementation
+ *******************************************************************************/
+package org.simantics.db.impl.query;
+
+import org.simantics.databoard.binding.Binding;
+import org.simantics.databoard.serialization.Serializer;
+import org.simantics.db.ObjectResourceIdMap;
+import org.simantics.db.common.WriteBindings;
+import org.simantics.db.common.exception.DebugException;
+import org.simantics.db.exception.DatabaseException;
+import org.simantics.db.impl.graph.ReadGraphImpl;
+import org.simantics.db.impl.procedure.InternalProcedure;
+import org.simantics.db.service.CollectionSupport;
+
+public final class ChildMap extends UnaryQueryP<ObjectResourceIdMap<String>> {
+
+ ChildMap(final int r) {
+ super(r);
+ }
+
+ @Override
+ public final void removeEntry(QueryProcessor provider) {
+ provider.cache.remove(this);
+ }
+
+ @Override
+ public void compute(ReadGraphImpl graph, final InternalProcedure<ObjectResourceIdMap<String>> procedure)
+ throws DatabaseException {
+ computeForEach(graph, id, this, procedure);
+ }
+
+ public static void computeForEach(ReadGraphImpl graph, final int root, final ChildMap entry,
+ final InternalProcedure<ObjectResourceIdMap<String>> procedure_) throws DatabaseException {
+
+ InternalProcedure<ObjectResourceIdMap<String>> procedure = entry != null ? entry : procedure_;
+
+ computeForEach2(graph, root, entry, procedure);
+
+ if (entry != null)
+ entry.performFromCache(graph, procedure_);
+
+ }
+
Code Review / simantics / platform.git / commitdiff