import org.simantics.db.request.MultiRead;
import org.simantics.db.request.Read;
-import gnu.trove.map.hash.TObjectIntHashMap;
-
public class QueryCache extends QueryCacheBase {
public QueryCache(QuerySupport querySupport, int threads) {
super(querySupport, threads);
}
- Objects getOrCreateObjects(ReadGraphImpl graph, int r1, int r2) throws DatabaseException {
+ Objects getOrCreateObjects(QueryProcessor processor, int r1, int r2) throws DatabaseException {
Objects existing = null;
synchronized(objectsMap) {
existing = (Objects)objectsMap.get(r1,r2);
return existing;
}
}
- if(existing.isPending()) waitPending(graph, existing);
+ if(existing.isPending()) waitPending(processor, existing);
return existing;
}
Objects.computeForEach(graph, r1,r2, null, procedure);
return;
}
- Objects entry = (Objects)cache.getOrCreateObjects(graph, r1,r2);
+ Objects entry = (Objects)cache.getOrCreateObjects(graph.processor, r1,r2);
IntProcedure procedure_ = procedure != null ? procedure : emptyProcedureObjects;
ListenerEntry listenerEntry = cache.registerDependencies(graph, entry, parent, listener, procedure_, false);
if(entry.isReady()) entry.performFromCache(graph, procedure_);
}
}
- Statements getOrCreateStatements(ReadGraphImpl graph, int r1, int r2) throws DatabaseException {
+ Statements getOrCreateStatements(QueryProcessor processor, int r1, int r2) throws DatabaseException {
Statements existing = null;
synchronized(statementsMap) {
existing = (Statements)statementsMap.get(r1,r2);
return existing;
}
}
- if(existing.isPending()) waitPending(graph, existing);
+ if(existing.isPending()) waitPending(processor, existing);
return existing;
}
Statements.computeForEach(graph, r1,r2, null, procedure);
return;
}
- Statements entry = (Statements)cache.getOrCreateStatements(graph, r1,r2);
+ Statements entry = (Statements)cache.getOrCreateStatements(graph.processor, r1,r2);
TripleIntProcedure procedure_ = procedure != null ? procedure : emptyProcedureStatements;
ListenerEntry listenerEntry = cache.registerDependencies(graph, entry, parent, listener, procedure_, false);
if(entry.isReady()) entry.performFromCache(graph, procedure_);
}
}
- DirectObjects getOrCreateDirectObjects(ReadGraphImpl graph, int r1, int r2) throws DatabaseException {
+ DirectObjects getOrCreateDirectObjects(QueryProcessor processor, int r1, int r2) throws DatabaseException {
DirectObjects existing = null;
synchronized(directObjectsMap) {
existing = (DirectObjects)directObjectsMap.get(r1,r2);
return existing;
}
}
- if(existing.isPending()) waitPending(graph, existing);
+ if(existing.isPending()) waitPending(processor, existing);
return existing;
}
DirectObjects.computeForEach(graph, r1,r2, null, procedure);
return;
}
- DirectObjects entry = (DirectObjects)cache.getOrCreateDirectObjects(graph, r1,r2);
+ DirectObjects entry = (DirectObjects)cache.getOrCreateDirectObjects(graph.processor, r1,r2);
IntProcedure procedure_ = procedure != null ? procedure : emptyProcedureDirectObjects;
ListenerEntry listenerEntry = cache.registerDependencies(graph, entry, parent, listener, procedure_, false);
if(entry.isReady()) entry.performFromCache(graph, procedure_);
}
}
- RelationInfoQuery getOrCreateRelationInfoQuery(ReadGraphImpl graph, int r) throws DatabaseException {
+ RelationInfoQuery getOrCreateRelationInfoQuery(QueryProcessor processor, int r) throws DatabaseException {
RelationInfoQuery existing = null;
synchronized(relationInfoQueryMap) {
existing = (RelationInfoQuery)relationInfoQueryMap.get(r);
return existing;
}
}
- if(existing.isPending()) waitPending(graph, existing);
+ if(existing.isPending()) waitPending(processor, existing);
return existing;
}
RelationInfoQuery.computeForEach(graph, r, null, procedure);
return;
}
- RelationInfoQuery entry = (RelationInfoQuery)cache.getOrCreateRelationInfoQuery(graph, r);
+ RelationInfoQuery entry = (RelationInfoQuery)cache.getOrCreateRelationInfoQuery(graph.processor, r);
InternalProcedure<RelationInfo> procedure_ = procedure != null ? procedure : emptyProcedureRelationInfoQuery;
ListenerEntry listenerEntry = cache.registerDependencies(graph, entry, parent, listener, procedure_, false);
if(entry.isReady()) entry.performFromCache(graph, procedure_);
}
}
- URIToResource getOrCreateURIToResource(ReadGraphImpl graph, String id) throws DatabaseException {
+ URIToResource getOrCreateURIToResource(QueryProcessor processor, String id) throws DatabaseException {
URIToResource existing = null;
synchronized(uRIToResourceMap) {
existing = (URIToResource)uRIToResourceMap.get(id);
return existing;
}
}
- if(existing.isPending()) waitPending(graph, existing);
+ if(existing.isPending()) waitPending(processor, existing);
return existing;
}
URIToResource.computeForEach(graph, id, null, procedure);
return;
}
- URIToResource entry = (URIToResource)cache.getOrCreateURIToResource(graph, id);
+ URIToResource entry = (URIToResource)cache.getOrCreateURIToResource(graph.processor, id);
InternalProcedure<Integer> procedure_ = procedure != null ? procedure : emptyProcedureURIToResource;
ListenerEntry listenerEntry = cache.registerDependencies(graph, entry, parent, listener, procedure_, false);
if(entry.isReady()) entry.performFromCache(graph, procedure_);
}
}
- ValueQuery getOrCreateValueQuery(ReadGraphImpl graph, int r) throws DatabaseException {
+ ValueQuery getOrCreateValueQuery(QueryProcessor processor, int r) throws DatabaseException {
ValueQuery existing = null;
synchronized(valueQueryMap) {
existing = (ValueQuery)valueQueryMap.get(r);
return existing;
}
}
- if(existing.isPending()) waitPending(graph, existing);
+ if(existing.isPending()) waitPending(processor, existing);
return existing;
}
ValueQuery.computeForEach(graph, r, null, procedure);
return;
}
- ValueQuery entry = (ValueQuery)cache.getOrCreateValueQuery(graph, r);
+ ValueQuery entry = (ValueQuery)cache.getOrCreateValueQuery(graph.processor, r);
InternalProcedure<byte[]> procedure_ = procedure != null ? procedure : emptyProcedureValueQuery;
ListenerEntry listenerEntry = cache.registerDependencies(graph, entry, parent, listener, procedure_, false);
if(entry.isReady()) entry.performFromCache(graph, procedure_);
}
}
- OrderedSet getOrCreateOrderedSet(ReadGraphImpl graph, int r) throws DatabaseException {
+ OrderedSet getOrCreateOrderedSet(QueryProcessor processor, int r) throws DatabaseException {
OrderedSet existing = null;
synchronized(orderedSetMap) {
existing = (OrderedSet)orderedSetMap.get(r);
return existing;
}
}
- if(existing.isPending()) waitPending(graph, existing);
+ if(existing.isPending()) waitPending(processor, existing);
return existing;
}
OrderedSet.computeForEach(graph, r, null, procedure);
return;
}
- OrderedSet entry = (OrderedSet)cache.getOrCreateOrderedSet(graph, r);
+ OrderedSet entry = (OrderedSet)cache.getOrCreateOrderedSet(graph.processor, r);
IntProcedure procedure_ = procedure != null ? procedure : emptyProcedureOrderedSet;
ListenerEntry listenerEntry = cache.registerDependencies(graph, entry, parent, listener, procedure_, false);
if(entry.isReady()) entry.performFromCache(graph, procedure_);
}
}
- PrincipalTypes getOrCreatePrincipalTypes(ReadGraphImpl graph, int r) throws DatabaseException {
+ PrincipalTypes getOrCreatePrincipalTypes(QueryProcessor processor, int r) throws DatabaseException {
PrincipalTypes existing = null;
synchronized(principalTypesMap) {
existing = (PrincipalTypes)principalTypesMap.get(r);
return existing;
}
}
- if(existing.isPending()) waitPending(graph, existing);
+ if(existing.isPending()) waitPending(processor, existing);
return existing;
}
PrincipalTypes.computeForEach(graph, r, null, procedure);
return;
}
- PrincipalTypes entry = (PrincipalTypes)cache.getOrCreatePrincipalTypes(graph, r);
+ PrincipalTypes entry = (PrincipalTypes)cache.getOrCreatePrincipalTypes(graph.processor, r);
IntProcedure procedure_ = procedure != null ? procedure : emptyProcedurePrincipalTypes;
ListenerEntry listenerEntry = cache.registerDependencies(graph, entry, parent, listener, procedure_, false);
if(entry.isReady()) entry.performFromCache(graph, procedure_);
}
}
- DirectPredicates getOrCreateDirectPredicates(ReadGraphImpl graph, int r) throws DatabaseException {
+ DirectPredicates getOrCreateDirectPredicates(QueryProcessor processor, int r) throws DatabaseException {
DirectPredicates existing = null;
synchronized(directPredicatesMap) {
existing = (DirectPredicates)directPredicatesMap.get(r);
return existing;
}
}
- if(existing.isPending()) waitPending(graph, existing);
+ if(existing.isPending()) waitPending(processor, existing);
return existing;
}
DirectPredicates.computeForEach(graph, r, null, procedure);
return;
}
- DirectPredicates entry = (DirectPredicates)cache.getOrCreateDirectPredicates(graph, r);
+ DirectPredicates entry = (DirectPredicates)cache.getOrCreateDirectPredicates(graph.processor, r);
InternalProcedure<IntSet> procedure_ = procedure != null ? procedure : emptyProcedureDirectPredicates;
ListenerEntry listenerEntry = cache.registerDependencies(graph, entry, parent, listener, procedure_, false);
if(entry.isReady()) entry.performFromCache(graph, procedure_);
}
}
- Predicates getOrCreatePredicates(ReadGraphImpl graph, int r) throws DatabaseException {
+ Predicates getOrCreatePredicates(QueryProcessor processor, int r) throws DatabaseException {
Predicates existing = null;
synchronized(predicatesMap) {
existing = (Predicates)predicatesMap.get(r);
return existing;
}
}
- if(existing.isPending()) waitPending(graph, existing);
+ if(existing.isPending()) waitPending(processor, existing);
return existing;
}
Predicates.computeForEach(graph, r, null, procedure);
return;
}
- Predicates entry = (Predicates)cache.getOrCreatePredicates(graph, r);
+ Predicates entry = (Predicates)cache.getOrCreatePredicates(graph.processor, r);
InternalProcedure<IntSet> procedure_ = procedure != null ? procedure : emptyProcedurePredicates;
ListenerEntry listenerEntry = cache.registerDependencies(graph, entry, parent, listener, procedure_, false);
if(entry.isReady()) entry.performFromCache(graph, procedure_);
}
}
- ReadEntry getOrCreateReadEntry(ReadGraphImpl graph, Read<?> r, boolean isSync) throws DatabaseException {
+ ReadEntry getOrCreateReadEntry(QueryProcessor processor, Read<?> r, boolean isSync) throws DatabaseException {
ReadEntry existing = null;
synchronized(readEntryMap) {
existing = (ReadEntry)readEntryMap.get(r);
}
}
if(existing.isPending()) {
- if(isSync) waitPending(graph, existing);
+ if(isSync) waitPending(processor, existing);
else return null;
}
return existing;
ReadEntry.computeForEach(graph, r, null, procedure);
return;
}
- ReadEntry entry = (ReadEntry)cache.getOrCreateReadEntry(graph, r, isSync);
+ ReadEntry entry = (ReadEntry)cache.getOrCreateReadEntry(graph.processor, r, isSync);
if(entry == null) {
graph.processor.schedule(new SessionTask(false) {
@Override
}
}
- AsyncReadEntry getOrCreateAsyncReadEntry(ReadGraphImpl graph, AsyncRead<?> r, boolean isSync) throws DatabaseException {
+ AsyncReadEntry getOrCreateAsyncReadEntry(QueryProcessor processor, AsyncRead<?> r, boolean isSync) throws DatabaseException {
AsyncReadEntry existing = null;
synchronized(asyncReadEntryMap) {
existing = (AsyncReadEntry)asyncReadEntryMap.get(r);
}
}
if(existing.isPending()) {
- if(isSync) waitPending(graph, existing);
+ if(isSync) waitPending(processor, existing);
else return null;
}
return existing;
AsyncReadEntry.computeForEach(graph, r, null, procedure);
return;
}
- AsyncReadEntry entry = (AsyncReadEntry)cache.getOrCreateAsyncReadEntry(graph, r, isSync);
+ AsyncReadEntry entry = (AsyncReadEntry)cache.getOrCreateAsyncReadEntry(graph.processor, r, isSync);
if(entry == null) {
graph.processor.schedule(new SessionTask(false) {
@Override
}
}
- Types getOrCreateTypes(ReadGraphImpl graph, int r) throws DatabaseException {
+ Types getOrCreateTypes(QueryProcessor processor, int r) throws DatabaseException {
Types existing = null;
synchronized(typesMap) {
existing = (Types)typesMap.get(r);
return existing;
}
}
- if(existing.isPending()) waitPending(graph, existing);
+ if(existing.isPending()) waitPending(processor, existing);
return existing;
}
Types.computeForEach(graph, r, null, procedure);
return;
}
- Types entry = (Types)cache.getOrCreateTypes(graph, r);
+ Types entry = (Types)cache.getOrCreateTypes(graph.processor, r);
InternalProcedure<IntSet> procedure_ = procedure != null ? procedure : emptyProcedureTypes;
ListenerEntry listenerEntry = cache.registerDependencies(graph, entry, parent, listener, procedure_, false);
if(entry.isReady()) entry.performFromCache(graph, procedure_);
}
}
- ChildMap getOrCreateChildMap(ReadGraphImpl graph, int r) throws DatabaseException {
+ ChildMap getOrCreateChildMap(QueryProcessor processor, int r) throws DatabaseException {
ChildMap existing = null;
synchronized(childMapMap) {
existing = (ChildMap)childMapMap.get(r);
return existing;
}
}
- if(existing.isPending()) waitPending(graph, existing);
+ if(existing.isPending()) waitPending(processor, existing);
return existing;
}
ChildMap.computeForEach(graph, r, null, procedure);
return;
}
- ChildMap entry = (ChildMap)cache.getOrCreateChildMap(graph, r);
+ ChildMap entry = (ChildMap)cache.getOrCreateChildMap(graph.processor, r);
InternalProcedure<ObjectResourceIdMap<String>> procedure_ = procedure != null ? procedure : emptyProcedureChildMap;
ListenerEntry listenerEntry = cache.registerDependencies(graph, entry, parent, listener, procedure_, false);
if(entry.isReady()) entry.performFromCache(graph, procedure_);
}
}
- AssertedStatements getOrCreateAssertedStatements(ReadGraphImpl graph, int r1, int r2) throws DatabaseException {
- AssertedStatements existing = null;
- synchronized(assertedStatementsMap) {
- existing = (AssertedStatements)assertedStatementsMap.get(r1,r2);
+ TypeHierarchy getOrCreateTypeHierarchy(QueryProcessor processor, int r) throws DatabaseException {
+ TypeHierarchy existing = null;
+ synchronized(typeHierarchyMap) {
+ existing = (TypeHierarchy)typeHierarchyMap.get(r);
if(existing == null) {
- existing = new AssertedStatements(r1,r2);
+ existing = new TypeHierarchy(r);
existing.clearResult(querySupport);
existing.setPending();
- assertedStatementsMap.put(keyR2(r1,r2), existing);
+ typeHierarchyMap.put(keyR(r), existing);
size++;
return existing;
}
return existing;
}
}
- if(existing.isPending()) waitPending(graph, existing);
+ if(existing.isPending()) waitPending(processor, existing);
return existing;
}
- void remove(AssertedStatements entry) {
- synchronized(assertedStatementsMap) {
- assertedStatementsMap.remove(entry.id);
+ void remove(TypeHierarchy entry) {
+ synchronized(typeHierarchyMap) {
+ typeHierarchyMap.remove(entry.id);
}
}
- public static void runnerAssertedStatements(ReadGraphImpl graph, int r1, int r2, CacheEntry parent, ListenerBase listener, final TripleIntProcedure procedure) throws DatabaseException {
+ public static void runnerTypeHierarchy(ReadGraphImpl graph, int r, CacheEntry parent, ListenerBase listener, final InternalProcedure<IntSet> procedure) throws DatabaseException {
QueryCache cache = graph.processor.cache;
- AssertedStatements entry = (AssertedStatements)cache.getOrCreateAssertedStatements(graph, r1,r2);
- TripleIntProcedure procedure_ = procedure != null ? procedure : emptyProcedureAssertedStatements;
+ if(parent == null && listener == null && !cache.shouldCache(graph.processor, r)) {
+ TypeHierarchy.computeForEach(graph, r, null, procedure);
+ return;
+ }
+ TypeHierarchy entry = (TypeHierarchy)cache.getOrCreateTypeHierarchy(graph.processor, r);
+ InternalProcedure<IntSet> procedure_ = procedure != null ? procedure : emptyProcedureTypeHierarchy;
ListenerEntry listenerEntry = cache.registerDependencies(graph, entry, parent, listener, procedure_, false);
if(entry.isReady()) entry.performFromCache(graph, procedure_);
else {
assert(entry.isPending());
- entry.compute(graph, procedure_);
+ TypeHierarchy.computeForEach(graph, r, entry, procedure_);
if(listenerEntry != null) cache.primeListenerEntry(listenerEntry, entry.getResult());
}
}
- AssertedPredicates getOrCreateAssertedPredicates(ReadGraphImpl graph, int r) throws DatabaseException {
- AssertedPredicates existing = null;
- synchronized(assertedPredicatesMap) {
- existing = (AssertedPredicates)assertedPredicatesMap.get(r);
+ SuperTypes getOrCreateSuperTypes(QueryProcessor processor, int r) throws DatabaseException {
+ SuperTypes existing = null;
+ synchronized(superTypesMap) {
+ existing = (SuperTypes)superTypesMap.get(r);
if(existing == null) {
- existing = new AssertedPredicates(r);
+ existing = new SuperTypes(r);
existing.clearResult(querySupport);
existing.setPending();
- assertedPredicatesMap.put(keyR(r), existing);
+ superTypesMap.put(keyR(r), existing);
size++;
return existing;
}
return existing;
}
}
- if(existing.isPending()) waitPending(graph, existing);
+ if(existing.isPending()) waitPending(processor, existing);
return existing;
}
- void remove(AssertedPredicates entry) {
- synchronized(assertedPredicatesMap) {
- assertedPredicatesMap.remove(entry.id);
+ void remove(SuperTypes entry) {
+ synchronized(superTypesMap) {
+ superTypesMap.remove(entry.id);
}
}
- public static void runnerAssertedPredicates(ReadGraphImpl graph, int r, CacheEntry parent, ListenerBase listener, final IntProcedure procedure) throws DatabaseException {
+ public static void runnerSuperTypes(ReadGraphImpl graph, int r, CacheEntry parent, ListenerBase listener, final InternalProcedure<IntSet> procedure) throws DatabaseException {
QueryCache cache = graph.processor.cache;
- AssertedPredicates entry = (AssertedPredicates)cache.getOrCreateAssertedPredicates(graph, r);
- IntProcedure procedure_ = procedure != null ? procedure : emptyProcedureAssertedPredicates;
+ if(parent == null && listener == null && !cache.shouldCache(graph.processor, r)) {
+ SuperTypes.computeForEach(graph, r, null, procedure);
+ return;
+ }
+ SuperTypes entry = (SuperTypes)cache.getOrCreateSuperTypes(graph.processor, r);
+ InternalProcedure<IntSet> procedure_ = procedure != null ? procedure : emptyProcedureSuperTypes;
ListenerEntry listenerEntry = cache.registerDependencies(graph, entry, parent, listener, procedure_, false);
if(entry.isReady()) entry.performFromCache(graph, procedure_);
else {
assert(entry.isPending());
- entry.compute(graph, procedure_);
+ SuperTypes.computeForEach(graph, r, entry, procedure_);
if(listenerEntry != null) cache.primeListenerEntry(listenerEntry, entry.getResult());
}
}
- DirectSuperRelations getOrCreateDirectSuperRelations(ReadGraphImpl graph, int r) throws DatabaseException {
- DirectSuperRelations existing = null;
- synchronized(directSuperRelationsMap) {
- existing = (DirectSuperRelations)directSuperRelationsMap.get(r);
+ SuperRelations getOrCreateSuperRelations(QueryProcessor processor, int r) throws DatabaseException {
+ SuperRelations existing = null;
+ synchronized(superRelationsMap) {
+ existing = (SuperRelations)superRelationsMap.get(r);
if(existing == null) {
- existing = new DirectSuperRelations(r);
+ existing = new SuperRelations(r);
existing.clearResult(querySupport);
existing.setPending();
- directSuperRelationsMap.put(keyR(r), existing);
+ superRelationsMap.put(keyR(r), existing);
size++;
return existing;
}
return existing;
}
}
- if(existing.isPending()) waitPending(graph, existing);
+ if(existing.isPending()) waitPending(processor, existing);
return existing;
}
- void remove(DirectSuperRelations entry) {
- synchronized(directSuperRelationsMap) {
- directSuperRelationsMap.remove(entry.id);
+ void remove(SuperRelations entry) {
+ synchronized(superRelationsMap) {
+ superRelationsMap.remove(entry.id);
}
}
- public static void runnerDirectSuperRelations(ReadGraphImpl graph, int r, CacheEntry parent, ListenerBase listener, final IntProcedure procedure) throws DatabaseException {
+ public static void runnerSuperRelations(ReadGraphImpl graph, int r, CacheEntry parent, ListenerBase listener, final InternalProcedure<IntSet> procedure) throws DatabaseException {
QueryCache cache = graph.processor.cache;
- DirectSuperRelations entry = (DirectSuperRelations)cache.getOrCreateDirectSuperRelations(graph, r);
- IntProcedure procedure_ = procedure != null ? procedure : emptyProcedureDirectSuperRelations;
+ if(parent == null && listener == null && !cache.shouldCache(graph.processor, r)) {
+ SuperRelations.computeForEach(graph, r, null, procedure);
+ return;
+ }
+ SuperRelations entry = (SuperRelations)cache.getOrCreateSuperRelations(graph.processor, r);
+ InternalProcedure<IntSet> procedure_ = procedure != null ? procedure : emptyProcedureSuperRelations;
ListenerEntry listenerEntry = cache.registerDependencies(graph, entry, parent, listener, procedure_, false);
if(entry.isReady()) entry.performFromCache(graph, procedure_);
else {
assert(entry.isPending());
- entry.compute(graph, procedure_);
+ SuperRelations.computeForEach(graph, r, entry, procedure_);
if(listenerEntry != null) cache.primeListenerEntry(listenerEntry, entry.getResult());
}
}
- SuperTypes getOrCreateSuperTypes(ReadGraphImpl graph, int r) throws DatabaseException {
- SuperTypes existing = null;
- synchronized(superTypesMap) {
- existing = (SuperTypes)superTypesMap.get(r);
+ AssertedPredicates getOrCreateAssertedPredicates(QueryProcessor processor, int r) throws DatabaseException {
+ AssertedPredicates existing = null;
+ synchronized(assertedPredicatesMap) {
+ existing = (AssertedPredicates)assertedPredicatesMap.get(r);
if(existing == null) {
- existing = new SuperTypes(r);
+ existing = new AssertedPredicates(r);
existing.clearResult(querySupport);
existing.setPending();
- superTypesMap.put(keyR(r), existing);
+ assertedPredicatesMap.put(keyR(r), existing);
size++;
return existing;
}
return existing;
}
}
- if(existing.isPending()) waitPending(graph, existing);
+ if(existing.isPending()) waitPending(processor, existing);
return existing;
}
- void remove(SuperTypes entry) {
- synchronized(superTypesMap) {
- superTypesMap.remove(entry.id);
+ void remove(AssertedPredicates entry) {
+ synchronized(assertedPredicatesMap) {
+ assertedPredicatesMap.remove(entry.id);
}
}
- public static void runnerSuperTypes(ReadGraphImpl graph, int r, CacheEntry parent, ListenerBase listener, final InternalProcedure<IntSet> procedure) throws DatabaseException {
+ public static void runnerAssertedPredicates(ReadGraphImpl graph, int r, CacheEntry parent, ListenerBase listener, final IntProcedure procedure) throws DatabaseException {
QueryCache cache = graph.processor.cache;
- SuperTypes entry = (SuperTypes)cache.getOrCreateSuperTypes(graph, r);
- InternalProcedure<IntSet> procedure_ = procedure != null ? procedure : emptyProcedureSuperTypes;
+ AssertedPredicates entry = (AssertedPredicates)cache.getOrCreateAssertedPredicates(graph.processor, r);
+ IntProcedure procedure_ = procedure != null ? procedure : emptyProcedureAssertedPredicates;
ListenerEntry listenerEntry = cache.registerDependencies(graph, entry, parent, listener, procedure_, false);
if(entry.isReady()) entry.performFromCache(graph, procedure_);
else {
}
}
- TypeHierarchy getOrCreateTypeHierarchy(ReadGraphImpl graph, int r) throws DatabaseException {
- TypeHierarchy existing = null;
- synchronized(typeHierarchyMap) {
- existing = (TypeHierarchy)typeHierarchyMap.get(r);
+ AssertedStatements getOrCreateAssertedStatements(QueryProcessor processor, int r1, int r2) throws DatabaseException {
+ AssertedStatements existing = null;
+ synchronized(assertedStatementsMap) {
+ existing = (AssertedStatements)assertedStatementsMap.get(r1,r2);
if(existing == null) {
- existing = new TypeHierarchy(r);
+ existing = new AssertedStatements(r1,r2);
existing.clearResult(querySupport);
existing.setPending();
- typeHierarchyMap.put(keyR(r), existing);
+ assertedStatementsMap.put(keyR2(r1,r2), existing);
size++;
return existing;
}
return existing;
}
}
- if(existing.isPending()) waitPending(graph, existing);
+ if(existing.isPending()) waitPending(processor, existing);
return existing;
}
- void remove(TypeHierarchy entry) {
- synchronized(typeHierarchyMap) {
- typeHierarchyMap.remove(entry.id);
+ void remove(AssertedStatements entry) {
+ synchronized(assertedStatementsMap) {
+ assertedStatementsMap.remove(entry.id);
}
}
- public static void runnerTypeHierarchy(ReadGraphImpl graph, int r, CacheEntry parent, ListenerBase listener, final InternalProcedure<IntSet> procedure) throws DatabaseException {
+ public static void runnerAssertedStatements(ReadGraphImpl graph, int r1, int r2, CacheEntry parent, ListenerBase listener, final TripleIntProcedure procedure) throws DatabaseException {
QueryCache cache = graph.processor.cache;
- TypeHierarchy entry = (TypeHierarchy)cache.getOrCreateTypeHierarchy(graph, r);
- InternalProcedure<IntSet> procedure_ = procedure != null ? procedure : emptyProcedureTypeHierarchy;
+ AssertedStatements entry = (AssertedStatements)cache.getOrCreateAssertedStatements(graph.processor, r1,r2);
+ TripleIntProcedure procedure_ = procedure != null ? procedure : emptyProcedureAssertedStatements;
ListenerEntry listenerEntry = cache.registerDependencies(graph, entry, parent, listener, procedure_, false);
if(entry.isReady()) entry.performFromCache(graph, procedure_);
else {
}
}
- SuperRelations getOrCreateSuperRelations(ReadGraphImpl graph, int r) throws DatabaseException {
- SuperRelations existing = null;
- synchronized(superRelationsMap) {
- existing = (SuperRelations)superRelationsMap.get(r);
+ DirectSuperRelations getOrCreateDirectSuperRelations(QueryProcessor processor, int r) throws DatabaseException {
+ DirectSuperRelations existing = null;
+ synchronized(directSuperRelationsMap) {
+ existing = (DirectSuperRelations)directSuperRelationsMap.get(r);
if(existing == null) {
- existing = new SuperRelations(r);
+ existing = new DirectSuperRelations(r);
existing.clearResult(querySupport);
existing.setPending();
- superRelationsMap.put(keyR(r), existing);
+ directSuperRelationsMap.put(keyR(r), existing);
size++;
return existing;
}
return existing;
}
}
- if(existing.isPending()) waitPending(graph, existing);
+ if(existing.isPending()) waitPending(processor, existing);
return existing;
}
- void remove(SuperRelations entry) {
- synchronized(superRelationsMap) {
- superRelationsMap.remove(entry.id);
+ void remove(DirectSuperRelations entry) {
+ synchronized(directSuperRelationsMap) {
+ directSuperRelationsMap.remove(entry.id);
}
}
- public static void runnerSuperRelations(ReadGraphImpl graph, int r, CacheEntry parent, ListenerBase listener, final InternalProcedure<IntSet> procedure) throws DatabaseException {
+ public static void runnerDirectSuperRelations(ReadGraphImpl graph, int r, CacheEntry parent, ListenerBase listener, final IntProcedure procedure) throws DatabaseException {
QueryCache cache = graph.processor.cache;
- SuperRelations entry = (SuperRelations)cache.getOrCreateSuperRelations(graph, r);
- InternalProcedure<IntSet> procedure_ = procedure != null ? procedure : emptyProcedureSuperRelations;
+ DirectSuperRelations entry = (DirectSuperRelations)cache.getOrCreateDirectSuperRelations(graph.processor, r);
+ IntProcedure procedure_ = procedure != null ? procedure : emptyProcedureDirectSuperRelations;
ListenerEntry listenerEntry = cache.registerDependencies(graph, entry, parent, listener, procedure_, false);
if(entry.isReady()) entry.performFromCache(graph, procedure_);
else {
}
}
- MultiReadEntry getOrCreateMultiReadEntry(ReadGraphImpl graph, MultiRead<?> r) throws DatabaseException {
+ MultiReadEntry getOrCreateMultiReadEntry(QueryProcessor processor, MultiRead<?> r) throws DatabaseException {
MultiReadEntry existing = null;
synchronized(multiReadEntryMap) {
existing = (MultiReadEntry)multiReadEntryMap.get(r);
return existing;
}
}
- if(existing.isPending()) waitPending(graph, existing);
+ if(existing.isPending()) waitPending(processor, existing);
return existing;
}
public static void runnerMultiReadEntry(ReadGraphImpl graph, MultiRead<?> r, CacheEntry parent, ListenerBase listener, final AsyncMultiProcedure procedure) throws DatabaseException {
QueryCache cache = graph.processor.cache;
- MultiReadEntry entry = (MultiReadEntry)cache.getOrCreateMultiReadEntry(graph, r);
+ MultiReadEntry entry = (MultiReadEntry)cache.getOrCreateMultiReadEntry(graph.processor, r);
AsyncMultiProcedure procedure_ = procedure != null ? procedure : emptyProcedureMultiReadEntry;
ListenerEntry listenerEntry = cache.registerDependencies(graph, entry, parent, listener, procedure_, false);
if(entry.isReady()) entry.performFromCache(graph, procedure_);
}
}
- AsyncMultiReadEntry getOrCreateAsyncMultiReadEntry(ReadGraphImpl graph, AsyncMultiRead<?> r) throws DatabaseException {
+ AsyncMultiReadEntry getOrCreateAsyncMultiReadEntry(QueryProcessor processor, AsyncMultiRead<?> r) throws DatabaseException {
AsyncMultiReadEntry existing = null;
synchronized(asyncMultiReadEntryMap) {
existing = (AsyncMultiReadEntry)asyncMultiReadEntryMap.get(r);
return existing;
}
}
- if(existing.isPending()) waitPending(graph, existing);
+ if(existing.isPending()) waitPending(processor, existing);
return existing;
}
public static void runnerAsyncMultiReadEntry(ReadGraphImpl graph, AsyncMultiRead<?> r, CacheEntry parent, ListenerBase listener, final AsyncMultiProcedure procedure) throws DatabaseException {
QueryCache cache = graph.processor.cache;
- AsyncMultiReadEntry entry = (AsyncMultiReadEntry)cache.getOrCreateAsyncMultiReadEntry(graph, r);
+ AsyncMultiReadEntry entry = (AsyncMultiReadEntry)cache.getOrCreateAsyncMultiReadEntry(graph.processor, r);
AsyncMultiProcedure procedure_ = procedure != null ? procedure : emptyProcedureAsyncMultiReadEntry;
ListenerEntry listenerEntry = cache.registerDependencies(graph, entry, parent, listener, procedure_, false);
if(entry.isReady()) entry.performFromCache(graph, procedure_);
}
}
- ExternalReadEntry getOrCreateExternalReadEntry(ReadGraphImpl graph, ExternalRead<?> r) throws DatabaseException {
+ ExternalReadEntry getOrCreateExternalReadEntry(QueryProcessor processor, ExternalRead<?> r) throws DatabaseException {
ExternalReadEntry existing = null;
synchronized(externalReadEntryMap) {
existing = (ExternalReadEntry)externalReadEntryMap.get(r);
return existing;
}
}
- if(existing.isPending()) waitPending(graph, existing);
+ if(existing.isPending()) waitPending(processor, existing);
return existing;
}
public static void runnerExternalReadEntry(ReadGraphImpl graph, ExternalRead<?> r, CacheEntry parent, ListenerBase listener, final AsyncProcedure procedure) throws DatabaseException {
QueryCache cache = graph.processor.cache;
- ExternalReadEntry entry = (ExternalReadEntry)cache.getOrCreateExternalReadEntry(graph, r);
+ ExternalReadEntry entry = (ExternalReadEntry)cache.getOrCreateExternalReadEntry(graph.processor, r);
AsyncProcedure procedure_ = procedure != null ? procedure : emptyProcedureExternalReadEntry;
ListenerEntry listenerEntry = cache.registerDependencies(graph, entry, parent, listener, procedure_, false);
if(entry.isReady()) entry.performFromCache(graph, procedure_);
Code Review / simantics / platform.git / blobdiff