VersionedMapStoreBuilder returns builder state.

1 files changed, 67 insertions, 18 deletions

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
index 7e413a86..1a9aa0b3 100644
--- a/subprojects/store/src/main/java/tools/refinery/store/map/VersionedMapStoreBuilder.java
+++ b/subprojects/store/src/main/java/tools/refinery/store/map/VersionedMapStoreBuilder.java
@@ -2,7 +2,6 @@ package tools.refinery.store.map;
 
 import java.util.ArrayList;
 import java.util.List;
-import java.util.Optional;
 
 public class VersionedMapStoreBuilder<K, V> {
         public enum StoreStrategy {
@@ -17,41 +16,76 @@ public class VersionedMapStoreBuilder<K, V> {
                 NO_NODE_CACHE, SHARED_NODE_CACHE, SHARED_NODE_CACHE_IN_GROUP
         }
 
-        protected Optional<V> defaultValue = Optional.empty();
+        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 Optional<ContinousHashProvider<K>> hashProvider = Optional.empty();
+        protected ContinousHashProvider<K> hashProvider = null;
         protected DeltaStorageStrategy deltaStorageStrategy = DeltaStorageStrategy.LIST;
 
-        public void setDefaultValue(V defaultValue) {
-                this.defaultValue = Optional.of(defaultValue);
+        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 void setStrategy(StoreStrategy strategy) {
-                this.strategy = strategy;
+        public VersionedMapStoreBuilder<K, V> setHashProvider(ContinousHashProvider<K> hashProvider) {
+                var result = new VersionedMapStoreBuilder<>(this);
+                result.hashProvider = hashProvider;
+                return result;
         }
 
-        public void setHashProvider(ContinousHashProvider<K> hashProvider) {
-                this.hashProvider = Optional.of(hashProvider);
+        public VersionedMapStoreBuilder<K, V> setStateBasedImmutableWhenCommitting(boolean toImmutableWhenCommitting) {
+                var result = new VersionedMapStoreBuilder<>(this);
+                result.stateBasedImmutableWhenCommitting = toImmutableWhenCommitting;
+                return result;
         }
 
-        public void setStateBasedImmutableWhenCommitting(boolean toImmutableWhenCommitting) {
-                this.stateBasedImmutableWhenCommitting = toImmutableWhenCommitting;
+        public VersionedMapStoreBuilder<K, V> setStateBasedNodeSharingStrategy(StateStorageStrategy strategy) {
+                var result = new VersionedMapStoreBuilder<>(this);
+                result.stateBasedNodeSharingStrategy = strategy;
+                return result;
         }
 
-        public void setStateBasedNodeSharingStrategy(StateStorageStrategy strategy) {
-                this.stateBasedNodeSharingStrategy = strategy;
+        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.orElseThrow());
+                                        this.defaultValue);
                         case STATE -> new VersionedMapStoreImpl<>(
-                                        this.hashProvider.orElseThrow(),
-                                        this.defaultValue.orElseThrow(),
+                                        this.hashProvider,
+                                        this.defaultValue,
                                         new VersionedMapStoreConfiguration(
                                                         this.stateBasedImmutableWhenCommitting,
                                                         this.stateBasedNodeSharingStrategy != StateStorageStrategy.NO_NODE_CACHE,
@@ -60,12 +94,15 @@ public class VersionedMapStoreBuilder<K, V> {
         }
 
         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.orElseThrow(),
-                                        this.defaultValue.orElseThrow(),
+                                        this.hashProvider,
+                                        this.defaultValue,
                                         new VersionedMapStoreConfiguration(
                                                         this.stateBasedImmutableWhenCommitting,
                                                         true,
@@ -78,4 +115,16 @@ public class VersionedMapStoreBuilder<K, V> {
                         return result;
                 }
         }
+
+        @Override
+        public String toString() {
+                return "VersionedMapStoreBuilder{" +
+                                "defaultValue=" + defaultValue +
+                                ", strategy=" + strategy +
+                                ", stateBasedImmutableWhenCommitting=" + stateBasedImmutableWhenCommitting +
+                                ", stateBasedNodeSharingStrategy=" + stateBasedNodeSharingStrategy +
+                                ", hashProvider=" + hashProvider +
+                                ", deltaStorageStrategy=" + deltaStorageStrategy +
+                                '}';
+        }
 }