VersionedMap interface updates: diffcursors and synchronization

4 files changed, 60 insertions, 33 deletions

diff --git a/Solvers/VIATRA-Solver/org.eclipse.viatra.solver.data/src/org/eclipse/viatra/solver/data/map/VersionedMap.java b/Solvers/VIATRA-Solver/org.eclipse.viatra.solver.data/src/org/eclipse/viatra/solver/data/map/VersionedMap.java
index 28264f2f..2754c246 100644
--- a/Solvers/VIATRA-Solver/org.eclipse.viatra.solver.data/src/org/eclipse/viatra/solver/data/map/VersionedMap.java
+++ b/Solvers/VIATRA-Solver/org.eclipse.viatra.solver.data/src/org/eclipse/viatra/solver/data/map/VersionedMap.java
@@ -9,4 +9,5 @@ public interface VersionedMap<KEY,VALUE> extends Versioned{
         public long getSize();
         public Iterator<Map.Entry<KEY,VALUE>> getIterator();
         public Cursor<KEY,VALUE> getCursor();
+        public DiffCursor<KEY,VALUE> getDiffCursor(long state);
 }
diff --git a/Solvers/VIATRA-Solver/org.eclipse.viatra.solver.data/src/org/eclipse/viatra/solver/data/map/VersionedMapStore.java b/Solvers/VIATRA-Solver/org.eclipse.viatra.solver.data/src/org/eclipse/viatra/solver/data/map/VersionedMapStore.java
index 5a54c13b..d92e5ad6 100644
--- a/Solvers/VIATRA-Solver/org.eclipse.viatra.solver.data/src/org/eclipse/viatra/solver/data/map/VersionedMapStore.java
+++ b/Solvers/VIATRA-Solver/org.eclipse.viatra.solver.data/src/org/eclipse/viatra/solver/data/map/VersionedMapStore.java
@@ -6,6 +6,5 @@ public interface VersionedMapStore<KEY, VALUE> {
 
         public VersionedMap<KEY, VALUE> createMap(long state) throws IllegalAccessException;
 
-        // long addState(Node<KEY, VALUE> data);
-        //public void removeState(long state);
+        public DiffCursor<KEY,VALUE> getDiffCursor(long fromState, long toState);
 }
\ No newline at end of file
diff --git a/Solvers/VIATRA-Solver/org.eclipse.viatra.solver.data/src/org/eclipse/viatra/solver/data/map/VersionedMapStoreImpl.java b/Solvers/VIATRA-Solver/org.eclipse.viatra.solver.data/src/org/eclipse/viatra/solver/data/map/VersionedMapStoreImpl.java
index 0c00108b..b6a615ed 100644
--- a/Solvers/VIATRA-Solver/org.eclipse.viatra.solver.data/src/org/eclipse/viatra/solver/data/map/VersionedMapStoreImpl.java
+++ b/Solvers/VIATRA-Solver/org.eclipse.viatra.solver.data/src/org/eclipse/viatra/solver/data/map/VersionedMapStoreImpl.java
@@ -5,6 +5,7 @@ import java.util.Map;
 import java.util.Set;
 
 import org.eclipse.viatra.solver.data.map.internal.ImmutableNode;
+import org.eclipse.viatra.solver.data.map.internal.MapDiffCursor;
 import org.eclipse.viatra.solver.data.map.internal.Node;
 import org.eclipse.viatra.solver.data.map.internal.VersionedMapImpl;
 
@@ -25,7 +26,7 @@ public class VersionedMapStoreImpl<KEY,VALUE> implements VersionedMapStore<KEY,
                 nodeCache = new HashMap<>();
         }
         
-        Set<Long> getStates() {
+        synchronized Set<Long> getStates() {
                 return states.keySet();
         }
         
@@ -34,29 +35,54 @@ public class VersionedMapStoreImpl<KEY,VALUE> implements VersionedMapStore<KEY,
                 return new VersionedMapImpl<KEY,VALUE>(this,hashProvider,defaultValue);
         }
         @Override
-        public VersionedMap<KEY,VALUE> createMap(long state) throws IllegalAccessException {
-                ImmutableNode<KEY, VALUE> data = getStateData(state);
+        public VersionedMap<KEY,VALUE> createMap(long state) {
+                ImmutableNode<KEY, VALUE> data = revert(state);
                 if(data != null) {
                         return new VersionedMapImpl<KEY,VALUE>(this,hashProvider,defaultValue,data); 
                 } else {
-                        throw new IllegalAccessException("Store does not contain state " + state + "!");
+                        throw new IllegalArgumentException("Store does not contain state " + state + "!");
                 }
         }
-
-        private long getNextID() {
-                if(nextID == Long.MAX_VALUE) throw new IllegalStateException("Map store run out of Id-s");
-                return nextID++;
-        }
         
-        public ImmutableNode<KEY,VALUE> getStateData(long state) {
+        synchronized public ImmutableNode<KEY,VALUE> revert(long state) {
                 return states.get(state);
         }
-        public Map<Node<KEY,VALUE>, ImmutableNode<KEY,VALUE>> getStore() {
-                return this.nodeCache;
-        }
-        public long addState(ImmutableNode<KEY,VALUE> data) {
-                long id = getNextID();
-                states.put(id,data);
+        synchronized public long commit(Node<KEY,VALUE> data, VersionedMapImpl<KEY, VALUE> mapToUpdateRoot) {
+                ImmutableNode<KEY,VALUE> immutable;
+                if(data != null) {
+                        if(this.nodeCache != null) {
+                                immutable = data.toImmutable(this.nodeCache);
+                        } else {
+                                immutable = data.toImmutable();
+                        }
+                } else {
+                        immutable = null;
+                }
+                
+                
+                if(nextID == Long.MAX_VALUE) throw new IllegalStateException(
+                        "Map store run out of Id-s");
+                long id = nextID++;
+                this.states.put(id, immutable);
+                //mapToUpdateRoot.setRoot(immutable);
                 return id;
         }
+        
+//      public Map<Node<KEY,VALUE>, ImmutableNode<KEY,VALUE>> getStore() {
+//              return this.nodeCache;
+//      }
+//      public long addState(ImmutableNode<KEY,VALUE> data) {
+//              
+//              states.put(id,data);
+//              return id;
+//      }
+
+        @Override
+        public DiffCursor<KEY, VALUE> getDiffCursor(long fromState, long toState) {
+                VersionedMap<KEY, VALUE> map1 = createMap(fromState);
+                VersionedMap<KEY, VALUE> map2 = createMap(toState);
+                Cursor<KEY, VALUE> cursor1 = map1.getCursor();
+                Cursor<KEY, VALUE> cursor2 = map2.getCursor();
+                return new MapDiffCursor<KEY, VALUE>(this.defaultValue,cursor1,cursor2);
+        }
 }
diff --git a/Solvers/VIATRA-Solver/org.eclipse.viatra.solver.data/src/org/eclipse/viatra/solver/data/map/internal/VersionedMapImpl.java b/Solvers/VIATRA-Solver/org.eclipse.viatra.solver.data/src/org/eclipse/viatra/solver/data/map/internal/VersionedMapImpl.java
index fd5c9b41..4fb8d7f8 100644
--- a/Solvers/VIATRA-Solver/org.eclipse.viatra.solver.data/src/org/eclipse/viatra/solver/data/map/internal/VersionedMapImpl.java
+++ b/Solvers/VIATRA-Solver/org.eclipse.viatra.solver.data/src/org/eclipse/viatra/solver/data/map/internal/VersionedMapImpl.java
@@ -5,6 +5,7 @@ import java.util.Map;
 
 import org.eclipse.viatra.solver.data.map.ContinousHashProvider;
 import org.eclipse.viatra.solver.data.map.Cursor;
+import org.eclipse.viatra.solver.data.map.DiffCursor;
 import org.eclipse.viatra.solver.data.map.VersionedMap;
 import org.eclipse.viatra.solver.data.map.VersionedMapStoreImpl;
 
@@ -84,28 +85,27 @@ public class VersionedMapImpl<KEY,VALUE> implements VersionedMap<KEY,VALUE>{
                 MapEntryIterator<KEY,VALUE> cursor = new MapEntryIterator<>(this.root,this);
                 return cursor;
         }
+        @Override
+        public DiffCursor<KEY, VALUE> getDiffCursor(long to) {
+                Cursor<KEY, VALUE> fromCursor = this.getCursor();
+                VersionedMap<KEY, VALUE> toMap = this.store.createMap(to);
+                Cursor<KEY, VALUE> toCursor = toMap.getCursor();
+                return new MapDiffCursor<KEY, VALUE>(defaultValue, fromCursor, toCursor);
+                
+        }
+        
 
         @Override
         public long commit() {
-                ImmutableNode<KEY,VALUE> immutable;
-                if(this.root != null) {
-                        Map<Node<KEY, VALUE>, ImmutableNode<KEY, VALUE>> cache = this.store.getStore();
-                        if(cache != null) {
-                                immutable = root.toImmutable(cache);
-                        } else {
-                                immutable = root.toImmutable();
-                        }
-                        
-                } else {
-                        immutable = null;
-                }
-                long result = this.store.addState(immutable);
-                return result;
+                return this.store.commit(root,this);
+        }
+        public void setRoot(Node<KEY, VALUE> root) {
+                this.root = root;
         }
 
         @Override
         public void restore(long state) {
-                root = this.store.getStateData(state);
+                root = this.store.revert(state);
         }
         
         @Override
@@ -146,4 +146,5 @@ public class VersionedMapImpl<KEY,VALUE> implements VersionedMap<KEY,VALUE>{
                         this.root.checkIntegrity(hashProvider, defaultValue, 0);
                 }
         }
+
 }