RawPatternMatcher for exposing raw pattern matches

3 files changed, 91 insertions, 6 deletions

diff --git a/store/src/main/java/tools/refinery/store/query/internal/DNF2PQuery.java b/store/src/main/java/tools/refinery/store/query/internal/DNF2PQuery.java
index c9c8245b..f0ac0276 100644
--- a/store/src/main/java/tools/refinery/store/query/internal/DNF2PQuery.java
+++ b/store/src/main/java/tools/refinery/store/query/internal/DNF2PQuery.java
@@ -160,8 +160,8 @@ public class DNF2PQuery {
                         return bodies;
                 }
 
-                public GenericQuerySpecification<GenericPatternMatcher> build() {
-                        return new GenericQuerySpecification<GenericPatternMatcher>(this) {
+                public GenericQuerySpecification<RawPatternMatcher> build() {
+                        return new GenericQuerySpecification<RawPatternMatcher>(this) {
 
                                 @Override
                                 public Class<? extends QueryScope> getPreferredScopeClass() {
@@ -169,13 +169,17 @@ public class DNF2PQuery {
                                 }
 
                                 @Override
-                                protected GenericPatternMatcher instantiate(ViatraQueryEngine engine) {
-                                        return defaultInstantiate(engine);
+                                protected RawPatternMatcher instantiate(ViatraQueryEngine engine) {
+                                        RawPatternMatcher matcher = engine.getExistingMatcher(this);
+                                if (matcher == null) {
+                                    matcher = engine.getMatcher(this);
+                                }       
+                                return matcher;
                                 }
 
                                 @Override
-                                public GenericPatternMatcher instantiate() {
-                                        return new GenericPatternMatcher(this);
+                                public RawPatternMatcher instantiate() {
+                                        return new RawPatternMatcher(this);
                                 }
 
                         };
diff --git a/store/src/main/java/tools/refinery/store/query/internal/PredicateResult.java b/store/src/main/java/tools/refinery/store/query/internal/PredicateResult.java
new file mode 100644
index 00000000..65d23eb6
--- /dev/null
+++ b/store/src/main/java/tools/refinery/store/query/internal/PredicateResult.java
@@ -0,0 +1,24 @@
+package tools.refinery.store.query.internal;
+
+import java.util.Optional;
+import java.util.stream.Stream;
+
+public interface PredicateResult {
+
+        boolean hasResult();
+
+        boolean hasResult(Object[] parameters);
+
+        Optional<Object[]> oneResult();
+
+        Optional<Object[]> oneResult(Object[] parameters);
+
+        Stream<Object[]> allResults();
+
+        Stream<Object[]> allResults(Object[] parameters);
+
+        int countResults();
+
+        int countResults(Object[] parameters);
+
+}
\ No newline at end of file
diff --git a/store/src/main/java/tools/refinery/store/query/internal/RawPatternMatcher.java b/store/src/main/java/tools/refinery/store/query/internal/RawPatternMatcher.java
new file mode 100644
index 00000000..c6d6353c
--- /dev/null
+++ b/store/src/main/java/tools/refinery/store/query/internal/RawPatternMatcher.java
@@ -0,0 +1,57 @@
+package tools.refinery.store.query.internal;
+
+import java.util.Optional;
+import java.util.stream.Stream;
+
+import org.eclipse.viatra.query.runtime.api.GenericPatternMatcher;
+import org.eclipse.viatra.query.runtime.api.GenericQuerySpecification;
+import org.eclipse.viatra.query.runtime.matchers.tuple.Tuple;
+import org.eclipse.viatra.query.runtime.matchers.tuple.AbstractTuple;
+
+public class RawPatternMatcher extends GenericPatternMatcher implements PredicateResult{
+        
+        protected final Object[] empty;
+        
+        public RawPatternMatcher(GenericQuerySpecification<? extends GenericPatternMatcher> specification) {
+                super(specification);
+                this.empty = new Object[specification.getParameterNames().size()];
+        }
+        
+        @Override
+        public boolean hasResult() {
+                return hasResult(empty);
+        }
+        @Override
+        public boolean hasResult(Object[] parameters) {
+                return this.backend.hasMatch(parameters);
+        }
+        @Override
+        public Optional<Object[]> oneResult() {
+                return oneResult(empty);
+        }
+        @Override
+        public Optional<Object[]> oneResult(Object[] parameters) {
+                Optional<Tuple> tuple = this.backend.getOneArbitraryMatch(parameters);
+                if(tuple.isPresent()) {
+                        return Optional.of(tuple.get().getElements());
+                } else {
+                        return Optional.empty();
+                }
+        }
+        @Override
+        public Stream<Object[]> allResults() {
+                return allResults(empty);
+        }
+        @Override
+        public Stream<Object[]> allResults(Object[] parameters) {
+                return this.backend.getAllMatches(parameters).map(AbstractTuple::getElements);
+        }
+        @Override
+        public int countResults() {
+                return countResults(empty);
+        }
+        @Override
+        public int countResults(Object[] parameters) {
+                return backend.countMatches(parameters);
+        }
+}