From 7f6a2528bf83f93e3d35eff228f7180e0181f4eb Mon Sep 17 00:00:00 2001
From: Kristóf Marussy <marussy@mit.bme.hu>
Date: Thu, 29 Jul 2021 19:01:25 +0200
Subject: Add new data structure for backend
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Co-authored-by: Oszkár Semeráth <semerath@mit.bme.hu>
---
 .../solver/data/map/internal/VersionedMapImpl.java | 168 +++++++++++++++++++++
 1 file changed, 168 insertions(+)
 create mode 100644 model-data/src/main/java/org/eclipse/viatra/solver/data/map/internal/VersionedMapImpl.java

(limited to 'model-data/src/main/java/org/eclipse/viatra/solver/data/map/internal/VersionedMapImpl.java')

diff --git a/model-data/src/main/java/org/eclipse/viatra/solver/data/map/internal/VersionedMapImpl.java b/model-data/src/main/java/org/eclipse/viatra/solver/data/map/internal/VersionedMapImpl.java
new file mode 100644
index 00000000..715a9d74
--- /dev/null
+++ b/model-data/src/main/java/org/eclipse/viatra/solver/data/map/internal/VersionedMapImpl.java
@@ -0,0 +1,168 @@
+package org.eclipse.viatra.solver.data.map.internal;
+
+import java.util.Iterator;
+import java.util.LinkedList;
+import java.util.List;
+
+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;
+
+/**
+ * Not threadSafe in itself
+ * @author Oszkar Semerath
+ *
+ * @param <KEY>
+ * @param <VALUE>
+ */
+public class VersionedMapImpl<KEY,VALUE> implements VersionedMap<KEY,VALUE>{
+	protected final VersionedMapStoreImpl<KEY,VALUE> store;
+	
+	protected final ContinousHashProvider<? super KEY> hashProvider;
+	protected final VALUE defaultValue;
+	protected Node<KEY,VALUE> root;
+	
+	public VersionedMapImpl(
+			VersionedMapStoreImpl<KEY,VALUE> store,
+			ContinousHashProvider<? super KEY> hashProvider,
+			VALUE defaultValue)
+	{
+		this.store = store;
+		this.hashProvider = hashProvider;
+		this.defaultValue = defaultValue;
+		this.root = null;
+	}
+	public VersionedMapImpl(
+			VersionedMapStoreImpl<KEY,VALUE> store,
+			ContinousHashProvider<? super KEY> hashProvider,
+			VALUE defaultValue, Node<KEY,VALUE> data)
+	{
+		this.store = store;
+		this.hashProvider = hashProvider;
+		this.defaultValue = defaultValue;
+		this.root = data;
+	}
+		
+	public VALUE getDefaultValue() {
+		return defaultValue;
+	}
+	public ContinousHashProvider<? super KEY> getHashProvider() {
+		return hashProvider;
+	}
+	@Override
+	public void put(KEY key, VALUE value) {
+		if(root!=null) {
+			root = root.putValue(key, value, hashProvider, defaultValue, hashProvider.getHash(key, 0), 0);
+		} else {
+			root = MutableNode.initialize(key, value, hashProvider, defaultValue);
+		}
+	}
+	
+	@Override
+	public void putAll(Cursor<KEY, VALUE> cursor) {
+		if(cursor.getDependingMaps().contains(this)) {
+			List<KEY> keys = new LinkedList<>();
+			List<VALUE> values = new LinkedList<>();
+			while(cursor.move()) {
+				keys.add(cursor.getKey());
+				values.add(cursor.getValue());
+			}
+			Iterator<KEY> keyIterator = keys.iterator();
+			Iterator<VALUE> valueIterator = values.iterator();
+			while(keyIterator.hasNext()) {
+				this.put(keyIterator.next(), valueIterator.next());
+			}
+		} else {
+			while(cursor.move()) {
+				this.put(cursor.getKey(), cursor.getValue());
+			}
+		}
+	}
+	
+	@Override
+	public VALUE get(KEY key) {
+		if(root!=null) {
+			return root.getValue(key, hashProvider, defaultValue, hashProvider.getHash(key, 0), 0);
+		} else {
+			return defaultValue;
+		}
+	}
+	@Override
+	public long getSize() {
+		if(root == null) {
+			return 0;
+		} else {
+			return root.getSize();
+		}
+	}
+
+	@Override
+	public Cursor<KEY, VALUE> getCursor() {
+		MapCursor<KEY,VALUE> cursor = new MapCursor<>(this.root,this);
+		return cursor;
+	}
+	@Override
+	public DiffCursor<KEY, VALUE> getDiffCursor(long toVersion) {
+		Cursor<KEY, VALUE> fromCursor = this.getCursor();
+		VersionedMap<KEY, VALUE> toMap = this.store.createMap(toVersion);
+		Cursor<KEY, VALUE> toCursor = toMap.getCursor();
+		return new MapDiffCursor<KEY, VALUE>(this.hashProvider,this.defaultValue, fromCursor, toCursor);
+		
+	}
+	
+
+	@Override
+	public long commit() {
+		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.revert(state);
+	}
+	
+	@Override
+	public int hashCode() {
+		final int prime = 31;
+		int result = 1;
+		result = prime * result + ((root == null) ? 0 : root.hashCode());
+		return result;
+	}
+	
+	@Override
+	public boolean equals(Object obj) {
+		if (this == obj)
+			return true;
+		if (obj == null)
+			return false;
+		if (getClass() != obj.getClass())
+			return false;
+		VersionedMapImpl<?,?> other = (VersionedMapImpl<?,?>) obj;
+		if (root == null) {
+			if (other.root != null)
+				return false;
+		} else if (!root.equals(other.root))
+			return false;
+		return true;
+	}
+	public void prettyPrint() {
+		StringBuilder s = new StringBuilder();
+		if(this.root != null) {
+			this.root.prettyPrint(s, 0, -1);
+			System.out.println(s.toString());
+		} else {
+			System.out.println("empty tree");
+		}
+	}
+	public void checkIntegrity() {
+		if(this.root != null) {
+			this.root.checkIntegrity(hashProvider, defaultValue, 0);
+		}
+	}
+
+}
-- 
cgit v1.2.3-54-g00ecf