VersionedMapStoreFactoryBuilder.java is introduced, all tests are updated.

VersionedMapStoreBuilder.java is removed.

7 files changed, 255 insertions, 137 deletions

diff --git a/subprojects/store/src/main/java/tools/refinery/store/map/VersionedMapStore.java b/subprojects/store/src/main/java/tools/refinery/store/map/VersionedMapStore.java
index a8d7fb1a..7768287a 100644
--- a/subprojects/store/src/main/java/tools/refinery/store/map/VersionedMapStore.java
+++ b/subprojects/store/src/main/java/tools/refinery/store/map/VersionedMapStore.java
@@ -1,14 +1,20 @@
 package tools.refinery.store.map;
 
+import tools.refinery.store.map.internal.VersionedMapStoreFactoryBuilderImpl;
+
 import java.util.Set;
 
 public interface VersionedMapStore<K, V> {
-        
-        public VersionedMap<K, V> createMap();
 
-        public VersionedMap<K, V> createMap(long state);
-        
-        public Set<Long> getStates();
+        VersionedMap<K, V> createMap();
+
+        VersionedMap<K, V> createMap(long state);
+
+        Set<Long> getStates();
+
+        DiffCursor<K,V> getDiffCursor(long fromState, long toState);
 
-        public DiffCursor<K,V> getDiffCursor(long fromState, long toState);
-}
\ No newline at end of file
+        static <K,V> VersionedMapStoreFactoryBuilder<K,V> builder() {
+                return new VersionedMapStoreFactoryBuilderImpl<>();
+        }
+}
diff --git a/subprojects/store/src/main/java/tools/refinery/store/map/VersionedMapStoreBuilder.java b/subprojects/store/src/main/java/tools/refinery/store/map/VersionedMapStoreBuilder.java
deleted file mode 100644
index 1a9aa0b3..00000000
--- a/subprojects/store/src/main/java/tools/refinery/store/map/VersionedMapStoreBuilder.java
+++ /dev/null
@@ -1,130 +0,0 @@
-package tools.refinery.store.map;
-
-import java.util.ArrayList;
-import java.util.List;
-
-public class VersionedMapStoreBuilder<K, V> {
-        public enum StoreStrategy {
-                STATE, DELTA
-        }
-
-        public enum DeltaStorageStrategy {
-                LIST, SET
-        }
-
-        public enum StateStorageStrategy {
-                NO_NODE_CACHE, SHARED_NODE_CACHE, SHARED_NODE_CACHE_IN_GROUP
-        }
-
-        public static <K, V> VersionedMapStoreBuilder<K, V> builder() {
-                return new VersionedMapStoreBuilder<>();
-        }
-        protected VersionedMapStoreBuilder() {
-        }
-        protected VersionedMapStoreBuilder(VersionedMapStoreBuilder<K, V> other) {
-                this.defaultValue = other.defaultValue;
-                this.defaultSet = other.defaultSet;
-                this.strategy = other.strategy;
-                this.stateBasedImmutableWhenCommitting = other.stateBasedImmutableWhenCommitting;
-                this.stateBasedNodeSharingStrategy = other.stateBasedNodeSharingStrategy;
-                this.hashProvider = other.hashProvider;
-                this.deltaStorageStrategy = other.deltaStorageStrategy;
-        }
-        protected boolean defaultSet = false;
-        protected V defaultValue = null;
-        protected StoreStrategy strategy = StoreStrategy.DELTA;
-        protected Boolean stateBasedImmutableWhenCommitting = false;
-        protected StateStorageStrategy stateBasedNodeSharingStrategy = StateStorageStrategy.SHARED_NODE_CACHE_IN_GROUP;
-        protected ContinousHashProvider<K> hashProvider = null;
-        protected DeltaStorageStrategy deltaStorageStrategy = DeltaStorageStrategy.LIST;
-
-        public VersionedMapStoreBuilder<K, V> setDefaultValue(V defaultValue) {
-                var result = new VersionedMapStoreBuilder<>(this);
-                result.defaultValue = defaultValue;
-                result.defaultSet = true;
-                return result;
-        }
-
-        public VersionedMapStoreBuilder<K, V> setStrategy(StoreStrategy strategy) {
-                var result = new VersionedMapStoreBuilder<>(this);
-                result.strategy = strategy;
-                return result;
-        }
-
-        public VersionedMapStoreBuilder<K, V> setHashProvider(ContinousHashProvider<K> hashProvider) {
-                var result = new VersionedMapStoreBuilder<>(this);
-                result.hashProvider = hashProvider;
-                return result;
-        }
-
-        public VersionedMapStoreBuilder<K, V> setStateBasedImmutableWhenCommitting(boolean toImmutableWhenCommitting) {
-                var result = new VersionedMapStoreBuilder<>(this);
-                result.stateBasedImmutableWhenCommitting = toImmutableWhenCommitting;
-                return result;
-        }
-
-        public VersionedMapStoreBuilder<K, V> setStateBasedNodeSharingStrategy(StateStorageStrategy strategy) {
-                var result = new VersionedMapStoreBuilder<>(this);
-                result.stateBasedNodeSharingStrategy = strategy;
-                return result;
-        }
-
-        public VersionedMapStoreBuilder<K, V> setDeltaStorageStrategy(DeltaStorageStrategy deltaStorageStrategy) {
-                var result = new VersionedMapStoreBuilder<>(this);
-                result.deltaStorageStrategy = deltaStorageStrategy;
-                return result;
-        }
-
-        public VersionedMapStore<K, V> buildOne() {
-                if(!defaultSet) {
-                        throw new IllegalStateException("Default value is missing!");
-                }
-                return switch (strategy) {
-                        case DELTA -> new VersionedMapStoreDeltaImpl<>(
-                                        this.deltaStorageStrategy == DeltaStorageStrategy.SET,
-                                        this.defaultValue);
-                        case STATE -> new VersionedMapStoreImpl<>(
-                                        this.hashProvider,
-                                        this.defaultValue,
-                                        new VersionedMapStoreConfiguration(
-                                                        this.stateBasedImmutableWhenCommitting,
-                                                        this.stateBasedNodeSharingStrategy != StateStorageStrategy.NO_NODE_CACHE,
-                                                        this.stateBasedNodeSharingStrategy == StateStorageStrategy.SHARED_NODE_CACHE_IN_GROUP));
-                };
-        }
-
-        public List<VersionedMapStore<K, V>> buildGroup(int amount) {
-                if(!defaultSet) {
-                        throw new IllegalStateException("Default value is missing!");
-                }
-                if (this.strategy == StoreStrategy.STATE &&
-                                this.stateBasedNodeSharingStrategy == StateStorageStrategy.SHARED_NODE_CACHE_IN_GROUP) {
-                        return VersionedMapStoreImpl.createSharedVersionedMapStores(
-                                        amount,
-                                        this.hashProvider,
-                                        this.defaultValue,
-                                        new VersionedMapStoreConfiguration(
-                                                        this.stateBasedImmutableWhenCommitting,
-                                                        true,
-                                                        true));
-                } else {
-                        List<VersionedMapStore<K, V>> result = new ArrayList<>(amount);
-                        for (int i = 0; i < amount; i++) {
-                                result.add(buildOne());
-                        }
-                        return result;
-                }
-        }
-
-        @Override
-        public String toString() {
-                return "VersionedMapStoreBuilder{" +
-                                "defaultValue=" + defaultValue +
-                                ", strategy=" + strategy +
-                                ", stateBasedImmutableWhenCommitting=" + stateBasedImmutableWhenCommitting +
-                                ", stateBasedNodeSharingStrategy=" + stateBasedNodeSharingStrategy +
-                                ", hashProvider=" + hashProvider +
-                                ", deltaStorageStrategy=" + deltaStorageStrategy +
-                                '}';
-        }
-}
diff --git a/subprojects/store/src/main/java/tools/refinery/store/map/VersionedMapStoreFactory.java b/subprojects/store/src/main/java/tools/refinery/store/map/VersionedMapStoreFactory.java
new file mode 100644
index 00000000..5f882a3a
--- /dev/null
+++ b/subprojects/store/src/main/java/tools/refinery/store/map/VersionedMapStoreFactory.java
@@ -0,0 +1,19 @@
+package tools.refinery.store.map;
+
+import java.util.List;
+
+public interface VersionedMapStoreFactory<K,V> {
+        /**
+         * Constructs a new instance of {@link VersionedMap}.
+         * @return The new instance.
+         */
+        VersionedMapStore<K,V> createOne();
+
+        /**
+         * Constructs a group of {@link VersionedMap}s with the same configuration. If possible, the stores share
+         * resources with each other.
+         * @param amount The amount of new instances to be created.
+         * @return A list of new stores with the given number of elements.
+         */
+        List<VersionedMapStore<K, V>> createGroup(int amount);
+}
diff --git a/subprojects/store/src/main/java/tools/refinery/store/map/VersionedMapStoreFactoryBuilder.java b/subprojects/store/src/main/java/tools/refinery/store/map/VersionedMapStoreFactoryBuilder.java
new file mode 100644
index 00000000..9cf17b49
--- /dev/null
+++ b/subprojects/store/src/main/java/tools/refinery/store/map/VersionedMapStoreFactoryBuilder.java
@@ -0,0 +1,24 @@
+package tools.refinery.store.map;
+
+public interface VersionedMapStoreFactoryBuilder<K,V> {
+        enum StoreStrategy {
+                STATE, DELTA
+        }
+
+        enum DeltaTransactionStrategy {
+                LIST, SET
+        }
+
+        enum SharingStrategy {
+                NO_NODE_CACHE, SHARED_NODE_CACHE, SHARED_NODE_CACHE_IN_GROUP
+        }
+
+        VersionedMapStoreFactoryBuilder<K,V> defaultValue(V defaultValue);
+        VersionedMapStoreFactoryBuilder<K,V> strategy(StoreStrategy strategy);
+        VersionedMapStoreFactoryBuilder<K,V> stateBasedImmutableWhenCommitting(boolean transformToImmutable);
+        VersionedMapStoreFactoryBuilder<K,V> stateBasedSharingStrategy(SharingStrategy sharingStrategy);
+        VersionedMapStoreFactoryBuilder<K,V> stateBasedHashProvider(ContinousHashProvider<K> hashProvider);
+        VersionedMapStoreFactoryBuilder<K,V> deltaTransactionStrategy(DeltaTransactionStrategy deltaStrategy);
+
+        VersionedMapStoreFactory<K,V> build();
+}
diff --git a/subprojects/store/src/main/java/tools/refinery/store/map/internal/DeltaBasedVersionedMapStoreFactory.java b/subprojects/store/src/main/java/tools/refinery/store/map/internal/DeltaBasedVersionedMapStoreFactory.java
new file mode 100644
index 00000000..29ec0da1
--- /dev/null
+++ b/subprojects/store/src/main/java/tools/refinery/store/map/internal/DeltaBasedVersionedMapStoreFactory.java
@@ -0,0 +1,34 @@
+package tools.refinery.store.map.internal;
+
+import tools.refinery.store.map.VersionedMapStore;
+import tools.refinery.store.map.VersionedMapStoreDeltaImpl;
+import tools.refinery.store.map.VersionedMapStoreFactory;
+import tools.refinery.store.map.VersionedMapStoreFactoryBuilder;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class DeltaBasedVersionedMapStoreFactory<K, V> implements VersionedMapStoreFactory<K, V> {
+        private final V defaultValue;
+        private final boolean summarizeChanges;
+
+        public DeltaBasedVersionedMapStoreFactory(V defaultValue,
+                                                                                          VersionedMapStoreFactoryBuilder.DeltaTransactionStrategy deltaTransactionStrategy) {
+                this.defaultValue = defaultValue;
+                this.summarizeChanges = deltaTransactionStrategy == VersionedMapStoreFactoryBuilder.DeltaTransactionStrategy.SET;
+        }
+
+        @Override
+        public VersionedMapStore<K, V> createOne() {
+                return new VersionedMapStoreDeltaImpl<>(summarizeChanges, defaultValue);
+        }
+
+        @Override
+        public List<VersionedMapStore<K, V>> createGroup(int amount) {
+                List<VersionedMapStore<K, V>> result = new ArrayList<>(amount);
+                for(int i=0; i<amount; i++) {
+                        result.add(new VersionedMapStoreDeltaImpl<>(summarizeChanges,defaultValue));
+                }
+                return result;
+        }
+}
diff --git a/subprojects/store/src/main/java/tools/refinery/store/map/internal/StateBasedVersionedMapStoreFactory.java b/subprojects/store/src/main/java/tools/refinery/store/map/internal/StateBasedVersionedMapStoreFactory.java
new file mode 100644
index 00000000..80dc347f
--- /dev/null
+++ b/subprojects/store/src/main/java/tools/refinery/store/map/internal/StateBasedVersionedMapStoreFactory.java
@@ -0,0 +1,33 @@
+package tools.refinery.store.map.internal;
+
+import tools.refinery.store.map.*;
+
+import java.util.List;
+
+public class StateBasedVersionedMapStoreFactory<K, V> implements VersionedMapStoreFactory<K, V> {
+        private final V defaultValue;
+        private final ContinousHashProvider<K> continousHashProvider;
+        private final VersionedMapStoreConfiguration config;
+
+        public StateBasedVersionedMapStoreFactory(V defaultValue, Boolean transformToImmutable, VersionedMapStoreFactoryBuilder.SharingStrategy sharingStrategy, ContinousHashProvider<K> continousHashProvider) {
+                this.defaultValue = defaultValue;
+                this.continousHashProvider = continousHashProvider;
+
+                this.config = new VersionedMapStoreConfiguration(
+                                transformToImmutable,
+                                sharingStrategy == VersionedMapStoreFactoryBuilder.SharingStrategy.SHARED_NODE_CACHE || sharingStrategy == VersionedMapStoreFactoryBuilder.SharingStrategy.SHARED_NODE_CACHE_IN_GROUP,
+                                sharingStrategy == VersionedMapStoreFactoryBuilder.SharingStrategy.SHARED_NODE_CACHE_IN_GROUP);
+        }
+
+        @Override
+        public VersionedMapStore<K, V> createOne() {
+                return new VersionedMapStoreImpl<>(continousHashProvider, defaultValue, config);
+
+        }
+
+        @Override
+        public List<VersionedMapStore<K, V>> createGroup(int amount) {
+                return VersionedMapStoreImpl.createSharedVersionedMapStores(amount, continousHashProvider, defaultValue,
+                                config);
+        }
+}
diff --git a/subprojects/store/src/main/java/tools/refinery/store/map/internal/VersionedMapStoreFactoryBuilderImpl.java b/subprojects/store/src/main/java/tools/refinery/store/map/internal/VersionedMapStoreFactoryBuilderImpl.java
new file mode 100644
index 00000000..3719eef5
--- /dev/null
+++ b/subprojects/store/src/main/java/tools/refinery/store/map/internal/VersionedMapStoreFactoryBuilderImpl.java
@@ -0,0 +1,132 @@
+package tools.refinery.store.map.internal;
+
+import tools.refinery.store.map.ContinousHashProvider;
+import tools.refinery.store.map.VersionedMapStoreFactory;
+import tools.refinery.store.map.VersionedMapStoreFactoryBuilder;
+
+public class VersionedMapStoreFactoryBuilderImpl<K, V> implements VersionedMapStoreFactoryBuilder<K, V> {
+
+        private boolean defaultSet = false;
+        private V defaultValue;
+        private StoreStrategy strategy = null;
+        private Boolean transformToImmutable = null;
+        private SharingStrategy sharingStrategy = null;
+        private ContinousHashProvider<K> continousHashProvider = null;
+        private DeltaTransactionStrategy deltaTransactionStrategy = null;
+
+        private StoreStrategy checkStrategy() {
+                StoreStrategy currentStrategy = strategy;
+                currentStrategy = mergeStrategies(currentStrategy, transformToImmutable, StoreStrategy.STATE);
+                currentStrategy = mergeStrategies(currentStrategy, sharingStrategy, StoreStrategy.STATE);
+                currentStrategy = mergeStrategies(currentStrategy, continousHashProvider, StoreStrategy.STATE);
+                currentStrategy = mergeStrategies(currentStrategy, deltaTransactionStrategy, StoreStrategy.DELTA);
+                return currentStrategy;
+        }
+
+        private StoreStrategy mergeStrategies(StoreStrategy old, StoreStrategy newStrategy) {
+                if (old != null && newStrategy != null && old != newStrategy) {
+                        throw new IllegalArgumentException("Mixed strategy parametrization in VersionedMap builder!");
+                }
+
+                if (old != null) {
+                        return old;
+                } else {
+                        return newStrategy;
+                }
+        }
+
+        private StoreStrategy mergeStrategies(StoreStrategy old, Object parameter, StoreStrategy newStrategy) {
+                if (parameter != null) {
+                        return mergeStrategies(old, newStrategy);
+                } else {
+                        return old;
+                }
+        }
+
+        @Override
+        public VersionedMapStoreFactoryBuilder<K, V> defaultValue(V defaultValue) {
+                this.defaultSet = true;
+                this.defaultValue = defaultValue;
+                return this;
+        }
+
+        @Override
+        public VersionedMapStoreFactoryBuilder<K, V> strategy(StoreStrategy strategy) {
+                this.strategy = strategy;
+                checkStrategy();
+                return this;
+        }
+
+        @Override
+        public VersionedMapStoreFactoryBuilder<K, V> stateBasedImmutableWhenCommitting(boolean transformToImmutable) {
+                this.transformToImmutable = transformToImmutable;
+                checkStrategy();
+                return this;
+        }
+
+        @Override
+        public VersionedMapStoreFactoryBuilder<K, V> stateBasedSharingStrategy(SharingStrategy sharingStrategy) {
+                this.sharingStrategy = sharingStrategy;
+                checkStrategy();
+                return this;
+        }
+
+        @Override
+        public VersionedMapStoreFactoryBuilder<K, V> stateBasedHashProvider(ContinousHashProvider<K> hashProvider) {
+                this.continousHashProvider = hashProvider;
+                checkStrategy();
+                return this;
+        }
+
+        @Override
+        public VersionedMapStoreFactoryBuilder<K, V> deltaTransactionStrategy(DeltaTransactionStrategy deltaTransactionStrategy) {
+                this.deltaTransactionStrategy = deltaTransactionStrategy;
+                checkStrategy();
+                return this;
+        }
+
+        private <T> T getOrDefault(T value, T defaultValue) {
+                if(value != null) {
+                        return value;
+                } else {
+                        return defaultValue;
+                }
+        }
+
+        @Override
+        public VersionedMapStoreFactory<K, V> build() {
+                if (!defaultSet) {
+                        throw new IllegalArgumentException("Default value is missing!");
+                }
+                var strategyToUse = checkStrategy();
+                if (strategyToUse == null) {
+                        return new DeltaBasedVersionedMapStoreFactory<>(defaultValue,
+                                        getOrDefault(deltaTransactionStrategy, DeltaTransactionStrategy.LIST));
+                }
+                return switch (strategyToUse) {
+                        case STATE -> {
+                                if(continousHashProvider == null) {
+                                        throw new IllegalArgumentException("Continuous hash provider is missing!");
+                                }
+                                yield new StateBasedVersionedMapStoreFactory<>(defaultValue,
+                                                getOrDefault(transformToImmutable,true),
+                                                getOrDefault(sharingStrategy, SharingStrategy.SHARED_NODE_CACHE_IN_GROUP),
+                                                continousHashProvider);
+                        }
+                        case DELTA -> new DeltaBasedVersionedMapStoreFactory<>(defaultValue,
+                                        getOrDefault(deltaTransactionStrategy, DeltaTransactionStrategy.LIST));
+                };
+        }
+
+        @Override
+        public String toString() {
+                return "VersionedMapStoreBuilder{" +
+                                "defaultValue=" + defaultValue +
+                                ", strategy=" + strategy +
+                                ", stateBasedImmutableWhenCommitting=" + transformToImmutable +
+                                ", stateBasedNodeSharingStrategy=" + sharingStrategy +
+                                ", hashProvider=" + continousHashProvider +
+                                ", deltaStorageStrategy=" + deltaTransactionStrategy +
+                                '}';
+        }
+}