Fixing a few things and testing more. Not useable atm.

The idea behind this system is that you can select systems a lot easier.
So if a custom system isn't required it can be disabled and all the
subsystems that require it either get disabled too.
it also allows you to set systems as: Only if they are required. Meaning
if only a specific system is required its dependencies can still load.

Changelog.md

@@ -1,21 +1,5 @@
 # Changelog of versions
 
-### Version 0.9.0
-- Added: getFirst/getLast/removeFirst/removeLast to List.class.
-- Added: Dedicated Set toArray implementations.
-- Added: ToArray/pushTop functions to Stack.class.
-- Added: ComputeNonDefault functions which will contain the current behavior of the Compute function, while the Compute will be changed to be more java compliant!
-- Added: List.reversed, which returns a SubList that has all elements in reversed order and also inserts reversed.
-- Added: Iterators.infinite as an option that will create a Infinite Iterator based on the inputed one.
-- Added: List.indexedIterator which allows you to create a iterator with a customized iteration indecies. Useful if you want to transform lists output.
-- Added: PriorityQueue.contains is now a function
-- Added: Iterators/Async Builders now support MapToPrimitiveType function on the object variant. So more processing can be done. (Will be expanded upon later versions)
-- Fixed: SetValue wasn't working on forEach implementations.
-- Fixed: Compute functions now perform with primitives more java compliant. Meaning that getDefaultReturnValue function no longer is seen as null.
-- Fixed: Supplier was using the wrong dataType in their function name.
-- Updated: SimpleCodeGenerator 1.3.0 is now being used which allows for iterative code support.
-- Breaking Change: Map.compute/IfAbsent/Present and Map.supplyIfAbsent if the value is a primitive it will no longer accept the defaultReturnValue() as "null" if that functionality is desired then use: computeNonDefault which contains the functionality!
-
 ### Version 0.8.1
 - Added: getFirst/getLast/removeFirst/removeLast to List.class.
 - Added: Dedicated Set toArray implementations.

EXTRAS.md

@@ -30,13 +30,10 @@ 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" can be defined as "Enabled" or "Disabled" using the "Default" argument.     
-If "Default" is missing, then it will just default to "Enabled".    
+Any Setting that isn't "Present" is counted as "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:
 ```

README.md

@@ -1,6 +1,5 @@
 ![build](https://github.com/Speiger/Primitive-Collections/actions/workflows/build_action.yml/badge.svg)
 [![Latest Release](https://jitpack.io/v/Speiger/Primitive-Collections.svg)](https://jitpack.io/#Speiger/Primitive-Collections)
-![Maven Central Version](https://img.shields.io/maven-central/v/io.github.speiger/Primitive-Collections)
 [![License](https://img.shields.io/badge/License-Apache_2.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)
 ![GitHub commit activity](https://img.shields.io/github/commit-activity/m/Speiger/Primitive-Collections)      
 ![Unit Tests](https://github.com/Speiger/Primitive-Collections/actions/workflows/build_tests_action.yml/badge.svg)
@@ -44,7 +43,7 @@ To ensure that problems can be dealt with even if it is breaking the current API
 
 # How to install
 Using Jitpack Gradle
-```groovy
+```gradle
 repositories {
     maven {
         url = "https://jitpack.io"
@@ -55,13 +54,6 @@ dependencies {
 }
 ```
 
-Using Maven Central
-```groovy
-dependencies {
-	implementation 'io.github.speiger:Primitive-Collections:0.9.0'
-}
-```
-
 # SourceCode
 The generated Sourcecode can be automatically build,    
 but if you want to just browse around in it.    

SECURITY.md

@@ -1,15 +0,0 @@
-# Security Policy
-
-## Supported Versions
-
-Due to how the releases work, only the latest versions will be supported.
-
-## Reporting a Vulnerability
-
-If you have discovered a security vulnerability in this project, please report it privately.     
-**Please refrain from posting in public issues.**     
-This gives me time to process issues that are being found, and reduces the possiblity of abuse while patches are being created.   
-Please disclose it [here](https://github.com/Speiger/Primitive-Collections/security/advisories/new).
-
-Please consider that this project is developed by a single person.    
-So please provide a reasonable timeframe when reporting.    

build.gradle

@@ -1,7 +1,6 @@
 plugins {
     id 'java-library'
     id "jacoco"
-//	id "com.vanniktech.maven.publish" version "0.28.0"
 }
 
 tasks.withType(JavaCompile) {
@@ -11,7 +10,6 @@ tasks.withType(JavaCompile) {
 apply plugin: 'java'
 apply plugin: 'eclipse'
 apply plugin: 'maven-publish'
-apply plugin: 'signing'
 
 repositories {
     mavenCentral()
@@ -21,17 +19,12 @@ repositories {
 }
 
 archivesBaseName = 'Primitive Collections'
-version = RELEASE_VERSION;
+version = '0.9.0';
 
 sourceCompatibility = targetCompatibility = compileJava.sourceCompatibility = compileJava.targetCompatibility = JavaVersion.current();
 
 System.out.println("Java Version: "+compileJava.sourceCompatibility)
 
-java {
-	withJavadocJar()
-    withSourcesJar()
-}
-
 javadoc {
     options.tags = [ "implSpec", "note" ] 
 }
@@ -106,12 +99,26 @@ task generateLimitSource(type: JavaExec) {
  	args = ['silent', 'load']
 }
 
+task javadocJar(type: Jar) {
+    from javadoc
+    archiveClassifier = 'javadoc'
+}
+
+task srcJar(type: Jar) {
+    from sourceSets.main.allSource
+    archiveClassifier = 'sources'
+}
+
 compileJava.dependsOn generateGithubSource
 
 javadoc.failOnError = false
 javadoc.options.memberLevel = JavadocMemberLevel.PUBLIC
 javadoc.options.quiet()
 
+artifacts {
+    archives javadocJar
+    archives srcJar
+}
 
 task testBooleans(type: Test) {
 	group 'tests'
@@ -261,10 +268,13 @@ jacocoTestReport {
     }
 }
 
-
 publishing {
+	Properties props = new Properties()
+	if(file("$buildDir/credentials.properties").exists()) {
+		props.load(new FileInputStream("$buildDir/credentials.properties"))
+	}
 	publications {
-		personal(MavenPublication) {
+		mavenJava(MavenPublication) {
 			pom {
 				name = 'Primitive Collections'
 				description = 'A Primitive Collection library that reduces memory usage and improves performance'
@@ -273,6 +283,8 @@ publishing {
 				artifactId = project.archivesBaseName.replace(" ", "-")
 				groupId = 'de.speiger'
 				from components.java
+				artifact tasks.srcJar
+				artifact tasks.javadocJar
 				licenses {
 					license {
 						name = 'The Apache License, Version 2.0'
@@ -297,83 +309,11 @@ publishing {
 	}
 	repositories {
 		maven {
-			name = "Speiger_Maven"
-			def auth = System.getenv("Speiger_Maven_Auth")?.split(';');
 			url version.endsWith('SNAPSHOT') ? "https://maven.speiger.com/repository/debug" : "https://maven.speiger.com/repository/main"
 			credentials(PasswordCredentials) {
-				username auth?[0]
-				password auth?[1]
+				username props.mavenUser
+				password props.mavenPassword
 			}
 		}
 	}
 }
-
-tasks.withType(PublishToMavenRepository) {
-    def predicate = provider {
-        (repository == publishing.repositories.mavenCentral && publication == publishing.publications.maven) ||
-        (repository != publishing.repositories.mavenCentral && publication != publishing.publications.maven)
-    }
-    onlyIf("publishing binary to the external repository, or binary and sources to the internal one") {
-        predicate.get()
-    }
-}
-
-tasks.withType(PublishToMavenLocal) {
-    def predicate = provider {
-        publication == publishing.publications.personal
-    }
-    onlyIf("publishing binary and sources") {
-        predicate.get()
-    }
-}
-
-//Maven central Start
-//Disabling due to java8 incompat, only needed to manually publishing anyways
-
-//signing.useGpgCmd()
-//
-//import com.vanniktech.maven.publish.SonatypeHost
-//import com.vanniktech.maven.publish.JavaLibrary
-//import com.vanniktech.maven.publish.JavadocJar
-//
-//mavenPublishing {
-//  configure(new JavaLibrary(new JavadocJar.None(), true))
-//}
-//
-//mavenPublishing {
-//    publishToMavenCentral(SonatypeHost.CENTRAL_PORTAL)
-//
-//    signAllPublications()
-//    pom {
-//		name = 'Primitive Collections'
-//		description = 'A Primitive Collection library that reduces memory usage and improves performance'
-//		url = 'https://github.com/Speiger/Primitive-Collections'
-//		version = project.version	
-//		group = 'io.github.speiger'
-//        licenses {
-//            license {
-//				name = 'The Apache License, Version 2.0'
-//				url = 'http://www.apache.org/licenses/LICENSE-2.0.txt'
-//            }
-//        }
-//
-//        developers {
-//			developer {
-//				id = 'speiger'
-//				name = 'Speiger'
-//			}
-//        }
-//
-//        scm {
-//            connection = 'scm:git:git://github.com/Speiger/Primitive-Collections.git'
-//            developerConnection = 'scm:git:ssh://github.com:Speiger/Primitive-Collections.git'
-//            url = 'https://github.com/Speiger/Primitive-Collections'
-//        }
-//                
-//        issueManagement {
-//			system = 'github'
-//			url = 'https://github.com/Speiger/Primitive-Collections/issues'
-//		}
-//    }
-//}
-//

gradle.properties

@@ -1,6 +1,4 @@
 org.gradle.jvmargs=-Xmx3G
 
 maxMemory = 1024m
-testThreads = 4
-
-RELEASE_VERSION = 0.9.0
+testThreads = 2

src/builder/java/speiger/src/builder/PrimitiveCollectionsBuilder.java

@@ -133,6 +133,7 @@ public class PrimitiveCollectionsBuilder extends TemplateProcessor
 			biPackages.forEach(modules.get(i)::init);
 		}
 		modules.forEach(BaseModule::cleanup);
+		manager.printModuleSettings(Arrays.asList(MapModule.INSTANCE));
 	}
 	
 	private void finishPackages()  {
@@ -213,7 +214,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

@@ -5,71 +5,37 @@ 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.dependencies.IDependency;
-import speiger.src.builder.dependencies.IDependency.LoadingState;
+import speiger.src.builder.dependency.IDependency;
 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() {
-		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);
+		boolean valid = true;
+		for(int i = 0;i<10000 && valid;i++) {
+			boolean result = false;
+			for(IDependency entry : allDependencies) {
+				result |= entry.resolveDependencies();
 			}
+			valid = result;
 		}
-		/**
-		 * 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));
-		}
+		if(valid) throw new RuntimeException("Couldn't resolve dependencies!");
 	}
 	
 	public void addModule(BaseModule module) {
@@ -79,7 +45,7 @@ public class SettingsManager
 					for(ClassType valueType : ModulePackage.TYPE) {
 						if(!module.isModuleValid(keyType, valueType)) continue;
 						for(IDependency dependency : module.getDependencies(keyType, valueType)) {
-							dependency.set(parsedData);
+							dependency.load(data, keyType, valueType);
 							allDependencies.add(dependency);
 						}
 					}
@@ -89,7 +55,7 @@ public class SettingsManager
 			for(ClassType keyType : ModulePackage.TYPE) {
 				if(!module.isModuleValid(keyType, keyType)) continue;
 				for(IDependency dependency : module.getDependencies(keyType, keyType)) {
-					dependency.set(parsedData);
+					dependency.load(data, keyType, keyType);
 					allDependencies.add(dependency);
 				}
 			}
@@ -106,6 +72,7 @@ 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);
 				}
@@ -118,6 +85,7 @@ 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);			
 		}
@@ -134,7 +102,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.isLoaded(keyType, valueType).getJsonResult());
+							if(key != null) obj.addProperty(key, dependency.getState(keyType, valueType).getJsonResult());
 						}
 						addModule(data, keyType, valueType, true, moduleName, obj);
 					}
@@ -146,7 +114,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.isLoaded(keyType, keyType).getJsonResult());
+					if(key != null) obj.addProperty(key, dependency.getState(keyType, keyType).getJsonResult());
 				}
 				addModule(data, keyType, keyType, false, moduleName, obj);			
 			}
@@ -167,9 +135,6 @@ 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

@@ -1,137 +0,0 @@
-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

@@ -1,29 +0,0 @@
-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

@@ -1,104 +0,0 @@
-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

@@ -1,31 +0,0 @@
-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

@@ -1,68 +0,0 @@
-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

@@ -0,0 +1,49 @@
+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

@@ -0,0 +1,131 @@
+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

@@ -0,0 +1,170 @@
+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

@@ -0,0 +1,42 @@
+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

@@ -0,0 +1,41 @@
+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

@@ -0,0 +1,51 @@
+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,14 +4,16 @@ import java.util.Arrays;
 import java.util.List;
 
 import speiger.src.builder.ClassType;
-import speiger.src.builder.dependencies.IDependency;
-import speiger.src.builder.dependencies.ModuleDependency;
+import speiger.src.builder.dependency.DependencyModule;
+import speiger.src.builder.dependency.DependencyModule.SingleTypeModule;
+import speiger.src.builder.dependency.IDependency;
 
 @SuppressWarnings("javadoc")
 public class AsyncModule extends BaseModule
 {
 	public static final BaseModule INSTANCE = new AsyncModule();
-	public static final ModuleDependency MODULE = new ModuleDependency(INSTANCE, false).addKeyDependency(JavaModule.MODULE);
+	public static final DependencyModule MODULE = CollectionModule.MODULE.addChild(new SingleTypeModule(INSTANCE));
+	
 	
 	@Override
 	public String getModuleName() { return "Async"; }
@@ -27,7 +29,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

@@ -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.dependencies.IDependency;
+import speiger.src.builder.dependency.IDependency;
 import speiger.src.builder.mappers.ArgumentMapper;
 import speiger.src.builder.mappers.InjectMapper;
 import speiger.src.builder.mappers.LineMapper;
@@ -32,9 +32,6 @@ 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

@@ -4,23 +4,20 @@ import java.util.Arrays;
 import java.util.List;
 
 import speiger.src.builder.ClassType;
-import speiger.src.builder.dependencies.FunctionDependency;
-import speiger.src.builder.dependencies.IDependency;
-import speiger.src.builder.dependencies.ModuleDependency;
+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;
 
 @SuppressWarnings("javadoc")
 public class CollectionModule extends BaseModule
 {
 	public static final BaseModule INSTANCE = new CollectionModule();
-	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");
+	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");
 	
 	@Override
 	public String getModuleName() { return "Collection"; }

src/builder/java/speiger/src/builder/modules/FunctionModule.java

@@ -5,14 +5,15 @@ import java.util.List;
 
 import speiger.src.builder.ClassType;
 import speiger.src.builder.RequiredType;
-import speiger.src.builder.dependencies.IDependency;
-import speiger.src.builder.dependencies.ModuleDependency;
+import speiger.src.builder.dependency.DependencyModule;
+import speiger.src.builder.dependency.IDependency;
+import speiger.src.builder.dependency.DependencyModule.BiTypeModule;
 
 @SuppressWarnings("javadoc")
 public class FunctionModule extends BaseModule
 {
 	public static final BaseModule INSTANCE = new FunctionModule();
-	public static final ModuleDependency MODULE = new ModuleDependency(INSTANCE, false).addKeyDependency(JavaModule.MODULE);
+	public static final DependencyModule MODULE = new BiTypeModule(INSTANCE);
 	
 	@Override
 	public String getModuleName() { return "Function"; }
@@ -34,7 +35,6 @@ 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

@@ -4,14 +4,15 @@ import java.util.Arrays;
 import java.util.List;
 
 import speiger.src.builder.ClassType;
-import speiger.src.builder.dependencies.IDependency;
-import speiger.src.builder.dependencies.ModuleDependency;
+import speiger.src.builder.dependency.DependencyBase;
+import speiger.src.builder.dependency.IDependency;
+import speiger.src.builder.dependency.DependencyModule.SingleTypeModule;
 
 @SuppressWarnings("javadoc")
 public class JavaModule extends BaseModule
 {
 	public static final BaseModule INSTANCE = new JavaModule();
-	public static final ModuleDependency MODULE = new ModuleDependency(INSTANCE, false);
+	public static final DependencyBase MODULE = new SingleTypeModule(INSTANCE);
 	
 	@Override
 	public String getModuleName() { return "Base"; }

src/builder/java/speiger/src/builder/modules/ListModule.java

@@ -4,21 +4,22 @@ import java.util.Arrays;
 import java.util.List;
 
 import speiger.src.builder.ClassType;
-import speiger.src.builder.dependencies.FunctionDependency;
-import speiger.src.builder.dependencies.IDependency;
-import speiger.src.builder.dependencies.ModuleDependency;
+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;
 
 @SuppressWarnings("javadoc")
 public class ListModule extends BaseModule
 {
 	public static final BaseModule INSTANCE = new ListModule();
-	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);
+	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");
 
 	@Override
 	public String getModuleName() { return "List"; }

src/builder/java/speiger/src/builder/modules/MapModule.java

@@ -1,44 +1,40 @@
 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.dependencies.FunctionDependency;
-import speiger.src.builder.dependencies.IDependency;
-import speiger.src.builder.dependencies.ModuleDependency;
+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;
 
 @SuppressWarnings("javadoc")
 public class MapModule extends BaseModule
 {
 	public static final BaseModule INSTANCE = new MapModule();
-	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);
+	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"));
 	
 	@Override
 	public String getModuleName() { return "Map"; }
@@ -49,11 +45,7 @@ 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) {
-		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;
-	}
+	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); }
 	
 	@Override
 	protected void loadFlags()
@@ -87,7 +79,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

@@ -4,22 +4,18 @@ import java.util.Arrays;
 import java.util.List;
 
 import speiger.src.builder.ClassType;
-import speiger.src.builder.dependencies.FunctionDependency;
-import speiger.src.builder.dependencies.IDependency;
-import speiger.src.builder.dependencies.ModuleDependency;
+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;
 
 @SuppressWarnings("javadoc")
 public class PairModule extends BaseModule
 {
 	public static final BaseModule INSTANCE = new PairModule();
-	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");
+	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

@@ -4,23 +4,22 @@ import java.util.Arrays;
 import java.util.List;
 
 import speiger.src.builder.ClassType;
-import speiger.src.builder.dependencies.FunctionDependency;
-import speiger.src.builder.dependencies.IDependency;
-import speiger.src.builder.dependencies.ModuleDependency;
+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;
 
 @SuppressWarnings("javadoc")
 public class PrioQueueModule extends BaseModule
 {
 	public static final BaseModule INSTANCE = new PrioQueueModule();
-	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);
-	
+	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");
 	
 	@Override
 	public String getModuleName() { return "PriorityQueue"; }

src/builder/java/speiger/src/builder/modules/SetModule.java

@@ -4,27 +4,28 @@ import java.util.Arrays;
 import java.util.List;
 
 import speiger.src.builder.ClassType;
-import speiger.src.builder.dependencies.FunctionDependency;
-import speiger.src.builder.dependencies.IDependency;
-import speiger.src.builder.dependencies.ModuleDependency;
+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;
 
 @SuppressWarnings("javadoc")
 public class SetModule extends BaseModule
 {
 	public static final BaseModule INSTANCE = new SetModule();
-	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);
+	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"));
 	
 	@Override
 	public String getModuleName() { return "Set"; }

src/builder/resources/speiger/assets/collections/templates/collections/BidirectionalIterator.template

@@ -1,11 +1,19 @@
 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
@@ -21,11 +29,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

@@ -11,15 +11,11 @@ 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;
 
 /**
@@ -536,10 +532,9 @@ 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

@@ -13,13 +13,11 @@ 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;
@@ -62,14 +60,12 @@ 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;
 
 /**
@@ -420,7 +416,6 @@ public class LINKED_LIST KEY_GENERIC_TYPE extends ABSTRACT_LIST KEY_GENERIC_TYPE
 		return new ListIter(getNode(index), index);
 	}
 	
-#if SPLIT_ITERATOR_FEATURE
 #if PRIMITIVES
 	/**
 	 * Returns a Java-Type-Specific Stream to reduce boxing/unboxing.
@@ -441,7 +436,6 @@ 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);
@@ -1259,7 +1253,6 @@ 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;
@@ -1404,5 +1397,4 @@ 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

@@ -15,9 +15,7 @@ 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;
@@ -29,9 +27,7 @@ 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
@@ -598,12 +594,10 @@ 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

@@ -3,13 +3,11 @@ 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
@@ -147,7 +145,6 @@ 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
@@ -155,7 +152,6 @@ 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

@@ -1,13 +1,11 @@
 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
@@ -63,7 +61,6 @@ 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
@@ -71,7 +68,6 @@ 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

@@ -4,13 +4,11 @@ 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;
 
 
 /**
@@ -90,12 +88,10 @@ 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

@@ -3,9 +3,7 @@ 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
@@ -14,9 +12,7 @@ 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
@@ -71,7 +67,6 @@ 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
@@ -79,7 +74,6 @@ 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/Iterables.template

@@ -342,8 +342,6 @@ public class ITERABLES
 #argument MAPPER Predicate ToByteFunction ToShortFunction ToIntFunction ToLongFunction ToFloatFunction ToDoubleFunction
 #argument APPLY test applyAsByte applyAsShort applyAsInt applyAsLong applyAsFloat applyAsDouble
 #argument DATA_TYPE Boolean Byte Short Int Long Float Double
-#argument FILTER_TYPE BOOLEAN_COLLECTION_MODULE BYTE_COLLECTION_MODULE SHORT_COLLECTION_MODULE INT_COLLECTION_MODULE LONG_COLLECTION_MODULE FLOAT_COLLECTION_MODULE DOUBLE_COLLECTION_MODULE
-#if FILTER_TYPE
 	private static class MAPPED_TYPEIterable<E> implements OUTPUT_ITERABLE, ISizeProvider
 	{
 		ITERABLE KEY_SPECIAL_GENERIC_TYPE<E> iterable;
@@ -371,7 +369,6 @@ public class ITERABLES
 		}
 	}
 	
-#endif
 #enditerate
 #endif
 	private static class MappedIterable KSS_GENERIC_TYPE<E, T> implements ObjectIterable<T>, ISizeProvider

src/builder/resources/speiger/assets/collections/templates/utils/Iterators.template

@@ -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 FILTER_TYPE
+#if BOOLEAN_COLLECTION_MODULE
 import speiger.src.collections.objects.functions.function.MAPPER;
 import speiger.src.collections.PACKAGE.collections.ITERATOR;
 #endif
@@ -925,8 +925,6 @@ public class ITERATORS
 #argument MAPPER Predicate ToByteFunction ToShortFunction ToIntFunction ToLongFunction ToFloatFunction ToDoubleFunction
 #argument APPLY test applyAsByte applyAsShort applyAsInt applyAsLong applyAsFloat applyAsDouble
 #argument DATA_TYPE boolean byte short int long float double
-#argument FILTER_TYPE BOOLEAN_COLLECTION_MODULE BYTE_COLLECTION_MODULE SHORT_COLLECTION_MODULE INT_COLLECTION_MODULE LONG_COLLECTION_MODULE FLOAT_COLLECTION_MODULE DOUBLE_COLLECTION_MODULE
-#if FILTER_TYPE
 	private static class MAPPED_TYPEIterator<E> implements OUTPUT_ITERATOR
 	{
 		ITERATOR<E> iterator;
@@ -953,7 +951,6 @@ public class ITERATORS
 		}
 	}
 	
-#endif
 #enditerate
 #endif
 	private static class FlatMappedIterator KSS_GENERIC_TYPE<E, T,[SPACE]V extends Iterable<T>> implements ObjectIterator<T>