Speiger/Primitive-Collections
0
0
Fork 1
Code Issues 1 Pull Requests Projects Releases 1 Wiki Activity

Reworked Module Settings System

Browse Source 
Changelog:
- Added: Dependency System that will resolve missing classes and enable
them as needed. (This isn't perfect on some low level modules like
Functions)
- Added: Dependency Error system that will throw errors if a dependency
is that is required is specifically disabled.
- Added: Default setting for "undefined" entries.
- Fixed: A few bugs that made the dependency system unnecessary
difficult.
- Updated: Documentation
This commit is contained in:
Speiger
2025-03-09 23:29:13 +01:00
parent ebe75b0fea
commit 20927a97eb
34 changed files with 3189 additions and 645 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/builder/java/speiger/src/builder/PrimitiveCollectionsBuilder.java
+1 -2
View File
@@ -133,7 +133,6 @@ public class PrimitiveCollectionsBuilder extends TemplateProcessor
biPackages.forEach(modules.get(i)::init);
}
modules.forEach(BaseModule::cleanup);
manager.printModuleSettings(Arrays.asList(MapModule.INSTANCE));
}
private void finishPackages() {
@@ -214,7 +213,7 @@ public class PrimitiveCollectionsBuilder extends TemplateProcessor
boolean force = flags.contains("force");
boolean tests = flags.contains("tests");
boolean forceTests = flags.contains("force-tests");
boolean load = !flags.contains("load");
boolean load = flags.contains("load");
boolean save = flags.contains("save");
int flag = (load ? LOAD : 0) | (save ? SAVE : 0);
new PrimitiveCollectionsBuilder(silent).setFlags(flag).process(force);
src/builder/java/speiger/src/builder/SettingsManager.java
+49 -14
View File
@@ -5,37 +5,71 @@ import java.io.IOException;
import java.io.OutputStreamWriter;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.ArrayList;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;
import java.util.TreeSet;
import com.google.gson.JsonElement;
import com.google.gson.JsonObject;
import com.google.gson.JsonParser;
import com.google.gson.internal.Streams;
import com.google.gson.stream.JsonWriter;
import speiger.src.builder.dependency.IDependency;
import speiger.src.builder.dependencies.IDependency;
import speiger.src.builder.dependencies.IDependency.LoadingState;
import speiger.src.builder.modules.BaseModule;
@SuppressWarnings("javadoc")
public class SettingsManager
{
boolean loaded;
Map<String, LoadingState> parsedData = new TreeMap<>();
JsonObject data = new JsonObject();
Set<String> moduleNames = new TreeSet<>(String.CASE_INSENSITIVE_ORDER);
Set<IDependency> allDependencies = new LinkedHashSet<>();
public void resolve() {
boolean valid = true;
for(int i = 0;i<10000 && valid;i++) {
boolean result = false;
for(IDependency entry : allDependencies) {
result |= entry.resolveDependencies();
if(!loaded) return;
Set<IDependency> roots = new LinkedHashSet<>();
Set<IDependency> leafs = new LinkedHashSet<>();
for(IDependency entry : allDependencies) {
if(entry.isRoot()) {
roots.add(entry);
}
if(entry.isLeaf()) {
leafs.add(entry);
}
valid = result;
}
if(valid) throw new RuntimeException("Couldn't resolve dependencies!");
/**
* This has to be 2 iteration passes.
* Due to Key Value Pairs, first pass does all initials keys, and the second pass processes the values.
* May require more passes but extremely unlikely
*/
for(int i = 0;i<2;i++) {
for(ClassType keyType : ModulePackage.TYPE) {
for(ClassType valueType : ModulePackage.TYPE) {
for(IDependency entry : roots) {
entry.resolveRequirements(keyType, valueType);
}
}
}
}
List<String> errors = new ArrayList<>();
for(ClassType keyType : ModulePackage.TYPE) {
for(ClassType valueType : ModulePackage.TYPE) {
for(IDependency entry : leafs) {
entry.validateDependency(errors::add, keyType, valueType);
}
}
}
if(errors.size() > 0) {
throw new IllegalStateException("Issues with dependencies found: "+String.join("\n", errors));
}
}
public void addModule(BaseModule module) {
@@ -45,7 +79,7 @@ public class SettingsManager
for(ClassType valueType : ModulePackage.TYPE) {
if(!module.isModuleValid(keyType, valueType)) continue;
for(IDependency dependency : module.getDependencies(keyType, valueType)) {
dependency.load(data, keyType, valueType);
dependency.set(parsedData);
allDependencies.add(dependency);
}
}
@@ -55,7 +89,7 @@ public class SettingsManager
for(ClassType keyType : ModulePackage.TYPE) {
if(!module.isModuleValid(keyType, keyType)) continue;
for(IDependency dependency : module.getDependencies(keyType, keyType)) {
dependency.load(data, keyType, keyType);
dependency.set(parsedData);
allDependencies.add(dependency);
}
}
@@ -72,7 +106,6 @@ public class SettingsManager
for(IDependency dependency : module.getDependencies(keyType, valueType)) {
String key = dependency.getName();
if(key != null) obj.addProperty(key, true);
dependency.setLoaded();
}
addModule(keyType, valueType, true, moduleName, obj);
}
@@ -85,7 +118,6 @@ public class SettingsManager
for(IDependency dependency : module.getDependencies(keyType, keyType)) {
String key = dependency.getName();
if(key != null) obj.addProperty(key, true);
dependency.setLoaded();
}
addModule(keyType, keyType, false, moduleName, obj);
}
@@ -102,7 +134,7 @@ public class SettingsManager
JsonObject obj = new JsonObject();
for(IDependency dependency : module.getDependencies(keyType, valueType)) {
String key = dependency.getName();
if(key != null) obj.addProperty(key, dependency.getState(keyType, valueType).getJsonResult());
if(key != null) obj.addProperty(key, dependency.isLoaded(keyType, valueType).getJsonResult());
}
addModule(data, keyType, valueType, true, moduleName, obj);
}
@@ -114,7 +146,7 @@ public class SettingsManager
JsonObject obj = new JsonObject();
for(IDependency dependency : module.getDependencies(keyType, keyType)) {
String key = dependency.getName();
if(key != null) obj.addProperty(key, dependency.getState(keyType, keyType).getJsonResult());
if(key != null) obj.addProperty(key, dependency.isLoaded(keyType, keyType).getJsonResult());
}
addModule(data, keyType, keyType, false, moduleName, obj);
}
@@ -135,6 +167,9 @@ public class SettingsManager
try(BufferedReader reader = Files.newBufferedReader(Paths.get("ModulSettings.json"))) {
data = JsonParser.parseReader(reader).getAsJsonObject();
loaded = true;
IDependency.flatten("", false, data, parsedData);
JsonElement element = data.get("Default");
LoadingState.setOptionalResolver(LoadingState.of(element == null ? true : element.getAsBoolean()));
}
catch(Exception e) { e.printStackTrace(); }
}
src/builder/java/speiger/src/builder/dependencies/BaseDependency.java
+137
View File
@@ -0,0 +1,137 @@
package speiger.src.builder.dependencies;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.StringJoiner;
import java.util.TreeSet;
import java.util.function.Consumer;
import speiger.src.builder.ClassType;
import speiger.src.builder.dependencies.Requirements.Requirement;
@SuppressWarnings("javadoc")
public abstract class BaseDependency implements IDependency {
protected static boolean FETCH_FAILURES = false;
protected static Set<String> FAILURE_KEYS = new TreeSet<>();
protected final String name;
protected final boolean biType;
protected Map<String, LoadingState> dependencies;
protected List<IDependency> children = new ArrayList<>();
protected List<Requirement> requirements = new ArrayList<>();
protected ClassType keyType;
protected ClassType valueType;
public BaseDependency(String name, boolean biType) {
this.name = name;
this.biType = biType;
}
@Override
public String toString() {
return name;
}
@Override
public void set(Map<String, LoadingState> dependency) {
dependencies = dependency;
}
@Override
public IDependency addDependency(Requirement require) {
requirements.add(require);
require.dependency.addChild(this);
return this;
}
@Override
public void addChild(IDependency child) {
children.add(child);
}
@Override
public boolean isLeaf() {
return children.isEmpty();
}
@Override
public boolean isRoot() {
return requirements.isEmpty();
}
protected LoadingState getGlobalState() {
return dependencies.getOrDefault(name, LoadingState.OPTIONAL);
}
@Override
public String getLocalStateKey(ClassType keyType, ClassType valueType) {
return (biType ? keyType.getClassPath()+"-"+valueType.getClassPath() : keyType.getClassPath())+"-"+name;
}
protected LoadingState getLocalState(ClassType keyType, ClassType valueType) {
return dependencies.getOrDefault(getLocalStateKey(keyType, valueType), LoadingState.OPTIONAL);
}
protected LoadingState getReqirementState(ClassType keyType, ClassType valueType) {
LoadingState state = requirements.isEmpty() ? LoadingState.REQUIRED : LoadingState.OPTIONAL;
for(int i = 0,m=requirements.size();i<m;i++) {
state = state.merge(requirements.get(i).test(keyType, valueType));
}
return state.resolveIfUndefined();
}
@Override
public void resolveRequirements(ClassType keyType, ClassType valueType) {
if(!children.isEmpty()) {
for(IDependency child : children) {
if(child == this) continue;
child.resolveRequirements(keyType, valueType);
}
}
if(getLocalState(keyType, valueType) == LoadingState.REQUIRED) {
for(Requirement req : requirements) {
dependencies.putIfAbsent(req.key(keyType, valueType), LoadingState.REQUIRED);
}
}
}
@Override
public void validateDependency(Consumer<String> result, ClassType keyType, ClassType valueType) {
if(getLocalState(keyType, valueType) == LoadingState.REQUIRED) {
FETCH_FAILURES = true;
for(Requirement req : requirements) {
req.test(keyType, valueType);
}
FETCH_FAILURES = false;
if(FAILURE_KEYS.size() > 0) {
int size = FAILURE_KEYS.size();
StringJoiner joiner = new StringJoiner("], [", "[", "]");
FAILURE_KEYS.forEach(joiner::add);
FAILURE_KEYS.clear();
String joins = size > 1 ? "["+joiner.toString()+"]" : joiner.toString();
result.accept("["+getLocalStateKey(keyType, valueType)+"] Requires "+joins+" but it specifically has been disabled!");
}
}
}
@Override
public void set(ClassType key, ClassType value) {
this.keyType = key;
this.valueType = value;
}
@Override
public boolean isEnabled() {
if(keyType == null || keyType == null) return false;
return isLoaded(keyType, valueType).getJsonResult();
}
@Override
public String getName() {
return name;
}
}
src/builder/java/speiger/src/builder/dependencies/FunctionDependency.java
+29
View File
@@ -0,0 +1,29 @@
package speiger.src.builder.dependencies;
import speiger.src.builder.ClassType;
@SuppressWarnings("javadoc")
public class FunctionDependency extends BaseDependency {
ModuleDependency owner;
public FunctionDependency(ModuleDependency owner, String name) {
super(name, owner.biType);
this.owner = owner;
}
@Override
public LoadingState isLoaded(ClassType key, ClassType value) {
if(dependencies == null) return LoadingState.REQUIRED;
LoadingState result = getLocalState(key, value);
if(FETCH_FAILURES && result == LoadingState.REJECTED) {
FAILURE_KEYS.add(getLocalStateKey(key, value));
}
return result.resolveIfUndefined().merge(getReqirementState(key, value));
}
@Override
public String getLocalStateKey(ClassType keyType, ClassType valueType) {
return (biType ? keyType.getClassPath()+"-"+valueType.getClassPath() : keyType.getClassPath())+"-"+owner.getName()+"-"+name;
}
}
src/builder/java/speiger/src/builder/dependencies/IDependency.java
+104
View File
@@ -0,0 +1,104 @@
package speiger.src.builder.dependencies;
import java.util.Map;
import java.util.Map.Entry;
import java.util.function.Consumer;
import com.google.gson.JsonElement;
import com.google.gson.JsonObject;
import com.google.gson.JsonPrimitive;
import speiger.src.builder.ClassType;
import speiger.src.builder.dependencies.Requirements.Requirement;
@SuppressWarnings("javadoc")
public interface IDependency {
public void set(Map<String, LoadingState> dependency);
public void set(ClassType key, ClassType value);
public LoadingState isLoaded(ClassType key, ClassType value);
public String getLocalStateKey(ClassType keyType, ClassType valueType);
public boolean isEnabled();
public boolean isLeaf();
public boolean isRoot();
public String getName();
public void validateDependency(Consumer<String> result, ClassType keyType, ClassType valueType);
public void resolveRequirements(ClassType keyType, ClassType valueType);
public void addChild(IDependency child);
public <T extends IDependency> T addDependency(Requirement require);
public default <T extends IDependency> T addKeyDependency(IDependency dependency) { return addDependency(new Requirement(dependency, Requirements.KEY_TEST, Requirements.KEY_GETTER)); }
public default <T extends IDependency> T addValueDependency(IDependency dependency) { return addDependency(new Requirement(dependency, Requirements.VALUE_TEST, Requirements.VALUE_GETTER)); }
public default <T extends IDependency> T addEntryDependency(IDependency dependency) { return addDependency(new Requirement(dependency, Requirements.ENTRY_TEST, Requirements.ENTRY_GETTER)); }
public default <T extends IDependency> T addTypeDependency(IDependency dependency, ClassType type) { return addDependency(new Requirement(dependency, Requirements.typedTest(type), Requirements.typedKey(type))); }
public default <T extends IDependency> T addOptionalTypeDependency(IDependency dependency, ClassType type, boolean key) { return addDependency(new Requirement(dependency, Requirements.optionalTest(type, key), Requirements.optionalKey(type, key))); }
public default <T extends IDependency> T addOptionalTypeDependency(ClassType type, boolean key) { return addDependency(new Requirement(this, Requirements.optionalTest(type, key), Requirements.optionalKey(type, key))); }
public static void flatten(String prefix, boolean applyMiddle, JsonObject object, Map<String, LoadingState> result) {
if(applyMiddle) prefix+="-";
for(Entry<String, JsonElement> entry : object.entrySet()) {
String key = entry.getKey();
JsonElement value = entry.getValue();
if(value instanceof JsonPrimitive) {
String entryKey = prefix+key;
if("Enabled".equalsIgnoreCase(key)) {
entryKey = prefix.substring(0, prefix.length()-1);
}
result.put(entryKey, LoadingState.of(((JsonPrimitive)value).getAsBoolean()));
}
if(value instanceof JsonObject) {
flatten(prefix+key, true, (JsonObject)value, result);
}
}
}
public static enum LoadingState {
OPTIONAL,
REQUIRED,
REJECTED;
private static LoadingState RESOLVED = LoadingState.REQUIRED;
public static LoadingState of(boolean value) {
return value ? REQUIRED : REJECTED;
}
public LoadingState merge(LoadingState merge) {
return ordinal() > merge.ordinal() ? this : merge;
}
public LoadingState replaceIfUndefined(LoadingState state) {
return this == OPTIONAL ? state : this;
}
public LoadingState resolveIfUndefined() {
return this == OPTIONAL ? RESOLVED : this;
}
public LoadingState mergeDown(LoadingState merge) {
if(merge == REJECTED || ordinal() > merge.ordinal()) {
return this;
}
return merge;
}
public LoadingState mergeUp(LoadingState merge) {
if(merge == REQUIRED || ordinal() > merge.ordinal()) {
return this;
}
return merge;
}
public static void setOptionalResolver(LoadingState state) {
RESOLVED = state;
}
public boolean getJsonResult() {
LoadingState state = this == OPTIONAL ? RESOLVED : this;
return state == REQUIRED;
}
}
}
src/builder/java/speiger/src/builder/dependencies/ModuleDependency.java
+31
View File
@@ -0,0 +1,31 @@
package speiger.src.builder.dependencies;
import speiger.src.builder.ClassType;
import speiger.src.builder.modules.BaseModule;
@SuppressWarnings("javadoc")
public class ModuleDependency extends BaseDependency {
BaseModule owner;
public ModuleDependency(BaseModule owner, boolean biType) {
super(owner.getModuleName(), biType);
this.owner = owner;
}
public FunctionDependency createDependency(String name) {
FunctionDependency result = new FunctionDependency(this, name);
if(biType) result.addEntryDependency(this);
else result.addKeyDependency(this);
return result;
}
@Override
public LoadingState isLoaded(ClassType key, ClassType value) {
if(dependencies == null) return LoadingState.REQUIRED;
LoadingState result = getLocalState(key, value);
if(FETCH_FAILURES && result == LoadingState.REJECTED) {
FAILURE_KEYS.add(getLocalStateKey(key, value));
}
return result.replaceIfUndefined(getGlobalState()).resolveIfUndefined().merge(getReqirementState(key, value));
}
}
src/builder/java/speiger/src/builder/dependencies/Requirements.java
+68
View File
@@ -0,0 +1,68 @@
package speiger.src.builder.dependencies;
import java.util.function.Consumer;
import speiger.src.builder.ClassType;
import speiger.src.builder.dependencies.IDependency.LoadingState;
@SuppressWarnings("javadoc")
public class Requirements {
public static final RequirementTest KEY_TEST = (T, K, V) -> T.isLoaded(K, K);
public static final RequirementTest VALUE_TEST = (T, K, V) -> T.isLoaded(V, V);
public static final RequirementTest ENTRY_TEST = (T, K, V) -> T.isLoaded(K, V);
public static RequirementTest typedTest(ClassType type) {
return (T, K, V) -> T.isLoaded(type, type);
}
public static RequirementTest optionalTest(ClassType type, boolean key) {
return (T, K, V) -> (key ? K : V) != type ? T.isLoaded(type, type) : LoadingState.REQUIRED;
}
public static final RequirementKey KEY_GETTER = (T, K, V) -> T.getLocalStateKey(K, K);
public static final RequirementKey VALUE_GETTER = (T, K, V) -> T.getLocalStateKey(V, V);
public static final RequirementKey ENTRY_GETTER = (T, K, V) -> T.getLocalStateKey(K, V);
public static RequirementKey typedKey(ClassType type) {
return (T, K, V) -> T.getLocalStateKey(type, type);
}
public static RequirementKey optionalKey(ClassType type, boolean key) {
return (T, K, V) -> (key ? K : V) != type ? T.getLocalStateKey(type, type) : "";
}
public interface RequirementTest {
public LoadingState test(IDependency test, ClassType keyType, ClassType valueType);
}
public static interface RequirementKey {
public String key(IDependency test, ClassType keyType, ClassType valueType);
}
public static interface RequirementResolver {
public void resolve(IDependency test, Consumer<String> result, ClassType keyType, ClassType valueType);
}
public static class Requirement {
IDependency dependency;
RequirementTest test;
RequirementKey key;
public Requirement(IDependency dependency, RequirementTest test, RequirementKey key) {
this.dependency = dependency;
this.test = test;
this.key = key;
}
public LoadingState test(ClassType keyType, ClassType valueType) {
return test.test(dependency, keyType, valueType);
}
public String key(ClassType keyType, ClassType valueType) {
return key.key(dependency, keyType, valueType);
}
}
}
src/builder/java/speiger/src/builder/dependency/DependencyBase.java
-49
View File
@@ -1,49 +0,0 @@
package speiger.src.builder.dependency;
import java.util.ArrayList;
import java.util.List;
import speiger.src.builder.ClassType;
@SuppressWarnings("javadoc")
public abstract class DependencyBase implements IDependency {
protected List<IDependency> children = new ArrayList<>();
protected List<IDependency> parents = new ArrayList<>();
public <T extends DependencyBase> T addChild(T child) {
children.add(child);
child.addParent(this);
return child;
}
public <T extends DependencyBase> T addParent(DependencyBase parent) {
parents.add(parent);
return (T) this;
}
public List<IDependency> getParents() {
return parents;
}
public List<IDependency> getChildren() {
return children;
}
protected LoadingState getChildState(ClassType keyType, ClassType valueType) {
LoadingState state = LoadingState.UNDEFINED;
for(IDependency child : children) {
if(state == LoadingState.LOADED) return LoadingState.LOADED;
state = state.mergeDown(child.getState(keyType, valueType));
}
return state;
}
protected LoadingState getParentState(ClassType keyType, ClassType valueType) {
LoadingState state = LoadingState.UNDEFINED;
for(IDependency parent : parents) {
if(state == LoadingState.UNLOADED) return LoadingState.UNLOADED;
state = state.mergeUp(parent.getState(keyType, valueType));
}
return state;
}
}
src/builder/java/speiger/src/builder/dependency/DependencyFunction.java
-131
View File
@@ -1,131 +0,0 @@
package speiger.src.builder.dependency;
import java.util.Arrays;
import com.google.gson.JsonObject;
import speiger.src.builder.ClassType;
@SuppressWarnings("javadoc")
public abstract class DependencyFunction extends DependencyBase {
protected DependencyModule owner;
public DependencyFunction(DependencyModule owner) {
this.owner = owner;
}
@Override
public boolean isEnabled() {
return getState(owner.owner.keyType(), owner.owner.valueType()) == LoadingState.LOADED;
}
public abstract DependencyFunction createSubFunction(String function);
public static class SingleFunction extends DependencyFunction {
LoadingState[] state = new LoadingState[ClassType.values().length];
String functionName;
public SingleFunction(DependencyModule owner, String functionName) {
super(owner);
this.functionName = functionName;
Arrays.fill(state, LoadingState.UNDEFINED);
}
@Override
public DependencyFunction createSubFunction(String function) {
return addChild(new SingleFunction(owner, function));
}
@Override
public void load(JsonObject obj, ClassType keyType, ClassType valueType) {
state[keyType.ordinal()] = owner.isFunctionLoaded(obj, keyType, valueType, functionName);
}
@Override
public LoadingState getState(ClassType keyType, ClassType valueType) {
return state[keyType.ordinal()];
}
@Override
public boolean resolveDependencies() {
boolean returnType = false;
for(ClassType type : ClassType.values()) {
LoadingState state = this.state[type.ordinal()];
if(state == LoadingState.UNLOADED) continue;
state = state.merge(getChildState(type, type)).merge(getParentState(type, type));
if(state != this.state[type.ordinal()]) {
this.state[type.ordinal()] = state;
returnType = true;
}
}
return returnType;
}
@Override
public String getName() {
return functionName;
}
@Override
public void setLoaded() {
Arrays.fill(state, LoadingState.LOADED);
}
}
public static class BiTypeFunction extends DependencyFunction {
LoadingState[][] state = new LoadingState[ClassType.values().length][ClassType.values().length];
String functionName;
BiTypeFunction(DependencyModule owner, String functionName) {
super(owner);
this.functionName = functionName;
for(int i = 0;i<state.length;i++) {
Arrays.fill(state[i], LoadingState.UNDEFINED);
}
}
@Override
public DependencyFunction createSubFunction(String function) {
return new BiTypeFunction(owner, function);
}
@Override
public void load(JsonObject obj, ClassType keyType, ClassType valueType) {
state[keyType.ordinal()][valueType.ordinal()] = owner.isFunctionLoaded(obj, keyType, valueType, functionName);
}
@Override
public LoadingState getState(ClassType keyType, ClassType valueType) {
return state[keyType.ordinal()][valueType.ordinal()];
}
@Override
public boolean resolveDependencies() {
boolean returnType = false;
for(ClassType keyType : ClassType.values()) {
for(ClassType valueType : ClassType.values()) {
LoadingState state = this.state[keyType.ordinal()][valueType.ordinal()];
if(state == LoadingState.UNLOADED) continue;
state = state.merge(getChildState(keyType, valueType)).merge(getParentState(keyType, valueType));
if(state != this.state[keyType.ordinal()][valueType.ordinal()]) {
this.state[keyType.ordinal()][valueType.ordinal()] = state;
returnType = true;
}
}
}
return returnType;
}
@Override
public String getName() {
return functionName;
}
@Override
public void setLoaded() {
for(int i = 0;i<state.length;i++) {
Arrays.fill(state[i], LoadingState.LOADED);
}
}
}
}
src/builder/java/speiger/src/builder/dependency/DependencyModule.java
-170
View File
@@ -1,170 +0,0 @@
package speiger.src.builder.dependency;
import java.util.Arrays;
import com.google.gson.JsonObject;
import speiger.src.builder.ClassType;
import speiger.src.builder.dependency.DependencyFunction.BiTypeFunction;
import speiger.src.builder.dependency.DependencyFunction.SingleFunction;
import speiger.src.builder.modules.BaseModule;
@SuppressWarnings("javadoc")
public abstract class DependencyModule extends DependencyBase {
protected BaseModule owner;
public DependencyModule(BaseModule owner) {
this.owner = owner;
}
public LoadingState isFunctionLoaded(JsonObject obj, ClassType keyType, ClassType valueType, String function) { return isModuleEnabled(obj, keyType, valueType, function); }
public abstract DependencyFunction createFunction(String functionName);
@Override
public boolean isEnabled() {
return getState(owner.keyType(), owner.valueType()) == LoadingState.LOADED;
}
public static class SingleTypeModule extends DependencyModule {
LoadingState[] state = new LoadingState[ClassType.values().length];
public SingleTypeModule(BaseModule owner) {
super(owner);
Arrays.fill(state, LoadingState.UNDEFINED);
}
@Override
public DependencyFunction createFunction(String functionName) {
return addChild(new SingleFunction(this, functionName));
}
@Override
public void load(JsonObject obj, ClassType keyType, ClassType valueType) {
state[keyType.ordinal()] = isModuleEnabled(obj, keyType, valueType);
}
@Override
public LoadingState getState(ClassType keyType, ClassType valueType) {
return state[keyType.ordinal()];
}
@Override
public boolean resolveDependencies() {
boolean returnType = false;
for(ClassType type : ClassType.values()) {
LoadingState state = this.state[type.ordinal()];
if(state == LoadingState.UNLOADED) continue;
state = state.merge(getChildState(type, type)).merge(getParentState(type, type));
if(state != this.state[type.ordinal()]) {
this.state[type.ordinal()] = state;
returnType = true;
}
}
return returnType;
}
@Override
public String getName() {
return "Enabled";
}
@Override
public void setLoaded() {
Arrays.fill(state, LoadingState.LOADED);
}
}
public static class BiTypeModule extends DependencyModule {
LoadingState[][] state = new LoadingState[ClassType.values().length][ClassType.values().length];
public BiTypeModule(BaseModule owner) {
super(owner);
for(int i = 0;i<state.length;i++) {
Arrays.fill(state[i], LoadingState.UNDEFINED);
}
}
@Override
public DependencyFunction createFunction(String functionName) {
return addChild(new BiTypeFunction(this, functionName));
}
@Override
public void load(JsonObject obj, ClassType keyType, ClassType valueType) {
state[keyType.ordinal()][valueType.ordinal()] = isModuleEnabled(obj, keyType, valueType);
}
@Override
public LoadingState getState(ClassType keyType, ClassType valueType) {
return state[keyType.ordinal()][valueType.ordinal()];
}
@Override
public boolean resolveDependencies() {
boolean returnType = false;
for(ClassType keyType : ClassType.values()) {
for(ClassType valueType : ClassType.values()) {
LoadingState state = this.state[keyType.ordinal()][valueType.ordinal()];
if(state == LoadingState.UNLOADED) continue;
state = state.merge(getChildState(keyType, valueType)).merge(getParentState(keyType, valueType));
if(state != this.state[keyType.ordinal()][valueType.ordinal()]) {
this.state[keyType.ordinal()][valueType.ordinal()] = state;
returnType = true;
}
}
}
return returnType;
}
@Override
public String getName() {
return "Enabled";
}
@Override
public void setLoaded() {
for(int i = 0;i<state.length;i++) {
Arrays.fill(state[i], LoadingState.LOADED);
}
}
}
protected LoadingState isModuleEnabled(JsonObject data, ClassType keyType, ClassType valueType) {
LoadingState state = isEnabled(data, owner.getModuleName());
JsonObject result = getObject(data, keyType.getClassPath(), false);
state = state.replaceIfDefined(isEnabled(result, "Enabled"));
if(owner.isBiModule()) {
result = getObject(result, valueType.getClassPath(), false);
state = state.replaceIfDefined(isEnabled(result, "Enabled"));
}
return state = state.replaceIfDefined(isEnabled(getObject(result, owner.getModuleName(), false), "Enabled"));
}
protected LoadingState isModuleEnabled(JsonObject data, ClassType keyType, ClassType valueType, String entry) {
LoadingState state = isEnabled(data, owner.getModuleName());
JsonObject result = getObject(data, keyType.getClassPath(), false);
state = state.replaceIfDefined(isEnabled(result, "Enabled"));
if(owner.isBiModule()) {
result = getObject(result, valueType.getClassPath(), false);
state = state.replaceIfDefined(isEnabled(result, "Enabled"));
}
result = getObject(result, owner.getModuleName(), false);
return state.replaceIfDefined(isEnabled(result, "Enabled")).replaceIfDefined(isEnabled(result, entry));
}
private JsonObject getObject(JsonObject data, String name, boolean create) {
JsonObject obj = data.getAsJsonObject(name);
if(obj == null) {
obj = new JsonObject();
data.add(name, obj);
if(create) obj.addProperty("Enabled", true);
}
return obj;
}
private LoadingState isEnabled(JsonObject obj, String key) {
if (obj.has(key)) return LoadingState.of(obj.getAsJsonPrimitive(key).getAsBoolean());
return LoadingState.UNDEFINED;
}
}
src/builder/java/speiger/src/builder/dependency/DependencyType.java
-42
View File
@@ -1,42 +0,0 @@
package speiger.src.builder.dependency;
import com.google.gson.JsonObject;
import speiger.src.builder.ClassType;
@SuppressWarnings("javadoc")
public class DependencyType extends DependencyBase {
DependencyBase owner;
ClassType myType;
public DependencyType(DependencyBase owner, ClassType myType) {
this.owner = owner;
this.myType = myType;
}
@Override
public void load(JsonObject obj, ClassType keyType, ClassType valueType) {}
@Override
public LoadingState getState(ClassType keyType, ClassType valueType) {
if(keyType != myType || valueType != myType) return LoadingState.UNDEFINED;
return owner.getState(keyType, valueType);
}
@Override
public boolean resolveDependencies() { return false; }
@Override
public boolean isEnabled() {
return owner.getState(myType, myType) == LoadingState.LOADED;
}
@Override
public String getName() {
return null;
}
@Override
public void setLoaded() {
}
}
src/builder/java/speiger/src/builder/dependency/DependencyValue.java
-41
View File
@@ -1,41 +0,0 @@
package speiger.src.builder.dependency;
import com.google.gson.JsonObject;
import speiger.src.builder.ClassType;
@SuppressWarnings("javadoc")
public class DependencyValue extends DependencyBase {
DependencyBase owner;
public DependencyValue(DependencyBase owner) {
this.owner = owner;
}
@Override
public void load(JsonObject obj, ClassType keyType, ClassType valueType) {}
@Override
public LoadingState getState(ClassType keyType, ClassType valueType) {
return owner.getState(valueType, keyType);
}
@Override
public boolean resolveDependencies() {
return false;
}
@Override
public boolean isEnabled() {
return owner.isEnabled();
}
@Override
public String getName() {
return null;
}
@Override
public void setLoaded() {
}
}
src/builder/java/speiger/src/builder/dependency/IDependency.java
-51
View File
@@ -1,51 +0,0 @@
package speiger.src.builder.dependency;
import com.google.gson.JsonObject;
import speiger.src.builder.ClassType;
@SuppressWarnings("javadoc")
public interface IDependency {
public void load(JsonObject obj, ClassType keyType, ClassType valueType);
public LoadingState getState(ClassType keyType, ClassType valueType);
public boolean resolveDependencies();
public boolean isEnabled();
public void setLoaded();
public String getName();
public static enum LoadingState {
UNDEFINED,
LOADED,
UNLOADED;
public static LoadingState of(boolean value) {
return value ? LOADED : UNLOADED;
}
public LoadingState merge(LoadingState merge) {
return ordinal() > merge.ordinal() ? this : merge;
}
public LoadingState replaceIfDefined(LoadingState state) {
return state == UNDEFINED ? this : state;
}
public LoadingState mergeDown(LoadingState merge) {
if(merge == UNLOADED || ordinal() > merge.ordinal()) {
return this;
}
return merge;
}
public LoadingState mergeUp(LoadingState merge) {
if(merge == LOADED || ordinal() > merge.ordinal()) {
return this;
}
return merge;
}
public boolean getJsonResult() {
return this == LOADED;
}
}
}
src/builder/java/speiger/src/builder/modules/AsyncModule.java
+4 -6
View File
@@ -4,16 +4,14 @@ import java.util.Arrays;
import java.util.List;
import speiger.src.builder.ClassType;
import speiger.src.builder.dependency.DependencyModule;
import speiger.src.builder.dependency.DependencyModule.SingleTypeModule;
import speiger.src.builder.dependency.IDependency;
import speiger.src.builder.dependencies.IDependency;
import speiger.src.builder.dependencies.ModuleDependency;
@SuppressWarnings("javadoc")
public class AsyncModule extends BaseModule
{
public static final BaseModule INSTANCE = new AsyncModule();
public static final DependencyModule MODULE = CollectionModule.MODULE.addChild(new SingleTypeModule(INSTANCE));
public static final ModuleDependency MODULE = new ModuleDependency(INSTANCE, false).addKeyDependency(JavaModule.MODULE);
@Override
public String getModuleName() { return "Async"; }
@@ -29,7 +27,7 @@ public class AsyncModule extends BaseModule
public List<IDependency> getDependencies(ClassType keyType, ClassType valueType) { return Arrays.asList(MODULE); }
@Override
protected void loadBlockades() {
if(MODULE.isEnabled()) {
if(!MODULE.isEnabled()) {
addBlockedFiles("AsyncBuilder", "Task");
}
}
src/builder/java/speiger/src/builder/modules/BaseModule.java
+4 -1
View File
@@ -9,7 +9,7 @@ import speiger.src.builder.ClassType;
import speiger.src.builder.ModulePackage;
import speiger.src.builder.RequiredType;
import speiger.src.builder.SettingsManager;
import speiger.src.builder.dependency.IDependency;
import speiger.src.builder.dependencies.IDependency;
import speiger.src.builder.mappers.ArgumentMapper;
import speiger.src.builder.mappers.InjectMapper;
import speiger.src.builder.mappers.LineMapper;
@@ -32,6 +32,9 @@ public abstract class BaseModule
this.entry = entry;
keyType = entry.getKeyType();
valueType = entry.getValueType();
for(IDependency dependency : getDependencies(keyType, valueType)) {
dependency.set(keyType, valueType);
}
loadVariables();
loadClasses();
loadTestClasses();
src/builder/java/speiger/src/builder/modules/CollectionModule.java
+12 -9
View File
@@ -4,20 +4,23 @@ import java.util.Arrays;
import java.util.List;
import speiger.src.builder.ClassType;
import speiger.src.builder.dependency.DependencyFunction;
import speiger.src.builder.dependency.DependencyModule;
import speiger.src.builder.dependency.DependencyModule.SingleTypeModule;
import speiger.src.builder.dependency.IDependency;
import speiger.src.builder.dependencies.FunctionDependency;
import speiger.src.builder.dependencies.IDependency;
import speiger.src.builder.dependencies.ModuleDependency;
@SuppressWarnings("javadoc")
public class CollectionModule extends BaseModule
{
public static final BaseModule INSTANCE = new CollectionModule();
public static final DependencyModule MODULE = JavaModule.MODULE.addChild(new SingleTypeModule(INSTANCE));
public static final DependencyFunction STREAMS = MODULE.createFunction("Streams");
public static final DependencyFunction SPLIT_ITERATORS = MODULE.createFunction("Splititerators");
public static final DependencyFunction IARRAY = MODULE.createFunction("IArray");
public static final DependencyFunction STRATEGY = MODULE.createFunction("Strategy");
public static final ModuleDependency MODULE = new ModuleDependency(INSTANCE, false)
.addKeyDependency(FunctionModule.MODULE)
.addOptionalTypeDependency(FunctionModule.MODULE, ClassType.OBJECT, true)
.addOptionalTypeDependency(FunctionModule.MODULE, ClassType.INT, true)
.addOptionalTypeDependency(ClassType.OBJECT, true);
public static final FunctionDependency STREAMS = MODULE.createDependency("Streams");
public static final FunctionDependency SPLIT_ITERATORS = MODULE.createDependency("Splititerators").addKeyDependency(STREAMS);
public static final FunctionDependency IARRAY = MODULE.createDependency("IArray");
public static final FunctionDependency STRATEGY = MODULE.createDependency("Strategy");
@Override
public String getModuleName() { return "Collection"; }
src/builder/java/speiger/src/builder/modules/FunctionModule.java
+4 -4
View File
@@ -5,15 +5,14 @@ import java.util.List;
import speiger.src.builder.ClassType;
import speiger.src.builder.RequiredType;
import speiger.src.builder.dependency.DependencyModule;
import speiger.src.builder.dependency.IDependency;
import speiger.src.builder.dependency.DependencyModule.BiTypeModule;
import speiger.src.builder.dependencies.IDependency;
import speiger.src.builder.dependencies.ModuleDependency;
@SuppressWarnings("javadoc")
public class FunctionModule extends BaseModule
{
public static final BaseModule INSTANCE = new FunctionModule();
public static final DependencyModule MODULE = new BiTypeModule(INSTANCE);
public static final ModuleDependency MODULE = new ModuleDependency(INSTANCE, false).addKeyDependency(JavaModule.MODULE);
@Override
public String getModuleName() { return "Function"; }
@@ -35,6 +34,7 @@ public class FunctionModule extends BaseModule
protected void loadBlockades()
{
if(keyType.isObject()) addBlockedFiles("Consumer", "Comparator");
if(!MODULE.isEnabled()) addBlockedFiles("Consumer", "BiConsumer", "Comparator", "Supplier", "Function", "UnaryOperator");
}
@Override
src/builder/java/speiger/src/builder/modules/JavaModule.java
+3 -4
View File
@@ -4,15 +4,14 @@ import java.util.Arrays;
import java.util.List;
import speiger.src.builder.ClassType;
import speiger.src.builder.dependency.DependencyBase;
import speiger.src.builder.dependency.IDependency;
import speiger.src.builder.dependency.DependencyModule.SingleTypeModule;
import speiger.src.builder.dependencies.IDependency;
import speiger.src.builder.dependencies.ModuleDependency;
@SuppressWarnings("javadoc")
public class JavaModule extends BaseModule
{
public static final BaseModule INSTANCE = new JavaModule();
public static final DependencyBase MODULE = new SingleTypeModule(INSTANCE);
public static final ModuleDependency MODULE = new ModuleDependency(INSTANCE, false);
@Override
public String getModuleName() { return "Base"; }
src/builder/java/speiger/src/builder/modules/ListModule.java
+11 -12
View File
@@ -4,23 +4,22 @@ import java.util.Arrays;
import java.util.List;
import speiger.src.builder.ClassType;
import speiger.src.builder.dependency.DependencyFunction;
import speiger.src.builder.dependency.DependencyModule;
import speiger.src.builder.dependency.DependencyModule.SingleTypeModule;
import speiger.src.builder.dependency.IDependency;
import speiger.src.builder.dependencies.FunctionDependency;
import speiger.src.builder.dependencies.IDependency;
import speiger.src.builder.dependencies.ModuleDependency;
@SuppressWarnings("javadoc")
public class ListModule extends BaseModule
{
public static final BaseModule INSTANCE = new ListModule();
public static final DependencyModule MODULE = CollectionModule.MODULE.addChild(new SingleTypeModule(INSTANCE));
public static final DependencyFunction IMPLEMENTATION = MODULE.createFunction("Implementations");
public static final DependencyFunction WRAPPERS = MODULE.createFunction("Wrappers");
public static final DependencyFunction ARRAY_LIST = IMPLEMENTATION.createSubFunction("ArrayList");
public static final DependencyFunction LINKED_LIST = IMPLEMENTATION.createSubFunction("LinkedList");
public static final DependencyFunction IMMUTABLE_LIST = IMPLEMENTATION.createSubFunction("ImmutableList");
public static final DependencyFunction COPY_ON_WRITE_LIST = IMPLEMENTATION.createSubFunction("CopyOnWriteList");
public static final ModuleDependency MODULE = new ModuleDependency(INSTANCE, false).addKeyDependency(CollectionModule.MODULE).addKeyDependency(CollectionModule.SPLIT_ITERATORS);
public static final FunctionDependency IMPLEMENTATION = MODULE.createDependency("Implementations");
public static final FunctionDependency WRAPPERS = MODULE.createDependency("Wrappers");
public static final FunctionDependency ARRAY_LIST = MODULE.createDependency("ArrayList").addKeyDependency(IMPLEMENTATION);
public static final FunctionDependency LINKED_LIST = MODULE.createDependency("LinkedList").addKeyDependency(IMPLEMENTATION);
public static final FunctionDependency IMMUTABLE_LIST = MODULE.createDependency("ImmutableList").addKeyDependency(IMPLEMENTATION);
public static final FunctionDependency COPY_ON_WRITE_LIST = MODULE.createDependency("CopyOnWriteList").addKeyDependency(IMPLEMENTATION);
@Override
public String getModuleName() { return "List"; }
@Override
src/builder/java/speiger/src/builder/modules/MapModule.java
+36 -28
View File
@@ -1,40 +1,44 @@
package speiger.src.builder.modules;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import speiger.src.builder.ClassType;
import speiger.src.builder.dependency.DependencyFunction;
import speiger.src.builder.dependency.DependencyModule;
import speiger.src.builder.dependency.DependencyModule.BiTypeModule;
import speiger.src.builder.dependency.DependencyType;
import speiger.src.builder.dependency.DependencyValue;
import speiger.src.builder.dependency.IDependency;
import speiger.src.builder.dependencies.FunctionDependency;
import speiger.src.builder.dependencies.IDependency;
import speiger.src.builder.dependencies.ModuleDependency;
@SuppressWarnings("javadoc")
public class MapModule extends BaseModule
{
public static final BaseModule INSTANCE = new MapModule();
public static final DependencyModule MODULE = make(new BiTypeModule(INSTANCE), T -> {
CollectionModule.MODULE.addChild(new DependencyValue(T));
CollectionModule.MODULE.addChild(new DependencyType(T, ClassType.OBJECT));
SetModule.MODULE.addChild(T);
});
public static final DependencyFunction WRAPPERS = MODULE.createFunction("Wrappers");
public static final DependencyFunction IMPLEMENTATION = MODULE.createFunction("Implementations");
public static final DependencyFunction ORDERED_MAP = MODULE.createFunction("OrderedMap");
public static final DependencyFunction SORTED_MAP = MODULE.createFunction("SortedMap");
public static final DependencyFunction ARRAY_MAP = ORDERED_MAP.addChild(IMPLEMENTATION.createSubFunction("ArrayMap"));
public static final DependencyFunction IMMUTABLE_MAP = IMPLEMENTATION.createSubFunction("ImmutableMap");
public static final DependencyFunction HASH_MAP = IMPLEMENTATION.createSubFunction("HashMap");
public static final DependencyFunction LINKED_MAP = HASH_MAP.addChild(ORDERED_MAP.addChild(IMPLEMENTATION.createSubFunction("LinkedHashMap")));
public static final DependencyFunction CUSTOM_MAP = IMPLEMENTATION.createSubFunction("CustomHashMap");
public static final DependencyFunction LINKED_CUSTOM_MAP = CUSTOM_MAP.addChild(ORDERED_MAP.addChild(IMPLEMENTATION.createSubFunction("LinkedCustomHashMap")));
public static final DependencyFunction ENUM_MAP = IMPLEMENTATION.createSubFunction("EnumMap");
public static final DependencyFunction LINKED_ENUM_MAP = ENUM_MAP.addChild(ORDERED_MAP.addChild(IMPLEMENTATION.createSubFunction("LinkedEnumMap")));
public static final DependencyFunction CONCURRENT_MAP = IMPLEMENTATION.createSubFunction("ConcurrentMap");
public static final DependencyFunction AVL_TREE_MAP = SORTED_MAP.addChild(IMPLEMENTATION.createSubFunction("AVLTreeMap"));
public static final DependencyFunction RB_TREE_MAP = SORTED_MAP.addChild(IMPLEMENTATION.createSubFunction("RBTreeMap"));
public static final ModuleDependency MODULE = new ModuleDependency(INSTANCE, true)
.addKeyDependency(SetModule.MODULE)
.addValueDependency(CollectionModule.MODULE)
.addEntryDependency(SetModule.MODULE)
.addTypeDependency(SetModule.MODULE, ClassType.OBJECT);
public static final FunctionDependency IMPLEMENTATION = MODULE.createDependency("Implementations");
public static final FunctionDependency WRAPPERS = MODULE.createDependency("Wrappers").addKeyDependency(SetModule.WRAPPERS).addOptionalTypeDependency(SetModule.WRAPPERS, ClassType.OBJECT, true);
public static final FunctionDependency ORDERED_MAP = MODULE.createDependency("OrderedMap").addKeyDependency(SetModule.ORDERED_SET).addOptionalTypeDependency(SetModule.ORDERED_SET, ClassType.OBJECT, true);
public static final FunctionDependency SORTED_MAP = MODULE.createDependency("SortedMap").addKeyDependency(SetModule.SORTED_SET).addOptionalTypeDependency(SetModule.SORTED_SET, ClassType.OBJECT, true);
public static final FunctionDependency ARRAY_MAP = MODULE.createDependency("ArrayMap").addEntryDependency(ORDERED_MAP).addEntryDependency(IMPLEMENTATION);
public static final FunctionDependency IMMUTABLE_MAP = MODULE.createDependency("ImmutableMap").addEntryDependency(IMPLEMENTATION);
public static final FunctionDependency HASH_MAP = MODULE.createDependency("HashMap").addEntryDependency(IMPLEMENTATION);
public static final FunctionDependency LINKED_MAP = MODULE.createDependency("LinkedHashMap").addEntryDependency(HASH_MAP).addEntryDependency(ORDERED_MAP);
public static final FunctionDependency CUSTOM_MAP = MODULE.createDependency("CustomHashMap").addEntryDependency(IMPLEMENTATION).addKeyDependency(CollectionModule.STRATEGY);
public static final FunctionDependency LINKED_CUSTOM_MAP = MODULE.createDependency("LinkedCustomHashMap").addEntryDependency(CUSTOM_MAP).addEntryDependency(ORDERED_MAP);
public static final FunctionDependency ENUM_MAP = MODULE.createDependency("EnumMap").addEntryDependency(IMPLEMENTATION);
public static final FunctionDependency LINKED_ENUM_MAP = MODULE.createDependency("LinkedEnumMap").addEntryDependency(ENUM_MAP).addEntryDependency(ORDERED_MAP);
public static final FunctionDependency CONCURRENT_MAP = MODULE.createDependency("ConcurrentMap").addEntryDependency(IMPLEMENTATION);
public static final FunctionDependency AVL_TREE_MAP = MODULE.createDependency("AVLTreeMap").addEntryDependency(SORTED_MAP).addEntryDependency(IMPLEMENTATION);
public static final FunctionDependency RB_TREE_MAP = MODULE.createDependency("RBTreeMap").addEntryDependency(SORTED_MAP).addEntryDependency(IMPLEMENTATION);
@Override
public String getModuleName() { return "Map"; }
@@ -45,7 +49,11 @@ public class MapModule extends BaseModule
@Override
public boolean isModuleValid(ClassType keyType, ClassType valueType) { return keyType != ClassType.BOOLEAN; }
@Override
public List<IDependency> getDependencies(ClassType keyType, ClassType valueType) { return Arrays.asList(MODULE, ORDERED_MAP, SORTED_MAP, IMPLEMENTATION, WRAPPERS, ARRAY_MAP, IMMUTABLE_MAP, HASH_MAP, LINKED_MAP, CUSTOM_MAP, LINKED_CUSTOM_MAP, ENUM_MAP, LINKED_ENUM_MAP, CONCURRENT_MAP, AVL_TREE_MAP, RB_TREE_MAP); }
public List<IDependency> getDependencies(ClassType keyType, ClassType valueType) {
List<IDependency> dependencies = new ArrayList<>(Arrays.asList(MODULE, ORDERED_MAP, SORTED_MAP, IMPLEMENTATION, WRAPPERS, ARRAY_MAP, IMMUTABLE_MAP, HASH_MAP, LINKED_MAP, CUSTOM_MAP, LINKED_CUSTOM_MAP, CONCURRENT_MAP, AVL_TREE_MAP, RB_TREE_MAP));
if(keyType == ClassType.OBJECT) dependencies.addAll(Arrays.asList(ENUM_MAP, LINKED_ENUM_MAP));
return dependencies;
}
@Override
protected void loadFlags()
@@ -79,7 +87,7 @@ public class MapModule extends BaseModule
if(!ORDERED_MAP.isEnabled()) addBlockedFiles("OrderedMap");
if(!HASH_MAP.isEnabled()) addBlockedFiles("OpenHashMap");
if(!LINKED_MAP.isEnabled()) addBlockedFiles("LinkedOpenHashMap");
if(CUSTOM_MAP.isEnabled()) addBlockedFiles("OpenCustomHashMap");
if(!CUSTOM_MAP.isEnabled()) addBlockedFiles("OpenCustomHashMap");
if(!LINKED_CUSTOM_MAP.isEnabled()) addBlockedFiles("LinkedOpenCustomHashMap");
if(!ENUM_MAP.isEnabled()) addBlockedFiles("EnumMap");
if(!LINKED_ENUM_MAP.isEnabled()) addBlockedFiles("LinkedEnumMap");
src/builder/java/speiger/src/builder/modules/PairModule.java
+11 -7
View File
@@ -4,18 +4,22 @@ import java.util.Arrays;
import java.util.List;
import speiger.src.builder.ClassType;
import speiger.src.builder.dependency.DependencyFunction;
import speiger.src.builder.dependency.DependencyModule;
import speiger.src.builder.dependency.DependencyModule.BiTypeModule;
import speiger.src.builder.dependency.IDependency;
import speiger.src.builder.dependencies.FunctionDependency;
import speiger.src.builder.dependencies.IDependency;
import speiger.src.builder.dependencies.ModuleDependency;
@SuppressWarnings("javadoc")
public class PairModule extends BaseModule
{
public static final BaseModule INSTANCE = new PairModule();
public static final DependencyModule MODULE = new BiTypeModule(INSTANCE);
public static final DependencyFunction IMMUTABLE = MODULE.createFunction("Immutable");
public static final DependencyFunction MUTABLE = MODULE.createFunction("Mutable");
public static final ModuleDependency MODULE = new ModuleDependency(INSTANCE, true).addKeyDependency(JavaModule.MODULE);
public static final FunctionDependency IMMUTABLE = MODULE.createDependency("Immutable");
public static final FunctionDependency MUTABLE = MODULE.createDependency("Mutable");
// public static final DependencyModule MODULE = new BiTypeModule(INSTANCE);
// public static final DependencyFunction IMMUTABLE = MODULE.createFunction("Immutable");
// public static final DependencyFunction MUTABLE = MODULE.createFunction("Mutable");
@Override
public String getModuleName() { return "Pair"; }
src/builder/java/speiger/src/builder/modules/PrioQueueModule.java
+12 -11
View File
@@ -4,22 +4,23 @@ import java.util.Arrays;
import java.util.List;
import speiger.src.builder.ClassType;
import speiger.src.builder.dependency.DependencyFunction;
import speiger.src.builder.dependency.DependencyModule;
import speiger.src.builder.dependency.DependencyModule.SingleTypeModule;
import speiger.src.builder.dependency.IDependency;
import speiger.src.builder.dependencies.FunctionDependency;
import speiger.src.builder.dependencies.IDependency;
import speiger.src.builder.dependencies.ModuleDependency;
@SuppressWarnings("javadoc")
public class PrioQueueModule extends BaseModule
{
public static final BaseModule INSTANCE = new PrioQueueModule();
public static final DependencyModule MODULE = CollectionModule.MODULE.addChild(new SingleTypeModule(INSTANCE));
public static final DependencyFunction IMPLEMENTATION = MODULE.createFunction("Implementations");
public static final DependencyFunction WRAPPERS = MODULE.createFunction("Wrappers");
public static final DependencyFunction DEQUEUE = MODULE.createFunction("Dequeue");
public static final DependencyFunction FIFO_QUEUE = DEQUEUE.addChild(IMPLEMENTATION.createSubFunction("FiFoQueue"));
public static final DependencyFunction HEAP_QUEUE = IMPLEMENTATION.createSubFunction("HeapQueue");
public static final DependencyFunction ARRAY_PRIO_QUEUE = IMPLEMENTATION.createSubFunction("ArrayPrioQueue");
public static final ModuleDependency MODULE = new ModuleDependency(INSTANCE, false).addKeyDependency(CollectionModule.MODULE);
public static final FunctionDependency IMPLEMENTATION = MODULE.createDependency("Implementations");
public static final FunctionDependency WRAPPERS = MODULE.createDependency("Wrappers");
public static final FunctionDependency DEQUEUE = MODULE.createDependency("Dequeue");
public static final FunctionDependency FIFO_QUEUE = MODULE.createDependency("FiFoQueue").addKeyDependency(DEQUEUE).addKeyDependency(IMPLEMENTATION);
public static final FunctionDependency HEAP_QUEUE = MODULE.createDependency("HeapQueue").addKeyDependency(IMPLEMENTATION);
public static final FunctionDependency ARRAY_PRIO_QUEUE = MODULE.createDependency("ArrayPrioQueue").addKeyDependency(IMPLEMENTATION);
@Override
public String getModuleName() { return "PriorityQueue"; }
src/builder/java/speiger/src/builder/modules/SetModule.java
+16 -17
View File
@@ -4,28 +4,27 @@ import java.util.Arrays;
import java.util.List;
import speiger.src.builder.ClassType;
import speiger.src.builder.dependency.DependencyFunction;
import speiger.src.builder.dependency.DependencyModule;
import speiger.src.builder.dependency.DependencyModule.SingleTypeModule;
import speiger.src.builder.dependency.IDependency;
import speiger.src.builder.dependencies.FunctionDependency;
import speiger.src.builder.dependencies.IDependency;
import speiger.src.builder.dependencies.ModuleDependency;
@SuppressWarnings("javadoc")
public class SetModule extends BaseModule
{
public static final BaseModule INSTANCE = new SetModule();
public static final DependencyModule MODULE = CollectionModule.MODULE.addChild(new SingleTypeModule(INSTANCE));
public static final DependencyFunction WRAPPERS = MODULE.createFunction("Wrappers");
public static final DependencyFunction IMPLEMENTATION = MODULE.createFunction("Implementations");
public static final DependencyFunction ORDERED_SET = MODULE.createFunction("OrderedSet");
public static final DependencyFunction SORTED_SET = MODULE.createFunction("SortedSet");
public static final DependencyFunction ARRAY_SET = ORDERED_SET.addChild(IMPLEMENTATION.createSubFunction("ArraySet"));
public static final DependencyFunction IMMUTABLE_SET = IMPLEMENTATION.createSubFunction("ImmutableSet");
public static final DependencyFunction HASH_SET = IMPLEMENTATION.createSubFunction("HashSet");
public static final DependencyFunction LINKED_SET = HASH_SET.addChild(ORDERED_SET.addChild(IMPLEMENTATION.createSubFunction("LinkedHashSet")));
public static final DependencyFunction CUSTOM_SET = IMPLEMENTATION.createSubFunction("CustomHashSet");
public static final DependencyFunction LINKED_CUSTOM_SET = CUSTOM_SET.addChild(ORDERED_SET.addChild(IMPLEMENTATION.createSubFunction("LinkedCustomHashSet")));
public static final DependencyFunction AVL_TREE_SET = SORTED_SET.addChild(IMPLEMENTATION.createSubFunction("AVLTreeSet"));
public static final DependencyFunction RB_TREE_SET = SORTED_SET.addChild(IMPLEMENTATION.createSubFunction("RBTreeSet"));
public static final ModuleDependency MODULE = new ModuleDependency(INSTANCE, false).addKeyDependency(CollectionModule.MODULE).addKeyDependency(CollectionModule.SPLIT_ITERATORS);
public static final FunctionDependency IMPLEMENTATION = MODULE.createDependency("Implementations");
public static final FunctionDependency WRAPPERS = MODULE.createDependency("Wrappers");
public static final FunctionDependency ORDERED_SET = MODULE.createDependency("OrderedSet");
public static final FunctionDependency SORTED_SET = MODULE.createDependency("SortedSet");
public static final FunctionDependency ARRAY_SET = MODULE.createDependency("ArraySet").addKeyDependency(ORDERED_SET).addKeyDependency(IMPLEMENTATION);
public static final FunctionDependency IMMUTABLE_SET = MODULE.createDependency("ImmutableSet").addKeyDependency(ORDERED_SET).addKeyDependency(IMPLEMENTATION);
public static final FunctionDependency HASH_SET = MODULE.createDependency("HashSet").addKeyDependency(IMPLEMENTATION);
public static final FunctionDependency LINKED_SET = MODULE.createDependency("LinkedHashSet").addKeyDependency(ORDERED_SET).addKeyDependency(HASH_SET);
public static final FunctionDependency CUSTOM_SET = MODULE.createDependency("CustomHashSet").addKeyDependency(IMPLEMENTATION).addKeyDependency(CollectionModule.STRATEGY);
public static final FunctionDependency LINKED_CUSTOM_SET = MODULE.createDependency("LinkedCustomHashSet").addKeyDependency(ORDERED_SET).addKeyDependency(CUSTOM_SET);
public static final FunctionDependency AVL_TREE_SET = MODULE.createDependency("AVLTreeSet").addKeyDependency(SORTED_SET).addKeyDependency(IMPLEMENTATION);
public static final FunctionDependency RB_TREE_SET = MODULE.createDependency("RBTreeSet").addKeyDependency(SORTED_SET).addKeyDependency(IMPLEMENTATION);
@Override
public String getModuleName() { return "Set"; }
src/builder/resources/speiger/assets/collections/templates/collections/BidirectionalIterator.template
+2 -10
View File
@@ -1,19 +1,11 @@
package speiger.src.collections.PACKAGE.collections;
#if !TYPE_OBJECT
import speiger.src.collections.objects.collections.ObjectBidirectionalIterator;
/**
* A Type-Specific {@link ObjectBidirectionalIterator} to reduce (un)boxing
*/
public interface BI_ITERATOR KEY_GENERIC_TYPE extends ITERATOR KEY_GENERIC_TYPE, ObjectBidirectionalIterator<CLASS_TYPE>
#else
/**
* This is a basically a {@link java.util.ListIterator} without the index functions.
* Allowing to have a simple Bidirectional Iterator without having to keep track of the Iteration index.
* @Type(T)
*/
public interface BI_ITERATOR KEY_GENERIC_TYPE extends ITERATOR KEY_GENERIC_TYPE
#endif
{
/**
* Returns true if the Iterator has a Previous element
@@ -29,11 +21,11 @@ public interface BI_ITERATOR KEY_GENERIC_TYPE extends ITERATOR KEY_GENERIC_TYPE
public KEY_TYPE PREVIOUS();
#if !TYPE_OBJECT
/** {@inheritDoc}
/**
* <p>This default implementation delegates to the corresponding type-specific function.
* @deprecated Please use the corresponding type-specific function instead.
* @return the Previous element of the iterator.+
*/
@Override
@Deprecated
public default CLASS_TYPE previous() {
return KEY_TO_OBJ(PREVIOUS());
src/builder/resources/speiger/assets/collections/templates/lists/AbstractList.template
+6 -1
View File
@@ -11,11 +11,15 @@ import java.util.RandomAccess;
import speiger.src.collections.PACKAGE.collections.ABSTRACT_COLLECTION;
import speiger.src.collections.PACKAGE.collections.COLLECTION;
import speiger.src.collections.PACKAGE.collections.ITERATOR;
#if SPLIT_ITERATOR_FEATURE
import speiger.src.collections.PACKAGE.collections.SPLIT_ITERATOR;
#endif
#if INT_LIST_MODULE && !TYPE_INT
import speiger.src.collections.ints.lists.IntList;
#endif
#if SPLIT_ITERATOR_FEATURE
import speiger.src.collections.PACKAGE.utils.SPLIT_ITERATORS;
#endif
import speiger.src.collections.utils.SanityChecks;
/**
@@ -532,9 +536,10 @@ public abstract class ABSTRACT_LIST KEY_GENERIC_TYPE extends ABSTRACT_COLLECTION
public int size() {
return size;
}
#if SPLIT_ITERATOR_FEATURE
@Override
public SPLIT_ITERATOR KEY_GENERIC_TYPE spliterator() { return SPLIT_ITERATORS.createSplititerator(this, 16464); }
#endif
@Override
public LIST_ITERATOR KEY_GENERIC_TYPE listIterator(int index) {
src/builder/resources/speiger/assets/collections/templates/lists/LinkedList.template
+9 -1
View File
@@ -13,11 +13,13 @@ import java.util.Collection;
import java.util.Iterator;
import java.util.Objects;
import java.util.NoSuchElementException;
#if SPLIT_ITERATOR_FEATURE
import java.util.Spliterator;
#if PRIMITIVES
import java.util.Spliterator.JAVA_SPLIT_ITERATOR;
#endif
import java.util.function.Consumer;
#endif
import java.util.function.Predicate;
#if TYPE_OBJECT
import java.util.function.IntFunction;
@@ -60,12 +62,14 @@ import speiger.src.collections.objects.utils.ObjectArrays;
#if TYPE_OBJECT
import speiger.src.collections.utils.Stack;
#endif
#if SPLIT_ITERATOR_FEATURE
#if PRIMITIVES
import java.util.stream.JAVA_STREAM;
import java.util.stream.StreamSupport;
#endif
import speiger.src.collections.PACKAGE.collections.SPLIT_ITERATOR;
import speiger.src.collections.PACKAGE.utils.SPLIT_ITERATORS;
#endif
import speiger.src.collections.utils.SanityChecks;
/**
@@ -415,7 +419,8 @@ public class LINKED_LIST KEY_GENERIC_TYPE extends ABSTRACT_LIST KEY_GENERIC_TYPE
if(index == 0) return new ListIter(first, index);
return new ListIter(getNode(index), index);
}
#if SPLIT_ITERATOR_FEATURE
#if PRIMITIVES
/**
* Returns a Java-Type-Specific Stream to reduce boxing/unboxing.
@@ -436,6 +441,7 @@ public class LINKED_LIST KEY_GENERIC_TYPE extends ABSTRACT_LIST KEY_GENERIC_TYPE
@Override
public SPLIT_ITERATOR KEY_GENERIC_TYPE spliterator() { return new TypeSplitIteratorBRACES(this, first, 0); }
#endif
@Override
public void forEach(CONSUMER KEY_SUPER_GENERIC_TYPE action) {
Objects.requireNonNull(action);
@@ -1253,6 +1259,7 @@ public class LINKED_LIST KEY_GENERIC_TYPE extends ABSTRACT_LIST KEY_GENERIC_TYPE
}
}
#if SPLIT_ITERATOR_FEATURE
private static class TypeSplitIterator KEY_GENERIC_TYPE implements SPLIT_ITERATOR KEY_GENERIC_TYPE
{
static final int BATCH_UNIT = 1 << 10;
@@ -1397,4 +1404,5 @@ public class LINKED_LIST KEY_GENERIC_TYPE extends ABSTRACT_LIST KEY_GENERIC_TYPE
}
}
#endif
#endif
}
src/builder/resources/speiger/assets/collections/templates/lists/List.template
+6
View File
@@ -15,7 +15,9 @@ import java.util.function.UnaryOperator;
#endif
import speiger.src.collections.PACKAGE.collections.COLLECTION;
#if SPLIT_ITERATOR_FEATURE
import speiger.src.collections.PACKAGE.collections.SPLIT_ITERATOR;
#endif
import speiger.src.collections.ints.functions.consumer.BI_FROM_INT_CONSUMER;
#if !TYPE_OBJECT
import speiger.src.collections.PACKAGE.functions.COMPARATOR;
@@ -27,7 +29,9 @@ import speiger.src.collections.PACKAGE.utils.LISTS;
#if INT_LIST_MODULE && !TYPE_INT
import speiger.src.collections.ints.lists.IntList;
#endif
#if SPLIT_ITERATOR_FEATURE
import speiger.src.collections.PACKAGE.utils.SPLIT_ITERATORS;
#endif
#if TYPE_BYTE || TYPE_SHORT || TYPE_CHAR || TYPE_FLOAT
import speiger.src.collections.utils.SanityChecks;
#endif
@@ -594,10 +598,12 @@ public interface LIST KEY_GENERIC_TYPE extends COLLECTION KEY_GENERIC_TYPE, List
}
#endif
#endif
#if SPLIT_ITERATOR_FEATURE
/**
* A Type Specific Type Splititerator to reduce boxing/unboxing
* @return type specific splititerator
*/
@Override
default SPLIT_ITERATOR KEY_GENERIC_TYPE spliterator() { return SPLIT_ITERATORS.createSplititerator(this, 0); }
#endif
}
src/builder/resources/speiger/assets/collections/templates/sets/NavigableSet.template
+5 -1
View File
@@ -3,11 +3,13 @@ package speiger.src.collections.PACKAGE.sets;
import java.util.NavigableSet;
import speiger.src.collections.PACKAGE.collections.BI_ITERATOR;
#if SPLIT_ITERATOR_FEATURE
import speiger.src.collections.PACKAGE.collections.SPLIT_ITERATOR;
import speiger.src.collections.PACKAGE.utils.SPLIT_ITERATORS;
#endif
#if SETS_FEATURE
import speiger.src.collections.PACKAGE.utils.SETS;
#endif
import speiger.src.collections.PACKAGE.utils.SPLIT_ITERATORS;
/**
* A Type Specific Navigable Set interface with a couple helper methods
@@ -145,6 +147,7 @@ public interface NAVIGABLE_SET KEY_GENERIC_TYPE extends NavigableSet<CLASS_TYPE>
public default NAVIGABLE_SET KEY_GENERIC_TYPE unmodifiable() { return SETS.unmodifiable(this); }
#endif
#if SPLIT_ITERATOR_FEATURE
/**
* A Type Specific Type Splititerator to reduce boxing/unboxing
* @return type specific splititerator
@@ -152,6 +155,7 @@ public interface NAVIGABLE_SET KEY_GENERIC_TYPE extends NavigableSet<CLASS_TYPE>
@Override
default SPLIT_ITERATOR KEY_GENERIC_TYPE spliterator() { return SPLIT_ITERATORS.createSplititerator(this, 0); }
#endif
#if !TYPE_OBJECT
@Override
@Deprecated
src/builder/resources/speiger/assets/collections/templates/sets/OrderedSet.template
+5 -1
View File
@@ -1,11 +1,13 @@
package speiger.src.collections.PACKAGE.sets;
import speiger.src.collections.PACKAGE.collections.BI_ITERATOR;
#if SPLIT_ITERATOR_FEATURE
import speiger.src.collections.PACKAGE.collections.SPLIT_ITERATOR;
import speiger.src.collections.PACKAGE.utils.SPLIT_ITERATORS;
#endif
#if SETS_FEATURE
import speiger.src.collections.PACKAGE.utils.SETS;
#endif
import speiger.src.collections.PACKAGE.utils.SPLIT_ITERATORS;
/**
* A Special Set Interface giving Access to some really usefull functions
@@ -61,6 +63,7 @@ public interface ORDERED_SET KEY_GENERIC_TYPE extends SET KEY_GENERIC_TYPE
*/
public BI_ITERATOR KEY_GENERIC_TYPE iterator(KEY_TYPE fromElement);
#if SPLIT_ITERATOR_FEATURE
/**
* A Type Specific Type Splititerator to reduce boxing/unboxing
* @return type specific splititerator
@@ -68,6 +71,7 @@ public interface ORDERED_SET KEY_GENERIC_TYPE extends SET KEY_GENERIC_TYPE
@Override
default SPLIT_ITERATOR KEY_GENERIC_TYPE spliterator() { return SPLIT_ITERATORS.createSplititerator(this, 0); }
#endif
/**
* A method to get the first element in the set
* @return first element in the set
src/builder/resources/speiger/assets/collections/templates/sets/Set.template
+6 -2
View File
@@ -4,11 +4,13 @@ import java.util.Set;
import speiger.src.collections.PACKAGE.collections.COLLECTION;
import speiger.src.collections.PACKAGE.collections.ITERATOR;
#if SPLIT_ITERATOR_FEATURE
import speiger.src.collections.PACKAGE.collections.SPLIT_ITERATOR;
import speiger.src.collections.PACKAGE.utils.SPLIT_ITERATORS;
#endif
#if SETS_FEATURE
import speiger.src.collections.PACKAGE.utils.SETS;
#endif
import speiger.src.collections.PACKAGE.utils.SPLIT_ITERATORS;
/**
@@ -88,10 +90,12 @@ public interface SET KEY_GENERIC_TYPE extends Set<CLASS_TYPE>, COLLECTION KEY_GE
public default SET KEY_GENERIC_TYPE unmodifiable() { return SETS.unmodifiable(this); }
#endif
#if SPLIT_ITERATOR_FEATURE
/**
* A Type Specific Type Splititerator to reduce boxing/unboxing
* @return type specific splititerator
*/
@Override
default SPLIT_ITERATOR KEY_GENERIC_TYPE spliterator() { return SPLIT_ITERATORS.createSplititerator(this, 0); }
}
#endif
}
src/builder/resources/speiger/assets/collections/templates/sets/SortedSet.template
+6
View File
@@ -3,7 +3,9 @@ package speiger.src.collections.PACKAGE.sets;
import java.util.SortedSet;
import speiger.src.collections.PACKAGE.collections.BI_ITERATOR;
#if SPLIT_ITERATOR_FEATURE
import speiger.src.collections.PACKAGE.collections.SPLIT_ITERATOR;
#endif
#if TYPE_OBJECT
import java.util.Comparator;
#else
@@ -12,7 +14,9 @@ import speiger.src.collections.PACKAGE.functions.COMPARATOR;
#if SETS_FEATURE
import speiger.src.collections.PACKAGE.utils.SETS;
#endif
#if SPLIT_ITERATOR_FEATURE
import speiger.src.collections.PACKAGE.utils.SPLIT_ITERATORS;
#endif
/**
* A Type Specific SortedSet implementation to reduce boxing/unboxing
@@ -67,6 +71,7 @@ public interface SORTED_SET KEY_GENERIC_TYPE extends SET KEY_GENERIC_TYPE, Sorte
public default SORTED_SET KEY_GENERIC_TYPE unmodifiable() { return SETS.unmodifiable(this); }
#endif
#if SPLIT_ITERATOR_FEATURE
/**
* A Type Specific Type Splititerator to reduce boxing/unboxing
* @return type specific splititerator
@@ -74,6 +79,7 @@ public interface SORTED_SET KEY_GENERIC_TYPE extends SET KEY_GENERIC_TYPE, Sorte
@Override
default SPLIT_ITERATOR KEY_GENERIC_TYPE spliterator() { return SPLIT_ITERATORS.createSplititerator(this, 0); }
#endif
#if !TYPE_OBJECT
/**
* A Type Specific SubSet method to reduce boxing/unboxing
src/builder/resources/speiger/assets/collections/templates/utils/Iterators.template
+1 -1
View File
@@ -25,7 +25,7 @@ import speiger.src.collections.booleans.collections.BooleanIterator;
#argument PACKAGE bytes shorts ints longs floats doubles
#argument MAPPER ToByteFunction ToShortFunction ToIntFunction ToLongFunction ToFloatFunction ToDoubleFunction
#argument FILTER_TYPE BYTE_COLLECTION_MODULE SHORT_COLLECTION_MODULE INT_COLLECTION_MODULE LONG_COLLECTION_MODULE FLOAT_COLLECTION_MODULE DOUBLE_COLLECTION_MODULE
#if BOOLEAN_COLLECTION_MODULE
#if FILTER_TYPE
import speiger.src.collections.objects.functions.function.MAPPER;
import speiger.src.collections.PACKAGE.collections.ITERATOR;
#endif