From a6dcff6293e960b420e26c57374a281467821556 Mon Sep 17 00:00:00 2001 From: OszkarSemerath Date: Fri, 21 Jul 2023 20:27:30 +0200 Subject: VersionedMapStoreFactoryBuilder.java is introduced, all tests are updated. VersionedMapStoreBuilder.java is removed. --- .../refinery/store/map/VersionedMapStore.java | 20 ++-- .../store/map/VersionedMapStoreBuilder.java | 130 -------------------- .../store/map/VersionedMapStoreFactory.java | 19 +++ .../store/map/VersionedMapStoreFactoryBuilder.java | 24 ++++ .../DeltaBasedVersionedMapStoreFactory.java | 34 ++++++ .../StateBasedVersionedMapStoreFactory.java | 33 ++++++ .../VersionedMapStoreFactoryBuilderImpl.java | 132 +++++++++++++++++++++ 7 files changed, 255 insertions(+), 137 deletions(-) delete mode 100644 subprojects/store/src/main/java/tools/refinery/store/map/VersionedMapStoreBuilder.java create mode 100644 subprojects/store/src/main/java/tools/refinery/store/map/VersionedMapStoreFactory.java create mode 100644 subprojects/store/src/main/java/tools/refinery/store/map/VersionedMapStoreFactoryBuilder.java create mode 100644 subprojects/store/src/main/java/tools/refinery/store/map/internal/DeltaBasedVersionedMapStoreFactory.java create mode 100644 subprojects/store/src/main/java/tools/refinery/store/map/internal/StateBasedVersionedMapStoreFactory.java create mode 100644 subprojects/store/src/main/java/tools/refinery/store/map/internal/VersionedMapStoreFactoryBuilderImpl.java (limited to 'subprojects/store/src/main/java/tools') 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 { - - public VersionedMap createMap(); - public VersionedMap createMap(long state); - - public Set getStates(); + VersionedMap createMap(); + + VersionedMap createMap(long state); + + Set getStates(); + + DiffCursor getDiffCursor(long fromState, long toState); - public DiffCursor getDiffCursor(long fromState, long toState); -} \ No newline at end of file + static VersionedMapStoreFactoryBuilder 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 { - 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 VersionedMapStoreBuilder builder() { - return new VersionedMapStoreBuilder<>(); - } - protected VersionedMapStoreBuilder() { - } - protected VersionedMapStoreBuilder(VersionedMapStoreBuilder 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 hashProvider = null; - protected DeltaStorageStrategy deltaStorageStrategy = DeltaStorageStrategy.LIST; - - public VersionedMapStoreBuilder setDefaultValue(V defaultValue) { - var result = new VersionedMapStoreBuilder<>(this); - result.defaultValue = defaultValue; - result.defaultSet = true; - return result; - } - - public VersionedMapStoreBuilder setStrategy(StoreStrategy strategy) { - var result = new VersionedMapStoreBuilder<>(this); - result.strategy = strategy; - return result; - } - - public VersionedMapStoreBuilder setHashProvider(ContinousHashProvider hashProvider) { - var result = new VersionedMapStoreBuilder<>(this); - result.hashProvider = hashProvider; - return result; - } - - public VersionedMapStoreBuilder setStateBasedImmutableWhenCommitting(boolean toImmutableWhenCommitting) { - var result = new VersionedMapStoreBuilder<>(this); - result.stateBasedImmutableWhenCommitting = toImmutableWhenCommitting; - return result; - } - - public VersionedMapStoreBuilder setStateBasedNodeSharingStrategy(StateStorageStrategy strategy) { - var result = new VersionedMapStoreBuilder<>(this); - result.stateBasedNodeSharingStrategy = strategy; - return result; - } - - public VersionedMapStoreBuilder setDeltaStorageStrategy(DeltaStorageStrategy deltaStorageStrategy) { - var result = new VersionedMapStoreBuilder<>(this); - result.deltaStorageStrategy = deltaStorageStrategy; - return result; - } - - public VersionedMapStore 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> 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> 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 { + /** + * Constructs a new instance of {@link VersionedMap}. + * @return The new instance. + */ + VersionedMapStore 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> 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 { + enum StoreStrategy { + STATE, DELTA + } + + enum DeltaTransactionStrategy { + LIST, SET + } + + enum SharingStrategy { + NO_NODE_CACHE, SHARED_NODE_CACHE, SHARED_NODE_CACHE_IN_GROUP + } + + VersionedMapStoreFactoryBuilder defaultValue(V defaultValue); + VersionedMapStoreFactoryBuilder strategy(StoreStrategy strategy); + VersionedMapStoreFactoryBuilder stateBasedImmutableWhenCommitting(boolean transformToImmutable); + VersionedMapStoreFactoryBuilder stateBasedSharingStrategy(SharingStrategy sharingStrategy); + VersionedMapStoreFactoryBuilder stateBasedHashProvider(ContinousHashProvider hashProvider); + VersionedMapStoreFactoryBuilder deltaTransactionStrategy(DeltaTransactionStrategy deltaStrategy); + + VersionedMapStoreFactory 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 implements VersionedMapStoreFactory { + 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 createOne() { + return new VersionedMapStoreDeltaImpl<>(summarizeChanges, defaultValue); + } + + @Override + public List> createGroup(int amount) { + List> result = new ArrayList<>(amount); + for(int i=0; i(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 implements VersionedMapStoreFactory { + private final V defaultValue; + private final ContinousHashProvider continousHashProvider; + private final VersionedMapStoreConfiguration config; + + public StateBasedVersionedMapStoreFactory(V defaultValue, Boolean transformToImmutable, VersionedMapStoreFactoryBuilder.SharingStrategy sharingStrategy, ContinousHashProvider 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 createOne() { + return new VersionedMapStoreImpl<>(continousHashProvider, defaultValue, config); + + } + + @Override + public List> 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 implements VersionedMapStoreFactoryBuilder { + + private boolean defaultSet = false; + private V defaultValue; + private StoreStrategy strategy = null; + private Boolean transformToImmutable = null; + private SharingStrategy sharingStrategy = null; + private ContinousHashProvider 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 defaultValue(V defaultValue) { + this.defaultSet = true; + this.defaultValue = defaultValue; + return this; + } + + @Override + public VersionedMapStoreFactoryBuilder strategy(StoreStrategy strategy) { + this.strategy = strategy; + checkStrategy(); + return this; + } + + @Override + public VersionedMapStoreFactoryBuilder stateBasedImmutableWhenCommitting(boolean transformToImmutable) { + this.transformToImmutable = transformToImmutable; + checkStrategy(); + return this; + } + + @Override + public VersionedMapStoreFactoryBuilder stateBasedSharingStrategy(SharingStrategy sharingStrategy) { + this.sharingStrategy = sharingStrategy; + checkStrategy(); + return this; + } + + @Override + public VersionedMapStoreFactoryBuilder stateBasedHashProvider(ContinousHashProvider hashProvider) { + this.continousHashProvider = hashProvider; + checkStrategy(); + return this; + } + + @Override + public VersionedMapStoreFactoryBuilder deltaTransactionStrategy(DeltaTransactionStrategy deltaTransactionStrategy) { + this.deltaTransactionStrategy = deltaTransactionStrategy; + checkStrategy(); + return this; + } + + private T getOrDefault(T value, T defaultValue) { + if(value != null) { + return value; + } else { + return defaultValue; + } + } + + @Override + public VersionedMapStoreFactory 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 + + '}'; + } +} -- cgit v1.2.3-70-g09d2