Buffered Model update listener, first version

8 files changed, 187 insertions, 84 deletions

diff --git a/store/src/main/java/tools/refinery/store/query/RelationalScope.java b/store/src/main/java/tools/refinery/store/query/RelationalScope.java
index 5fe8083a..e37fdb95 100644
--- a/store/src/main/java/tools/refinery/store/query/RelationalScope.java
+++ b/store/src/main/java/tools/refinery/store/query/RelationalScope.java
@@ -9,23 +9,23 @@ import org.eclipse.viatra.query.runtime.api.scope.IIndexingErrorListener;
 import org.eclipse.viatra.query.runtime.api.scope.QueryScope;
 
 import tools.refinery.store.model.Model;
-import tools.refinery.store.model.Tuple;
-import tools.refinery.store.query.internal.RelationUpdateListener;
+import tools.refinery.store.query.internal.ModelUpdateListener;
 import tools.refinery.store.query.internal.RelationalEngineContext;
 import tools.refinery.store.query.view.RelationView;
 
 public class RelationalScope extends QueryScope{
         private final Model model;
-        private final RelationUpdateListener updateListener;
+        private final ModelUpdateListener updateListener;
         
         public RelationalScope(Model model, Set<RelationView<?>> relationViews) {
                 this.model = model;
-                updateListener = new RelationUpdateListener(relationViews);
+                this.updateListener = new ModelUpdateListener(relationViews);
+                //this.changeListener = new 
         }
         
-        public <D> void processUpdate(RelationView<D> relationView, Tuple key, D oldValue, D newValue) {
-                updateListener.processChange(relationView, key, oldValue, newValue);
-        }
+//      public <D> void processUpdate(RelationView<D> relationView, Tuple key, D oldValue, D newValue) {
+//              updateListener.processChange(relationView, key, oldValue, newValue);
+//      }
 
         @Override
         protected IEngineContext createEngineContext(ViatraQueryEngine engine, IIndexingErrorListener errorListener,
diff --git a/store/src/main/java/tools/refinery/store/query/internal/ModelUpdateListener.java b/store/src/main/java/tools/refinery/store/query/internal/ModelUpdateListener.java
new file mode 100644
index 00000000..425ae8f7
--- /dev/null
+++ b/store/src/main/java/tools/refinery/store/query/internal/ModelUpdateListener.java
@@ -0,0 +1,112 @@
+package tools.refinery.store.query.internal;
+
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
+
+import org.eclipse.viatra.query.runtime.matchers.context.IQueryRuntimeContextListener;
+import org.eclipse.viatra.query.runtime.matchers.tuple.ITuple;
+
+import tools.refinery.store.model.Tuple;
+import tools.refinery.store.model.representation.Relation;
+import tools.refinery.store.query.view.RelationView;
+
+public class ModelUpdateListener {
+        /**
+         * Collections of Relations and their Views.
+         */
+        private final Map<Relation<?>, Set<RelationView<?>>> relation2View;
+        /**
+         * Collection of Views and their buffers.
+         */
+        private final Map<RelationView<?>, Set<ViewUpdateBuffer<?>>> view2Buffers;
+
+        public ModelUpdateListener(Set<RelationView<?>> relationViews) {
+                this.relation2View = new HashMap<>();
+                this.view2Buffers = new HashMap<>();
+
+                for (RelationView<?> relationView : relationViews) {
+                        registerView(relationView);
+                }
+        }
+
+        private void registerView(RelationView<?> view) {
+                Relation<?> relation = view.getRepresentation();
+
+                // 1. register views to relations, if necessary
+                var views = relation2View.get(relation);
+                if (views == null) {
+                        views = new HashSet<>();
+                        relation2View.put(relation, views);
+                }
+                views.add(view);
+
+                // 2. register notifier map to views, if necessary
+                if (!view2Buffers.containsKey(view)) {
+                        view2Buffers.put(view, new HashSet<>());
+                }
+        }
+
+        boolean containsRelationalView(RelationView<?> relationalKey) {
+                return view2Buffers.containsKey(relationalKey);
+        }
+
+        <D> void addListener(RelationView<D> relationView, ITuple seed, IQueryRuntimeContextListener listener) {
+                if (view2Buffers.containsKey(relationView)) {
+                        ViewUpdateTranslator<D> updateListener = new ViewUpdateTranslator<>(relationView, seed, listener);
+                        ViewUpdateBuffer<D> updateBuffer = new ViewUpdateBuffer<>(updateListener);
+                        view2Buffers.get(relationView).add(updateBuffer);
+                } else
+                        throw new IllegalArgumentException();
+        }
+
+        void removeListener(RelationView<?> relationView, ITuple seed, IQueryRuntimeContextListener listener) {
+                if (view2Buffers.containsKey(relationView)) {
+                        Set<ViewUpdateBuffer<?>> buffers = this.view2Buffers.get(relationView);
+                        for(var buffer : buffers) {
+                                if(buffer.getUpdateListener().key == seed && buffer.getUpdateListener().listener == listener) {
+                                        // remove buffer and terminate immediately, or it will break iterator.
+                                        buffers.remove(buffer);
+                                        return;
+                                }
+                        }
+                } else
+                        throw new IllegalArgumentException();
+        }
+
+        public <D> void addUpdate(Relation<D> relation, Tuple key, D oldValue, D newValue) {
+                var views = this.relation2View.get(relation);
+                if (views != null) {
+                        for (var view : views) {
+                                var buffers = this.view2Buffers.get(view);
+                                for (var buffer : buffers) {
+                                        @SuppressWarnings("unchecked")
+                                        var typedBuffer = (ViewUpdateBuffer<D>) buffer;
+                                        typedBuffer.addChange(key, oldValue, newValue);
+                                }
+                        }
+                } else {
+                        throw new IllegalArgumentException(
+                                        "Relation " + relation.getName() + " is not in the scope of the update listener.");
+                }
+        }
+
+        public boolean hasChange() {
+                for (var bufferCollection : this.view2Buffers.values()) {
+                        for (ViewUpdateBuffer<?> buffer : bufferCollection) {
+                                if (buffer.hasChange())
+                                        return true;
+                        }
+                }
+                return false;
+        }
+
+        public void flush() {
+                for (var bufferCollection : this.view2Buffers.values()) {
+                        for (ViewUpdateBuffer<?> buffer : bufferCollection) {
+                                buffer.flush();
+                        }
+                }
+        }
+}
diff --git a/store/src/main/java/tools/refinery/store/query/internal/RelationUpdateListener.java b/store/src/main/java/tools/refinery/store/query/internal/RelationUpdateListener.java
deleted file mode 100644
index cf5260f6..00000000
--- a/store/src/main/java/tools/refinery/store/query/internal/RelationUpdateListener.java
+++ /dev/null
@@ -1,52 +0,0 @@
-package tools.refinery.store.query.internal;
-
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.Map;
-import java.util.Set;
-
-import org.eclipse.viatra.query.runtime.matchers.context.IQueryRuntimeContextListener;
-import org.eclipse.viatra.query.runtime.matchers.tuple.ITuple;
-
-import tools.refinery.store.model.Tuple;
-import tools.refinery.store.query.view.RelationView;
-
-public class RelationUpdateListener {
-        private final Map<RelationView<?>,Set<RelationUpdateListenerEntry<?>>> view2Listeners;
-        
-        public RelationUpdateListener(Set<RelationView<?>> relationViews) {
-                view2Listeners = new HashMap<>();
-                for(RelationView<?> relationView : relationViews) {
-                        view2Listeners.put(relationView, new HashSet<>());
-                }
-        }
-        public boolean containsRelationalView(RelationView<?> relationalKey) {
-                RelationView<?> relationView = relationalKey.getWrappedKey();
-                return view2Listeners.containsKey(relationView);
-        }
-        public void addListener(RelationView<?> relationalKey, ITuple seed, IQueryRuntimeContextListener listener) {
-                RelationView<?> relationView = relationalKey.getWrappedKey();
-                if(view2Listeners.containsKey(relationView)) {
-                        RelationUpdateListenerEntry<?> entry = new RelationUpdateListenerEntry<>(relationalKey, seed, listener);
-                        view2Listeners.get(relationView).add(entry);
-                } else throw new IllegalArgumentException();
-        }
-        public void removeListener(RelationView<?> relationalKey, ITuple seed, IQueryRuntimeContextListener listener) {
-                RelationView<?> relationView = relationalKey.getWrappedKey();
-                if(view2Listeners.containsKey(relationView)) {
-                        RelationUpdateListenerEntry<?> entry = new RelationUpdateListenerEntry<>(relationalKey, seed, listener);
-                        view2Listeners.get(relationView).remove(entry);
-                } else throw new IllegalArgumentException();
-        }
-        
-        public <D> void processChange(RelationView<D> relationView, Tuple tuple, D oldValue, D newValue) {
-                Set<RelationUpdateListenerEntry<?>> listeners = view2Listeners.get(relationView);
-                if(listeners != null) {
-                        for(RelationUpdateListenerEntry<?> listener : listeners) {
-                                @SuppressWarnings("unchecked")
-                                RelationUpdateListenerEntry<D> typeCorrectListener = (RelationUpdateListenerEntry<D>) listener;
-                                typeCorrectListener.processChange(tuple, oldValue, newValue);
-                        }
-                } else throw new IllegalArgumentException("View was not indexed in constructor "+relationView);
-        }
-}
diff --git a/store/src/main/java/tools/refinery/store/query/internal/RelationalEngineContext.java b/store/src/main/java/tools/refinery/store/query/internal/RelationalEngineContext.java
index 691baf81..dfbd8545 100644
--- a/store/src/main/java/tools/refinery/store/query/internal/RelationalEngineContext.java
+++ b/store/src/main/java/tools/refinery/store/query/internal/RelationalEngineContext.java
@@ -11,7 +11,7 @@ public class RelationalEngineContext implements IEngineContext{
         private final RelationalRuntimeContext runtimeContext;
         
 
-        public RelationalEngineContext(Model model, RelationUpdateListener updateListener) {
+        public RelationalEngineContext(Model model, ModelUpdateListener updateListener) {
                 runtimeContext = new RelationalRuntimeContext(model, updateListener);
         }
 
diff --git a/store/src/main/java/tools/refinery/store/query/internal/RelationalRuntimeContext.java b/store/src/main/java/tools/refinery/store/query/internal/RelationalRuntimeContext.java
index da118f26..d5112128 100644
--- a/store/src/main/java/tools/refinery/store/query/internal/RelationalRuntimeContext.java
+++ b/store/src/main/java/tools/refinery/store/query/internal/RelationalRuntimeContext.java
@@ -25,12 +25,12 @@ import tools.refinery.store.query.view.RelationView;
 
 public class RelationalRuntimeContext implements IQueryRuntimeContext {
         private final RelationalQueryMetaContext metaContext = new RelationalQueryMetaContext();
-        private final RelationUpdateListener relationUpdateListener;
+        private final ModelUpdateListener modelUpdateListener;
         private final Model model;
         
-        public RelationalRuntimeContext(Model model, RelationUpdateListener relationUpdateListener) {
+        public RelationalRuntimeContext(Model model, ModelUpdateListener relationUpdateListener) {
                 this.model = model;
-                this.relationUpdateListener = relationUpdateListener;
+                this.modelUpdateListener = relationUpdateListener;
         }
         
         @Override
@@ -58,7 +58,7 @@ public class RelationalRuntimeContext implements IQueryRuntimeContext {
         @Override
         public boolean isIndexed(IInputKey key, IndexingService service) {
                 if(key instanceof RelationView<?> relationalKey) {
-                        return this.relationUpdateListener.containsRelationalView(relationalKey);
+                        return this.modelUpdateListener.containsRelationalView(relationalKey);
                 } else {
                         return false;
                 }
@@ -74,7 +74,7 @@ public class RelationalRuntimeContext implements IQueryRuntimeContext {
         RelationView<?> checkKey(IInputKey key) {
                 if(key instanceof RelationView) {
                         RelationView<?> relationViewKey = (RelationView<?>) key;
-                        if(relationUpdateListener.containsRelationalView(relationViewKey)) {
+                        if(modelUpdateListener.containsRelationalView(relationViewKey)) {
                                 return relationViewKey;
                         } else {
                                 throw new IllegalStateException("Query is asking for non-indexed key");
@@ -144,14 +144,14 @@ public class RelationalRuntimeContext implements IQueryRuntimeContext {
         @Override
         public void addUpdateListener(IInputKey key, Tuple seed, IQueryRuntimeContextListener listener) {
                 RelationView<?> relationalKey = checkKey(key);
-                this.relationUpdateListener.addListener(relationalKey, seed, listener);
+                this.modelUpdateListener.addListener(relationalKey, seed, listener);
                 
         }
 
         @Override
         public void removeUpdateListener(IInputKey key, Tuple seed, IQueryRuntimeContextListener listener) {
                 RelationView<?> relationalKey = checkKey(key);
-                this.relationUpdateListener.removeListener(relationalKey, seed, listener);
+                this.modelUpdateListener.removeListener(relationalKey, seed, listener);
         }
 
         @Override
diff --git a/store/src/main/java/tools/refinery/store/query/internal/ViewUpdate.java b/store/src/main/java/tools/refinery/store/query/internal/ViewUpdate.java
new file mode 100644
index 00000000..d4a295f8
--- /dev/null
+++ b/store/src/main/java/tools/refinery/store/query/internal/ViewUpdate.java
@@ -0,0 +1,4 @@
+package tools.refinery.store.query.internal;
+
+record ViewUpdate (Object[] tuple, boolean isInsertion) {
+}
diff --git a/store/src/main/java/tools/refinery/store/query/internal/ViewUpdateBuffer.java b/store/src/main/java/tools/refinery/store/query/internal/ViewUpdateBuffer.java
new file mode 100644
index 00000000..6bc4c96a
--- /dev/null
+++ b/store/src/main/java/tools/refinery/store/query/internal/ViewUpdateBuffer.java
@@ -0,0 +1,46 @@
+package tools.refinery.store.query.internal;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+import tools.refinery.store.model.Tuple;
+
+public class ViewUpdateBuffer<D> {
+        protected final ViewUpdateTranslator<D> updateListener;
+        protected final List<ViewUpdate> buffer = new ArrayList<>();
+        
+        public ViewUpdateBuffer(ViewUpdateTranslator<D> updateListener) {
+                this.updateListener = updateListener;
+        }
+        
+        public ViewUpdateTranslator<D> getUpdateListener() {
+                return updateListener;
+        }
+        
+        public boolean hasChange() {
+                return ! buffer.isEmpty();
+        }
+        
+        public void addChange(Tuple tuple, D oldValue, D newValue) {
+                if(oldValue != newValue) {
+                        Object[] oldTuple = updateListener.isMatching(tuple, oldValue);
+                        Object[] newTuple = updateListener.isMatching(tuple, newValue);
+                        if(!Arrays.equals(oldTuple, newTuple)) {
+                                if(oldTuple != null) {
+                                        buffer.add(new ViewUpdate(oldTuple, false));
+                                }
+                                if(newTuple != null) {
+                                        buffer.add(new ViewUpdate(newTuple, true));
+                                }
+                        }
+                }
+        }
+        
+        public void flush() {
+                for (ViewUpdate viewChange : buffer) {
+                        updateListener.processChange(viewChange);
+                }
+                buffer.clear();
+        }
+}
diff --git a/store/src/main/java/tools/refinery/store/query/internal/RelationUpdateListenerEntry.java b/store/src/main/java/tools/refinery/store/query/internal/ViewUpdateTranslator.java
index 860a80b7..4596b9c1 100644
--- a/store/src/main/java/tools/refinery/store/query/internal/RelationUpdateListenerEntry.java
+++ b/store/src/main/java/tools/refinery/store/query/internal/ViewUpdateTranslator.java
@@ -1,6 +1,5 @@
 package tools.refinery.store.query.internal;
 
-import java.util.Arrays;
 import java.util.Objects;
 
 import org.eclipse.viatra.query.runtime.matchers.context.IQueryRuntimeContextListener;
@@ -10,30 +9,24 @@ import org.eclipse.viatra.query.runtime.matchers.tuple.Tuples;
 import tools.refinery.store.model.Tuple;
 import tools.refinery.store.query.view.RelationView;
 
-public class RelationUpdateListenerEntry<D> {
+public class ViewUpdateTranslator<D> {
         final RelationView<D> key;
         final ITuple filter;
         final IQueryRuntimeContextListener listener;
         
-        public RelationUpdateListenerEntry(RelationView<D> key, ITuple filter, IQueryRuntimeContextListener listener) {
+        public ViewUpdateTranslator(RelationView<D> key, ITuple filter, IQueryRuntimeContextListener listener) {
                 super();
                 this.key = key;
                 this.filter = filter;
                 this.listener = listener;
         }
         
-        public void processChange(Tuple tuple, D oldValue, D newValue) {
-                Object[] oldTuple = isMatching(key.getWrappedKey().transform(tuple, oldValue), filter);
-                Object[] newTuple = isMatching(key.getWrappedKey().transform(tuple, newValue), filter);
-                
-                if(!Arrays.equals(oldTuple, newTuple)) {
-                        if(oldTuple != null) {
-                                listener.update(key, Tuples.flatTupleOf(oldTuple), false);
-                        }
-                        if(newTuple != null) {
-                                listener.update(key, Tuples.flatTupleOf(newTuple), true);
-                        }
-                }
+        public void processChange(ViewUpdate change) {
+                listener.update(key, Tuples.flatTupleOf(change.tuple()), change.isInsertion());
+        }
+
+        public Object[] isMatching(Tuple tuple, D value){
+                return isMatching(key.getWrappedKey().transform(tuple, value), filter);
         }
         
         private Object[] isMatching(Object[] tuple, ITuple filter) {
@@ -55,9 +48,9 @@ public class RelationUpdateListenerEntry<D> {
         public boolean equals(Object obj) {
                 if (this == obj)
                         return true;
-                if (!(obj instanceof RelationUpdateListenerEntry))
+                if (!(obj instanceof ViewUpdateTranslator))
                         return false;
-                RelationUpdateListenerEntry<?> other = (RelationUpdateListenerEntry<?>) obj;
+                ViewUpdateTranslator<?> other = (ViewUpdateTranslator<?>) obj;
                 return Objects.equals(filter, other.filter) && Objects.equals(key, other.key)
                                 && Objects.equals(listener, other.listener);
         }