aboutsummaryrefslogtreecommitdiffstats
path: root/store/src/main/java/org/eclipse/viatra/solver/data/query/internal/RelationalRuntimeContext.java
diff options
context:
space:
mode:
Diffstat (limited to 'store/src/main/java/org/eclipse/viatra/solver/data/query/internal/RelationalRuntimeContext.java')
-rw-r--r--store/src/main/java/org/eclipse/viatra/solver/data/query/internal/RelationalRuntimeContext.java185
1 files changed, 0 insertions, 185 deletions
diff --git a/store/src/main/java/org/eclipse/viatra/solver/data/query/internal/RelationalRuntimeContext.java b/store/src/main/java/org/eclipse/viatra/solver/data/query/internal/RelationalRuntimeContext.java
deleted file mode 100644
index fa6a59ab..00000000
--- a/store/src/main/java/org/eclipse/viatra/solver/data/query/internal/RelationalRuntimeContext.java
+++ /dev/null
@@ -1,185 +0,0 @@
1package org.eclipse.viatra.solver.data.query.internal;
2
3import static org.eclipse.viatra.solver.data.util.CollectionsUtil.filter;
4import static org.eclipse.viatra.solver.data.util.CollectionsUtil.map;
5
6import java.lang.reflect.InvocationTargetException;
7import java.util.Iterator;
8import java.util.Optional;
9import java.util.concurrent.Callable;
10
11import org.eclipse.viatra.query.runtime.base.core.NavigationHelperImpl;
12import org.eclipse.viatra.query.runtime.matchers.context.IInputKey;
13import org.eclipse.viatra.query.runtime.matchers.context.IQueryMetaContext;
14import org.eclipse.viatra.query.runtime.matchers.context.IQueryRuntimeContext;
15import org.eclipse.viatra.query.runtime.matchers.context.IQueryRuntimeContextListener;
16import org.eclipse.viatra.query.runtime.matchers.context.IndexingService;
17import org.eclipse.viatra.query.runtime.matchers.tuple.ITuple;
18import org.eclipse.viatra.query.runtime.matchers.tuple.Tuple;
19import org.eclipse.viatra.query.runtime.matchers.tuple.TupleMask;
20import org.eclipse.viatra.query.runtime.matchers.tuple.Tuples;
21import org.eclipse.viatra.query.runtime.matchers.util.Accuracy;
22import org.eclipse.viatra.solver.data.model.Model;
23import org.eclipse.viatra.solver.data.query.view.RelationView;
24
25public class RelationalRuntimeContext implements IQueryRuntimeContext {
26 private final RelationalQueryMetaContext metaContext = new RelationalQueryMetaContext();
27 private final RelationUpdateListener relationUpdateListener;
28 private final Model model;
29
30 public RelationalRuntimeContext(Model model, RelationUpdateListener relationUpdateListener) {
31 this.model = model;
32 this.relationUpdateListener = relationUpdateListener;
33 }
34
35 @Override
36 public IQueryMetaContext getMetaContext() {
37 return metaContext;
38 }
39
40 /**
41 * TODO: check {@link NavigationHelperImpl#coalesceTraversals(Callable)}
42 */
43 @Override
44 public <V> V coalesceTraversals(Callable<V> callable) throws InvocationTargetException {
45 try {
46 return callable.call();
47 } catch (Exception e) {
48 throw new InvocationTargetException(e);
49 }
50 }
51
52 @Override
53 public boolean isCoalescing() {
54 return true;
55 }
56
57 @Override
58 public boolean isIndexed(IInputKey key, IndexingService service) {
59 if(key instanceof RelationView<?> relationalKey) {
60 return this.relationUpdateListener.containsRelationalView(relationalKey);
61 } else {
62 return false;
63 }
64 }
65
66 @Override
67 public void ensureIndexed(IInputKey key, IndexingService service) {
68 if(!isIndexed(key, service)) {
69 throw new IllegalStateException("Engine tries to index a new key " +key);
70 }
71 }
72
73 RelationView<?> checkKey(IInputKey key) {
74 if(key instanceof RelationView) {
75 RelationView<?> relationViewKey = (RelationView<?>) key;
76 if(relationUpdateListener.containsRelationalView(relationViewKey)) {
77 return relationViewKey;
78 } else {
79 throw new IllegalStateException("Query is asking for non-indexed key");
80 }
81 } else {
82 throw new IllegalStateException("Query is asking for non-relational key");
83 }
84 }
85
86 @Override
87 public int countTuples(IInputKey key, TupleMask seedMask, ITuple seed) {
88 RelationView<?> relationalViewKey = checkKey(key);
89 Iterable<Object[]> allObjects = relationalViewKey.getAll(model);
90 Iterable<Object[]> filteredBySeed = filter(allObjects,objectArray -> isMatching(objectArray,seedMask,seed));
91 Iterator<Object[]> iterator = filteredBySeed.iterator();
92 int result = 0;
93 while(iterator.hasNext()) {
94 iterator.next();
95 result++;
96 }
97 return result;
98 }
99
100 @Override
101 public Optional<Long> estimateCardinality(IInputKey key, TupleMask groupMask, Accuracy requiredAccuracy) {
102 return Optional.empty();
103 }
104
105 @Override
106 public Iterable<Tuple> enumerateTuples(IInputKey key, TupleMask seedMask, ITuple seed) {
107 RelationView<?> relationalViewKey = checkKey(key);
108 Iterable<Object[]> allObjects = relationalViewKey.getAll(model);
109 Iterable<Object[]> filteredBySeed = filter(allObjects,objectArray -> isMatching(objectArray,seedMask,seed));
110 return map(filteredBySeed,Tuples::flatTupleOf);
111 }
112
113 private boolean isMatching(Object[] tuple, TupleMask seedMask, ITuple seed) {
114 for(int i=0; i<seedMask.indices.length; i++) {
115 final Object seedElement = seed.get(i);
116 final Object tupleElement = tuple[seedMask.indices[i]];
117 if(!tupleElement.equals(seedElement)) {
118 return false;
119 }
120 }
121 return true;
122 }
123// private Object[] toObjectMask(RelationViewKey<?> relationalViewKey, TupleMask seedMask, ITuple seed) {
124// final int arity = relationalViewKey.getArity();
125// Object[] result = new Object[arity];
126// for(int i = 0; i<seedMask.indices.length; i++) {
127// result[seedMask.indices[i]] = seed.get(i);
128// }
129// return result;
130// }
131
132 @Override
133 public Iterable<? extends Object> enumerateValues(IInputKey key, TupleMask seedMask, ITuple seed) {
134 return enumerateTuples(key, seedMask, seed);
135 }
136
137 @Override
138 public boolean containsTuple(IInputKey key, ITuple seed) {
139 RelationView<?> relationalViewKey = checkKey(key);
140 return relationalViewKey.get(model,seed.getElements());
141 }
142
143 @Override
144 public void addUpdateListener(IInputKey key, Tuple seed, IQueryRuntimeContextListener listener) {
145 RelationView<?> relationalKey = checkKey(key);
146 this.relationUpdateListener.addListener(relationalKey, seed, listener);
147
148 }
149
150 @Override
151 public void removeUpdateListener(IInputKey key, Tuple seed, IQueryRuntimeContextListener listener) {
152 RelationView<?> relationalKey = checkKey(key);
153 this.relationUpdateListener.removeListener(relationalKey, seed, listener);
154 }
155
156 @Override
157 public Object wrapElement(Object externalElement) {
158 return externalElement;
159 }
160
161 @Override
162 public Object unwrapElement(Object internalElement) {
163 return internalElement;
164 }
165
166 @Override
167 public Tuple wrapTuple(Tuple externalElements) {
168 return externalElements;
169 }
170
171 @Override
172 public Tuple unwrapTuple(Tuple internalElements) {
173 return internalElements;
174 }
175
176 @Override
177 public void ensureWildcardIndexing(IndexingService service) {
178 throw new UnsupportedOperationException();
179 }
180
181 @Override
182 public void executeAfterTraversal(Runnable runnable) throws InvocationTargetException {
183 runnable.run();
184 }
185}
generated by cgit v1.2.3-54-g00ecf (git 2.45.2) at 2024-07-20 01:46:00 +0000