KitsuneAlex/Primitive-Collections
1
0
Fork 0
forked from Speiger/Primitive-Collections
Code Issues Pull Requests Projects Releases 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
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
EXTRAS.md
View File

@ -30,10 +30,13 @@ There is 3 layers of control inside of the ModuleSettings.
Allowing for greater control without having to edit hundreds of lines of code.
On top of that:
Any Setting that isn't "Present" is counted as "Enabled".
Any Setting that isn't "Present" can be defined as "Enabled" or "Disabled" using the "Default" argument.
If "Default" is missing, then it will just default to "Enabled".
So if you want to disable just 1 thing you can keep that 1 thing and delete the rest of the Setting.
It will still work as the same.
The default settings just come with everything so you can see what is controllable.
Note: If a global Module setting is disabled but a dependency needs said Module, it will enable only the required classes.
If a Module type (Float-Collection as example) is specifically disabled, the Dependency Resolver will throw errors telling you whats wrong.
How to compile the Code with the ModuleSettings enabled:
```

2635
ModulSettings.json
View File

File diff suppressed because it is too large Load Diff

3
src/builder/java/speiger/src/builder/PrimitiveCollectionsBuilder.java
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);

63
src/builder/java/speiger/src/builder/SettingsManager.java
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(); }
}

137
src/builder/java/speiger/src/builder/dependencies/BaseDependency.java Normal file
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;
}
}

29
src/builder/java/speiger/src/builder/dependencies/FunctionDependency.java Normal file
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;
}
}

104
src/builder/java/speiger/src/builder/dependencies/IDependency.java Normal file
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;
}
}
}

31
src/builder/java/speiger/src/builder/dependencies/ModuleDependency.java Normal file
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));
}
}

68
src/builder/java/speiger/src/builder/dependencies/Requirements.java Normal file
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);
}
}
}

49
src/builder/java/speiger/src/builder/dependency/DependencyBase.java
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;
}
}

131
src/builder/java/speiger/src/builder/dependency/DependencyFunction.java
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);
}
}
}
}

170
src/builder/java/speiger/src/builder/dependency/DependencyModule.java
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;
}
}

42
src/builder/java/speiger/src/builder/dependency/DependencyType.java
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() {
}
}

41
src/builder/java/speiger/src/builder/dependency/DependencyValue.java
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() {
}
}

51
src/builder/java/speiger/src/builder/dependency/IDependency.java
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;
}
}
}

10
src/builder/java/speiger/src/builder/modules/AsyncModule.java
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");
}
}

5
src/builder/java/speiger/src/builder/modules/BaseModule.java
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();

21
src/builder/java/speiger/src/builder/modules/CollectionModule.java
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"; }

8
src/builder/java/speiger/src/builder/modules/FunctionModule.java
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

7
src/builder/java/speiger/src/builder/modules/JavaModule.java
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"; }

23
src/builder/java/speiger/src/builder/modules/ListModule.java
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

64
src/builder/java/speiger/src/builder/modules/MapModule.java
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");

18
src/builder/java/speiger/src/builder/modules/PairModule.java
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"; }

23
src/builder/java/speiger/src/builder/modules/PrioQueueModule.java
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"; }

33
src/builder/java/speiger/src/builder/modules/SetModule.java
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"; }

12
src/builder/resources/speiger/assets/collections/templates/collections/BidirectionalIterator.template
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());

7
src/builder/resources/speiger/assets/collections/templates/lists/AbstractList.template
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) {

10
src/builder/resources/speiger/assets/collections/templates/lists/LinkedList.template
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
}

6
src/builder/resources/speiger/assets/collections/templates/lists/List.template
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
}

6
src/builder/resources/speiger/assets/collections/templates/sets/NavigableSet.template
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

6
src/builder/resources/speiger/assets/collections/templates/sets/OrderedSet.template
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

8
src/builder/resources/speiger/assets/collections/templates/sets/Set.template
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
}

6
src/builder/resources/speiger/assets/collections/templates/sets/SortedSet.template
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

2
src/builder/resources/speiger/assets/collections/templates/utils/Iterators.template
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